Object.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2012, 2013 Ripple Labs Inc.
 
    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 RIPPLE_JSON_OBJECT_H_INCLUDED
#define RIPPLE_JSON_OBJECT_H_INCLUDED
 
#include <ripple/json/Writer.h>
#include <memory>
 
namespace Json {
 
class Collection
{
public:
    Collection(Collection&& c) noexcept;
    Collection&
    operator=(Collection&& c) noexcept;
    Collection() = delete;
 
    ~Collection();
 
protected:
    // A null parent means "no parent at all".
    // Writers cannot be null.
    Collection(Collection* parent, Writer*);
    void
    checkWritable(std::string const& label);
 
    Collection* parent_;
    Writer* writer_;
    bool enabled_;
};
 
class Array;
 
//------------------------------------------------------------------------------
 
class Object : protected Collection
{
public:
    class Root;
 
    template <typename Scalar>
    void
    set(std::string const& key, Scalar const&);
 
    void
    set(std::string const& key, Json::Value const&);
 
    // Detail class and method used to implement operator[].
    class Proxy;
 
    Proxy
    operator[](std::string const& key);
    Proxy
    operator[](Json::StaticString const& key);
 
    Object
    setObject(std::string const& key);
 
    Array
    setArray(std::string const& key);
 
protected:
    friend class Array;
    Object(Collection* parent, Writer* w) : Collection(parent, w)
    {
    }
};
 
class Object::Root : public Object
{
public:
    Root(Writer&);
};
 
//------------------------------------------------------------------------------
 
class Array : private Collection
{
public:
    template <typename Scalar>
    void
    append(Scalar const&);
 
    void
    append(Json::Value const&);
 
    Object
    appendObject();
 
    Array
    appendArray();
 
protected:
    friend class Object;
    Array(Collection* parent, Writer* w) : Collection(parent, w)
    {
    }
};
 
//------------------------------------------------------------------------------
 
// Generic accessor functions to allow Json::Value and Collection to
// interoperate.
 
Json::Value&
setArray(Json::Value&, Json::StaticString const& key);
 
Array
setArray(Object&, Json::StaticString const& key);
 
Json::Value&
addObject(Json::Value&, Json::StaticString const& key);
 
Object
addObject(Object&, Json::StaticString const& key);
 
Json::Value&
appendArray(Json::Value&);
 
Array
appendArray(Array&);
 
Json::Value&
appendObject(Json::Value&);
 
Object
appendObject(Array&);
 
void
copyFrom(Json::Value& to, Json::Value const& from);
 
void
copyFrom(Object& to, Json::Value const& from);
 
class WriterObject
{
public:
    WriterObject(Output const& output)
        : writer_(std::make_unique<Writer>(output))
        , object_(std::make_unique<Object::Root>(*writer_))
    {
    }
 
    WriterObject(WriterObject&& other) = default;
 
    Object*
    operator->()
    {
        return object_.get();
    }
 
    Object&
    operator*()
    {
        return *object_;
    }
 
private:
    std::unique_ptr<Writer> writer_;
    std::unique_ptr<Object::Root> object_;
};
 
WriterObject
stringWriterObject(std::string&);
 
//------------------------------------------------------------------------------
// Implementation details.
 
// Detail class for Object::operator[].
class Object::Proxy
{
private:
    Object& object_;
    std::string const key_;
 
public:
    Proxy(Object& object, std::string const& key);
 
    template <class T>
    void
    operator=(T const& t)
    {
        object_.set(key_, t);
        // Note: This function shouldn't return *this, because it's a trap.
        //
        // In Json::Value, foo[jss::key] returns a reference to a
        // mutable Json::Value contained _inside_ foo.  But in the case of
        // Json::Object, where we write once only, there isn't any such
        // reference that can be returned.  Returning *this would return an
        // object "a level higher" than in Json::Value, leading to obscure bugs,
        // particularly in generic code.
    }
};
 
//------------------------------------------------------------------------------
 
template <typename Scalar>
void
Array::append(Scalar const& value)
{
    checkWritable("append");
    if (writer_)
        writer_->append(value);
}
 
template <typename Scalar>
void
Object::set(std::string const& key, Scalar const& value)
{
    checkWritable("set");
    if (writer_)
        writer_->set(key, value);
}
 
inline Json::Value&
setArray(Json::Value& json, Json::StaticString const& key)
{
    return (json[key] = Json::arrayValue);
}
 
inline Array
setArray(Object& json, Json::StaticString const& key)
{
    return json.setArray(std::string(key));
}
 
inline Json::Value&
addObject(Json::Value& json, Json::StaticString const& key)
{
    return (json[key] = Json::objectValue);
}
 
inline Object
addObject(Object& object, Json::StaticString const& key)
{
    return object.setObject(std::string(key));
}
 
inline Json::Value&
appendArray(Json::Value& json)
{
    return json.append(Json::arrayValue);
}
 
inline Array
appendArray(Array& json)
{
    return json.appendArray();
}
 
inline Json::Value&
appendObject(Json::Value& json)
{
    return json.append(Json::objectValue);
}
 
inline Object
appendObject(Array& json)
{
    return json.appendObject();
}
 
}  // namespace Json
 
#endif