include/json/writer.h

#pragma once

#include "value.h"

#include <vector>
#include <string>
#include <iostream>

namespace Json
{
  class Value;

  /** \brief Abstract class for writers.
   */
  class JSON_API Writer
  {
  public:
    virtual ~Writer ();

    virtual std::string write (const Value &root) = 0;
  };

  /** \brief Outputs a Value in <a href="http://www.json.org">JSON</a> format without formatting (not human friendly).
   *
   * The JSON document is written in a single line. It is not intended for 'human' consumption,
   * but may be usefull to support feature such as RPC where bandwith is limited.
   * \sa Reader, Value
   */
  class JSON_API FastWriter
    : public Writer
  {
  public:
    FastWriter ();
    virtual ~FastWriter () { }

    void enableYAMLCompatibility ();

  public:
    /* overridden from Writer */
    virtual std::string write (const Value &root);

  private:
    void writeValue (const Value &value);

    std::string document_;
    bool yamlCompatiblityEnabled_;
  };

  /** \brief Writes a Value in <a href="http://www.json.org">JSON</a> format in a human friendly way.
   *
   * The rules for line break and indent are as follow:
   * - Object value:
   *     - if empty then print {} without indent and line break
   *     - if not empty the print '{', line break & indent, print one value per line
   *       and then unindent and line break and print '}'.
   * - Array value:
   *     - if empty then print [] without indent and line break
   *     - if the array contains no object value, empty array or some other value types,
   *       and all the values fit on one lines, then print the array on a single line.
   *     - otherwise, it the values do not fit on one line, or the array contains
   *       object or non empty array, then print one value per line.
   *
   * If the Value have comments then they are outputed according to their #CommentPlacement.
   *
   * \sa Reader, Value, Value::setComment()
   */
  class JSON_API StyledWriter
    : public Writer
  {
  public:
    StyledWriter ();
    virtual ~StyledWriter () { }

  public:
    /* overridden from Writer */
    /** \brief Serialize a Value in <a href="http://www.json.org">JSON</a> format.
     * \param root Value to serialize.
     * \return String containing the JSON document that represents the root value.
     */
    virtual std::string write (const Value &root);

  private:
    void writeValue (const Value &value);
    void writeArrayValue (const Value &value);
    bool isMultineArray (const Value &value);
    void pushValue (const std::string &value);
    void writeIndent ();
    void writeWithIndent (const std::string &value);
    void indent ();
    void unindent ();
    void writeCommentBeforeValue (const Value &root);
    void writeCommentAfterValueOnSameLine (const Value &root);
    bool hasCommentForValue (const Value &value);
    static std::string normalizeEOL (const std::string &text);

    typedef std::vector<std::string> ChildValues;

    ChildValues childValues_;
    std::string document_;
    std::string indentString_;
    int rightMargin_;
    int indentSize_;
    bool addChildValues_;
  };

  /** \brief Writes a Value in <a href="http://www.json.org">JSON</a> format in a human friendly way,
   *   to a stream rather than to a string.
   *
   * The rules for line break and indent are as follow:
   * - Object value:
   *     - if empty then print {} without indent and line break
   *     - if not empty the print '{', line break & indent, print one value per line
   *       and then unindent and line break and print '}'.
   * - Array value:
   *     - if empty then print [] without indent and line break
   *     - if the array contains no object value, empty array or some other value types,
   *       and all the values fit on one lines, then print the array on a single line.
   *     - otherwise, it the values do not fit on one line, or the array contains
   *       object or non empty array, then print one value per line.
   *
   * If the Value have comments then they are outputed according to their #CommentPlacement.
   *
   * \param indentation Each level will be indented by this amount extra.
   * \sa Reader, Value, Value::setComment()
   */
  class JSON_API StyledStreamWriter
  {
  public:
    StyledStreamWriter (std::string indentation = "\t");
    ~StyledStreamWriter () { }

  public:
    /** \brief Serialize a Value in <a href="http://www.json.org">JSON</a> format.
     * \param out Stream to write to. (Can be ostringstream, e.g.)
     * \param root Value to serialize.
     * \note There is no point in deriving from Writer, since write() should not return a value.
     */
    void write (std::ostream &out, const Value &root);

  private:
    void writeValue (const Value &value);
    void writeArrayValue (const Value &value);
    bool isMultineArray (const Value &value);
    void pushValue (const std::string &value);
    void writeIndent ();
    void writeWithIndent (const std::string &value);
    void indent ();
    void unindent ();
    void writeCommentBeforeValue (const Value &root);
    void writeCommentAfterValueOnSameLine (const Value &root);
    bool hasCommentForValue (const Value &value);
    static std::string normalizeEOL (const std::string &text);

    typedef std::vector<std::string> ChildValues;

    ChildValues childValues_;
    std::ostream *document_;
    std::string indentString_;
    std::string indentation_;
    long rightMargin_;
    bool addChildValues_;
  };

  std::string JSON_API valueToString (Int value);
  std::string JSON_API valueToString (UInt value);
  std::string JSON_API valueToString (double value);
  std::string JSON_API valueToString (bool value);
  std::string JSON_API valueToQuotedString (const char *value);

  /**
   * \brief Output using the StyledStreamWriter.
   * \see Json::operator>>()
   */
  std::ostream &operator << (std::ostream &os, const Value &root);
} /* namespace Json */
Revision:	1.1
Committed:	Sun Oct 17 08:14:54 2010 UTC (15 years, 11 months ago) by sf-pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	initial import
#	User	Rev	Content
1	sf-pippijn	1.1	#pragma once
2
3			#include "value.h"
4
5			#include <vector>
6			#include <string>
7			#include <iostream>
8
9			namespace Json
10			{
11			class Value;
12
13			/** \brief Abstract class for writers.
14			*/
15			class JSON_API Writer
16			{
17			public:
18			virtual ~Writer ();
19
20			virtual std::string write (const Value &root) = 0;
21			};
22
23			/** \brief Outputs a Value in <a href="http://www.json.org">JSON</a> format without formatting (not human friendly).
24			*
25			* The JSON document is written in a single line. It is not intended for 'human' consumption,
26			* but may be usefull to support feature such as RPC where bandwith is limited.
27			* \sa Reader, Value
28			*/
29			class JSON_API FastWriter
30			: public Writer
31			{
32			public:
33			FastWriter ();
34			virtual ~FastWriter () { }
35
36			void enableYAMLCompatibility ();
37
38			public:
39			/* overridden from Writer */
40			virtual std::string write (const Value &root);
41
42			private:
43			void writeValue (const Value &value);
44
45			std::string document_;
46			bool yamlCompatiblityEnabled_;
47			};
48
49			/** \brief Writes a Value in <a href="http://www.json.org">JSON</a> format in a human friendly way.
50			*
51			* The rules for line break and indent are as follow:
52			* - Object value:
53			* - if empty then print {} without indent and line break
54			* - if not empty the print '{', line break & indent, print one value per line
55			* and then unindent and line break and print '}'.
56			* - Array value:
57			* - if empty then print [] without indent and line break
58			* - if the array contains no object value, empty array or some other value types,
59			* and all the values fit on one lines, then print the array on a single line.
60			* - otherwise, it the values do not fit on one line, or the array contains
61			* object or non empty array, then print one value per line.
62			*
63			* If the Value have comments then they are outputed according to their #CommentPlacement.
64			*
65			* \sa Reader, Value, Value::setComment()
66			*/
67			class JSON_API StyledWriter
68			: public Writer
69			{
70			public:
71			StyledWriter ();
72			virtual ~StyledWriter () { }
73
74			public:
75			/* overridden from Writer */
76			/** \brief Serialize a Value in <a href="http://www.json.org">JSON</a> format.
77			* \param root Value to serialize.
78			* \return String containing the JSON document that represents the root value.
79			*/
80			virtual std::string write (const Value &root);
81
82			private:
83			void writeValue (const Value &value);
84			void writeArrayValue (const Value &value);
85			bool isMultineArray (const Value &value);
86			void pushValue (const std::string &value);
87			void writeIndent ();
88			void writeWithIndent (const std::string &value);
89			void indent ();
90			void unindent ();
91			void writeCommentBeforeValue (const Value &root);
92			void writeCommentAfterValueOnSameLine (const Value &root);
93			bool hasCommentForValue (const Value &value);
94			static std::string normalizeEOL (const std::string &text);
95
96			typedef std::vector<std::string> ChildValues;
97
98			ChildValues childValues_;
99			std::string document_;
100			std::string indentString_;
101			int rightMargin_;
102			int indentSize_;
103			bool addChildValues_;
104			};
105
106			/** \brief Writes a Value in <a href="http://www.json.org">JSON</a> format in a human friendly way,
107			* to a stream rather than to a string.
108			*
109			* The rules for line break and indent are as follow:
110			* - Object value:
111			* - if empty then print {} without indent and line break
112			* - if not empty the print '{', line break & indent, print one value per line
113			* and then unindent and line break and print '}'.
114			* - Array value:
115			* - if empty then print [] without indent and line break
116			* - if the array contains no object value, empty array or some other value types,
117			* and all the values fit on one lines, then print the array on a single line.
118			* - otherwise, it the values do not fit on one line, or the array contains
119			* object or non empty array, then print one value per line.
120			*
121			* If the Value have comments then they are outputed according to their #CommentPlacement.
122			*
123			* \param indentation Each level will be indented by this amount extra.
124			* \sa Reader, Value, Value::setComment()
125			*/
126			class JSON_API StyledStreamWriter
127			{
128			public:
129			StyledStreamWriter (std::string indentation = "\t");
130			~StyledStreamWriter () { }
131
132			public:
133			/** \brief Serialize a Value in <a href="http://www.json.org">JSON</a> format.
134			* \param out Stream to write to. (Can be ostringstream, e.g.)
135			* \param root Value to serialize.
136			* \note There is no point in deriving from Writer, since write() should not return a value.
137			*/
138			void write (std::ostream &out, const Value &root);
139
140			private:
141			void writeValue (const Value &value);
142			void writeArrayValue (const Value &value);
143			bool isMultineArray (const Value &value);
144			void pushValue (const std::string &value);
145			void writeIndent ();
146			void writeWithIndent (const std::string &value);
147			void indent ();
148			void unindent ();
149			void writeCommentBeforeValue (const Value &root);
150			void writeCommentAfterValueOnSameLine (const Value &root);
151			bool hasCommentForValue (const Value &value);
152			static std::string normalizeEOL (const std::string &text);
153
154			typedef std::vector<std::string> ChildValues;
155
156			ChildValues childValues_;
157			std::ostream *document_;
158			std::string indentString_;
159			std::string indentation_;
160			long rightMargin_;
161			bool addChildValues_;
162			};
163
164			std::string JSON_API valueToString (Int value);
165			std::string JSON_API valueToString (UInt value);
166			std::string JSON_API valueToString (double value);
167			std::string JSON_API valueToString (bool value);
168			std::string JSON_API valueToQuotedString (const char *value);
169
170			/**
171			* \brief Output using the StyledStreamWriter.
172			* \see Json::operator>>()
173			*/
174			std::ostream &operator << (std::ostream &os, const Value &root);
175			} /* namespace Json */