UT_JSONArchive.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_JSONArchive.h (UT Library, C++)
 *
 * COMMENTS:    JSON archive for use with UT_Serialization
 *
 */

#ifndef __UT_JSONARCHIVE_H_INCLUDED__
#define __UT_JSONARCHIVE_H_INCLUDED__

/// @file
/// JSON archive for use with UT_Serialization
///

#include "UT_JSONParser.h"
#include "UT_JSONWriter.h"
#include "UT_UniquePtr.h"
#include "UT_Serialization.h"

/// @class UT_JSONArchive
/// @brief Use this to create a class archive for serializing classes to/from
/// streams as JSON.
///
/// To serialize your data, you first have to implement serialization functions
/// as described in UT_Serialize.h. Then just this class to perform it.
/// eg.
/// @code
///     // form 1
///     cout << UT_JSONArchive<MyClassA>::Output(a_object);
///     cin  >> UT_JSONArchive<MyClassB>::Input(b_object);
///
///     // form 2
///     UT_JSONArchive<MyClassA>::Output output_archive(my_object);
///     UT_JSONArchive<MyClassA>::Input  input_archive(my_object);
///     output_archive(cout);
///     input_archive(cin);
/// @endcode
///

struct UT_JSONArchiver
{
    class Output : public UT_SaveArchiver<Output>
    {
    public:
        Output(UT_OStream &os)
            : myOut(UT_JSONWriter::allocWriter(os.getOStream(), os.isBinary()))
        {
        }

        bool serializeMapBegin()
        {
            return myOut->jsonBeginMap();
        }
        bool serializeMapEnd()
        {
            return myOut->jsonEndMap();
        }
        bool serializeKey(const char *key)
        {
            return myOut->jsonKeyToken(key);
        }

        template <typename T>
        bool serializeValue(const T &val)
        {
            return myOut->jsonValue(val);
        }
        bool serializeStringValue(const char *str)
        {
            return myOut->jsonStringToken(str);
        }

        bool serializeArrayBegin(int64 count)
        {
            return myOut->jsonBeginArray() && serializeValue(count);
        }
        bool serializeArrayEnd()
        {
            return myOut->jsonEndArray();
        }
        // serializeArray() provided by superclass

        template <typename T>
        bool serializeUniformArray(T *vec, int64 count)
        {
            return myOut->jsonUniformArray(count, vec);
        }

        bool serializeListBegin()
        {
            return myOut->jsonBeginArray();
        }
        bool serializeListEnd()
        {
            return myOut->jsonEndArray();
        }

    private:
        UT_UniquePtr<UT_JSONWriter> myOut;
    };

    class Input : public UT_LoadArchiver<Input>
    {
    public:
        Input(UT_IStream &is) : myAutoParser(new UT_AutoJSONParser(is))
        {
            myParser = &myAutoParser.get()->parser();
        }

        Input(UT_JSONParser &p) : myParser(&p)
        {
        }

        bool serializeMapBegin()
        {
            bool error;
            return myParser->parseBeginMap(error);
        }
        bool serializeMapEnd() // return true when we hit the end
        {
            bool error;
            return myParser->parseEndMap(error);
        }
        bool serializeKey(UT_WorkBuffer &key)
        {
            if (!myParser->parseKey(key))
                return false;
            return true;
        }

        template <typename T>
        bool serializeValue(T &val)
        {
            return myParser->parseValue(val);
        }
        bool serializeStringValue(UT_WorkBuffer &str)
        {
            return myParser->parseString(str);
        }

        bool serializeArrayBegin(int64 &count)
        {
            bool error;
            return myParser->parseBeginArray(error) && serializeValue(count);
        }
        bool serializeArrayEnd()
        {
            bool error;
            return myParser->parseEndArray(error);
        }
        // serializeArray() provided by superclass

        template <typename T>
        bool serializeUniformArray(T *vec, int64 count)
        {
            return myParser->parseUniformArray(vec, count) == count;
        }

        bool serializeListBegin()
        {
            bool error;
            return myParser->parseBeginArray(error);
        }
        bool serializeListEnd()
        {
            bool error;
            return myParser->parseEndArray(error);
        }

    private:
        UT_UniquePtr<UT_AutoJSONParser>  myAutoParser;
        UT_JSONParser                   *myParser;
        UT_JSONParser::iterator          myTraverser;
    };
};

/// Main class for starting serialization
template <typename OBJ_T>
struct UT_JSONArchive
{
    typedef UT_LoadArchiverManip<OBJ_T,UT_JSONArchiver>  Input;
    typedef UT_SaveArchiverManip<OBJ_T,UT_JSONArchiver>  Output;
};

#endif // __UT_JSONARCHIVE_H_INCLUDED__