llsdserialize.h

Go to the documentation of this file.

#ifndef LL_LLSDSERIALIZE_H
#define LL_LLSDSERIALIZE_H

#include <iosfwd>
#include "llsd.h"
#include "llmemory.h"

class LLSDParser : public LLRefCount
{
protected:
        virtual ~LLSDParser();

public:
        LLSDParser();

        virtual S32 parse(std::istream& istr, LLSD& data) const = 0;

protected:

};

class LLSDNotationParser : public LLSDParser
{
protected:
        virtual ~LLSDNotationParser();

public:
        LLSDNotationParser() {}

        virtual S32 parse(std::istream& istr, LLSD& data) const;

        static LLSD parse(std::istream& istr);

private:
        S32 parseMap(std::istream& istr, LLSD& map) const;

        S32 parseArray(std::istream& istr, LLSD& array) const;

        void parseString(std::istream& istr, LLSD& data) const;

        void parseBinary(std::istream& istr, LLSD& data) const;
};

class LLSDXMLParser : public LLSDParser
{
protected:
        virtual ~LLSDXMLParser();

public:
        LLSDXMLParser();

        virtual S32 parse(std::istream& istr, LLSD& data) const;

private:
        class Impl;
        Impl& impl;

        void parsePart(const char *buf, int len);
        friend class LLSDSerialize;
};

class LLSDBinaryParser : public LLSDParser
{
protected:
        virtual ~LLSDBinaryParser();

public:
        LLSDBinaryParser();

        virtual S32 parse(std::istream& istr, LLSD& data) const;

        static LLSD parse(std::istream& istr);

private:
        S32 parseMap(std::istream& istr, LLSD& map) const;

        S32 parseArray(std::istream& istr, LLSD& array) const;

        void parseString(std::istream& istr, std::string& value) const;
};


class LLSDFormatter : public LLRefCount
{
protected:
        virtual ~LLSDFormatter();

public:
        enum e_formatter_options_type
        {
                OPTIONS_NONE = 0,
                OPTIONS_PRETTY = 1
        } EFormatterOptions;

        LLSDFormatter();

        void boolalpha(bool alpha);

        void realFormat(const std::string& format);

        virtual S32 format(const LLSD& data, std::ostream& ostr, U32 options = LLSDFormatter::OPTIONS_NONE) const = 0;

protected:
        void formatReal(LLSD::Real real, std::ostream& ostr) const;

protected:
        bool mBoolAlpha;
        std::string mRealFormat;
};


class LLSDNotationFormatter : public LLSDFormatter
{
protected:
        virtual ~LLSDNotationFormatter();

public:
        LLSDNotationFormatter();

        static std::string escapeString(const std::string& in);

        virtual S32 format(const LLSD& data, std::ostream& ostr, U32 options = LLSDFormatter::OPTIONS_NONE) const;
};


class LLSDXMLFormatter : public LLSDFormatter
{
protected:
        virtual ~LLSDXMLFormatter();

public:
        LLSDXMLFormatter();

        static std::string escapeString(const std::string& in);

        virtual S32 format(const LLSD& data, std::ostream& ostr, U32 options = LLSDFormatter::OPTIONS_NONE) const;

protected:

        S32 format_impl(const LLSD& data, std::ostream& ostr, U32 options, U32 level) const;
};


class LLSDBinaryFormatter : public LLSDFormatter
{
protected:
        virtual ~LLSDBinaryFormatter();

public:
        LLSDBinaryFormatter();

        virtual S32 format(const LLSD& data, std::ostream& ostr, U32 options = LLSDFormatter::OPTIONS_NONE) const;

protected:
        void formatString(const std::string& string, std::ostream& ostr) const;
};


template <class Formatter>
class LLSDOStreamer : public Formatter
{
public:
        LLSDOStreamer(const LLSD& data, U32 options = LLSDFormatter::OPTIONS_NONE) :
                mSD(data), mOptions(options) {}

        friend std::ostream& operator<<(
                std::ostream& str,
                const LLSDOStreamer<Formatter>& formatter)
        {
                formatter.format(formatter.mSD, str, formatter.mOptions);
                return str;
        }

protected:
        LLSD mSD;
        U32 mOptions;
};

typedef LLSDOStreamer<LLSDNotationFormatter>    LLSDNotationStreamer;
typedef LLSDOStreamer<LLSDXMLFormatter>                 LLSDXMLStreamer;

class LLSDSerialize
{
public:
        enum ELLSD_Serialize
        {
                LLSD_BINARY, LLSD_XML
        };

        /*
         * Generic in/outs
         */
        static void serialize(const LLSD& sd, std::ostream& str, ELLSD_Serialize,
                U32 options = LLSDFormatter::OPTIONS_NONE);
        static bool deserialize(LLSD& sd, std::istream& str);

        /*
         * Notation Methods
         */
        static S32 toNotation(const LLSD& sd, std::ostream& str)
        {
                LLPointer<LLSDNotationFormatter> f = new LLSDNotationFormatter;
                return f->format(sd, str, LLSDFormatter::OPTIONS_NONE);
        }
        static S32 fromNotation(LLSD& sd, std::istream& str)
        {
                LLPointer<LLSDNotationParser> p = new LLSDNotationParser;
                return p->parse(str, sd);
        }
        
        /*
         * XML Methods
         */
        static S32 toXML(const LLSD& sd, std::ostream& str)
        {
                LLPointer<LLSDXMLFormatter> f = new LLSDXMLFormatter;
                return f->format(sd, str, LLSDFormatter::OPTIONS_NONE);
        }
        static S32 toPrettyXML(const LLSD& sd, std::ostream& str)
        {
                LLPointer<LLSDXMLFormatter> f = new LLSDXMLFormatter;
                return f->format(sd, str, LLSDFormatter::OPTIONS_PRETTY);
        }
        static S32 fromXML(LLSD& sd, std::istream& str)
        {
                LLPointer<LLSDXMLParser> p = new LLSDXMLParser;
                return p->parse(str, sd);
        }

        /*
         * Binary Methods
         */
        static S32 toBinary(const LLSD& sd, std::ostream& str)
        {
                LLPointer<LLSDBinaryFormatter> f = new LLSDBinaryFormatter;
                return f->format(sd, str, LLSDFormatter::OPTIONS_NONE);
        }
        static S32 fromBinary(LLSD& sd, std::istream& str)
        {
                LLPointer<LLSDBinaryParser> p = new LLSDBinaryParser;
                return p->parse(str, sd);
        }
private:
        static const char *LLSDBinaryHeader;
        static const char *LLSDXMLHeader;
};

#endif // LL_LLSDSERIALIZE_H

---