PropertyStream.h

//------------------------------------------------------------------------------
/*
    This file is part of Beast: https://github.com/vinniefalco/Beast
    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
 
    Permission to use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#ifndef BEAST_UTILITY_PROPERTYSTREAM_H_INCLUDED
#define BEAST_UTILITY_PROPERTYSTREAM_H_INCLUDED
 
#include <ripple/beast/core/List.h>
 
#include <cstdint>
#include <mutex>
#include <sstream>
#include <string>
#include <utility>
 
namespace beast {
 
//------------------------------------------------------------------------------
 
class PropertyStream
{
public:
    class Map;
    class Set;
    class Source;
 
    PropertyStream() = default;
    virtual ~PropertyStream() = default;
 
protected:
    virtual void
    map_begin() = 0;
    virtual void
    map_begin(std::string const& key) = 0;
    virtual void
    map_end() = 0;
 
    virtual void
    add(std::string const& key, std::string const& value) = 0;
 
    void
    add(std::string const& key, char const* value)
    {
        add(key, std::string(value));
    }
 
    template <typename Value>
    void
    lexical_add(std::string const& key, Value value)
    {
        std::stringstream ss;
        ss << value;
        add(key, ss.str());
    }
 
    virtual void
    add(std::string const& key, bool value);
    virtual void
    add(std::string const& key, char value);
    virtual void
    add(std::string const& key, signed char value);
    virtual void
    add(std::string const& key, unsigned char value);
    virtual void
    add(std::string const& key, short value);
    virtual void
    add(std::string const& key, unsigned short value);
    virtual void
    add(std::string const& key, int value);
    virtual void
    add(std::string const& key, unsigned int value);
    virtual void
    add(std::string const& key, long value);
    virtual void
    add(std::string const& key, unsigned long value);
    virtual void
    add(std::string const& key, long long value);
    virtual void
    add(std::string const& key, unsigned long long value);
    virtual void
    add(std::string const& key, float value);
    virtual void
    add(std::string const& key, double value);
    virtual void
    add(std::string const& key, long double value);
 
    virtual void
    array_begin() = 0;
    virtual void
    array_begin(std::string const& key) = 0;
    virtual void
    array_end() = 0;
 
    virtual void
    add(std::string const& value) = 0;
 
    void
    add(char const* value)
    {
        add(std::string(value));
    }
 
    template <typename Value>
    void
    lexical_add(Value value)
    {
        std::stringstream ss;
        ss << value;
        add(ss.str());
    }
 
    virtual void
    add(bool value);
    virtual void
    add(char value);
    virtual void
    add(signed char value);
    virtual void
    add(unsigned char value);
    virtual void
    add(short value);
    virtual void
    add(unsigned short value);
    virtual void
    add(int value);
    virtual void
    add(unsigned int value);
    virtual void
    add(long value);
    virtual void
    add(unsigned long value);
    virtual void
    add(long long value);
    virtual void
    add(unsigned long long value);
    virtual void
    add(float value);
    virtual void
    add(double value);
    virtual void
    add(long double value);
 
private:
    class Item;
    class Proxy;
};
 
//------------------------------------------------------------------------------
//
// Item
//
//------------------------------------------------------------------------------
 
class PropertyStream::Item : public List<Item>::Node
{
public:
    explicit Item(Source* source);
    Source&
    source() const;
    Source*
    operator->() const;
    Source&
    operator*() const;
 
private:
    Source* m_source;
};
 
//------------------------------------------------------------------------------
//
// Proxy
//
//------------------------------------------------------------------------------
 
class PropertyStream::Proxy
{
private:
    Map const* m_map;
    std::string m_key;
    std::ostringstream mutable m_ostream;
 
public:
    Proxy(Map const& map, std::string const& key);
    Proxy(Proxy const& other);
    ~Proxy();
 
    template <typename Value>
    Proxy&
    operator=(Value value);
 
    std::ostream&
    operator<<(std::ostream& manip(std::ostream&)) const;
 
    template <typename T>
    std::ostream&
    operator<<(T const& t) const
    {
        return m_ostream << t;
    }
};
 
//------------------------------------------------------------------------------
//
// Map
//
//------------------------------------------------------------------------------
 
class PropertyStream::Map
{
private:
    PropertyStream& m_stream;
 
public:
    explicit Map(PropertyStream& stream);
    explicit Map(Set& parent);
    Map(std::string const& key, Map& parent);
    Map(std::string const& key, PropertyStream& stream);
    ~Map();
 
    Map(Map const&) = delete;
    Map&
    operator=(Map const&) = delete;
 
    PropertyStream&
    stream();
    PropertyStream const&
    stream() const;
 
    template <typename Value>
    void
    add(std::string const& key, Value value) const
    {
        m_stream.add(key, value);
    }
 
    template <typename Key, typename Value>
    void
    add(Key key, Value value) const
    {
        std::stringstream ss;
        ss << key;
        add(ss.str(), value);
    }
 
    Proxy
    operator[](std::string const& key);
 
    Proxy
    operator[](char const* key)
    {
        return Proxy(*this, key);
    }
 
    template <typename Key>
    Proxy
    operator[](Key key) const
    {
        std::stringstream ss;
        ss << key;
        return Proxy(*this, ss.str());
    }
};
 
//--------------------------------------------------------------------------
 
template <typename Value>
PropertyStream::Proxy&
PropertyStream::Proxy::operator=(Value value)
{
    m_map->add(m_key, value);
    return *this;
}
 
//--------------------------------------------------------------------------
//
// Set
//
//------------------------------------------------------------------------------
 
class PropertyStream::Set
{
private:
    PropertyStream& m_stream;
 
public:
    Set(std::string const& key, Map& map);
    Set(std::string const& key, PropertyStream& stream);
    ~Set();
 
    Set(Set const&) = delete;
    Set&
    operator=(Set const&) = delete;
 
    PropertyStream&
    stream();
    PropertyStream const&
    stream() const;
 
    template <typename Value>
    void
    add(Value value) const
    {
        m_stream.add(value);
    }
};
 
//------------------------------------------------------------------------------
//
// Source
//
//------------------------------------------------------------------------------
 
class PropertyStream::Source
{
private:
    std::string const m_name;
    std::recursive_mutex lock_;
    Item item_;
    Source* parent_;
    List<Item> children_;
 
public:
    explicit Source(std::string const& name);
    virtual ~Source();
 
    Source(Source const&) = delete;
    Source&
    operator=(Source const&) = delete;
 
    std::string const&
    name() const;
 
    void
    add(Source& source);
 
    template <class Derived>
    Derived*
    add(Derived* child)
    {
        add(*static_cast<Source*>(child));
        return child;
    }
 
    void
    remove(Source& child);
 
    void
    removeAll();
 
    void
    write_one(PropertyStream& stream);
 
    void
    write(PropertyStream& stream);
 
    void
    write(PropertyStream& stream, std::string const& path);
 
    std::pair<Source*, bool>
    find(std::string path);
 
    Source*
    find_one_deep(std::string const& name);
    PropertyStream::Source*
    find_path(std::string path);
    PropertyStream::Source*
    find_one(std::string const& name);
 
    static bool
    peel_leading_slash(std::string* path);
    static bool
    peel_trailing_slashstar(std::string* path);
    static std::string
    peel_name(std::string* path);
 
    //--------------------------------------------------------------------------
 
    virtual void
    onWrite(Map&);
};
 
}  // namespace beast
 
#endif