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:
        enum
        {
                PARSE_FAILURE = -1
        };

        LLSDParser();

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

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

        /* @name Simple istream helper methods 
         *
         * These helper methods exist to help correctly use the
         * mMaxBytesLeft without really thinking about it for most simple
         * operations. Use of the streamtools in llstreamtools.h will
         * require custom wrapping.
         */

        int get(std::istream& istr) const;
        
        std::istream& get(
                std::istream& istr,
                char* s,
                std::streamsize n,
                char delim) const;

        std::istream& get(
                std::istream& istr,
                std::streambuf& sb,
                char delim) const;

        std::istream& ignore(std::istream& istr) const;

        std::istream& putback(std::istream& istr, char c) const;

        std::istream& read(std::istream& istr, char* s, std::streamsize n) const;

protected:
        void account(S32 bytes) const;

protected:
        bool mCheckLimits;

        mutable S32 mMaxBytesLeft;
};

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

public:
        LLSDNotationParser();

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

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

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

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

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

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

public:
        LLSDXMLParser();

protected:
        virtual S32 doParse(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();

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

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

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

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


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

public:
        typedef 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
        };

        enum
        {
                // Setting an unlimited size is discouraged and should only be
                // used when reading cin or another stream source which does
                // not provide access to size.
                SIZE_UNLIMITED = -1,
        };

        /*
         * 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, S32 max_bytes);

        /*
         * 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, S32 max_bytes)
        {
                LLPointer<LLSDNotationParser> p = new LLSDNotationParser;
                return p->parse(str, sd, max_bytes);
        }
        static LLSD fromNotation(std::istream& str, S32 max_bytes)
        {
                LLPointer<LLSDNotationParser> p = new LLSDNotationParser;
                LLSD sd;
                (void)p->parse(str, sd, max_bytes);
                return 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)
        {
                // no need for max_bytes since xml formatting is not
                // subvertable by bad sizes.
                LLPointer<LLSDXMLParser> p = new LLSDXMLParser;
                return p->parse(str, sd, LLSDSerialize::SIZE_UNLIMITED);
        }

        /*
         * 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, S32 max_bytes)
        {
                LLPointer<LLSDBinaryParser> p = new LLSDBinaryParser;
                return p->parse(str, sd, max_bytes);
        }
        static LLSD fromBinary(std::istream& str, S32 max_bytes)
        {
                LLPointer<LLSDBinaryParser> p = new LLSDBinaryParser;
                LLSD sd;
                (void)p->parse(str, sd, max_bytes);
                return sd;
        }
};

#endif // LL_LLSDSERIALIZE_H

---