← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/json_server/json/writer.h

merge lp:~linuxjedi/drizzle/trunk-remove-drizzleadmin

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/json_server/json/writer.h
 
1
/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
2
 * 
 
3
 *  JSON Library, originally from http://jsoncpp.sourceforge.net/
 
4
 *
 
5
 *  Copyright (C) 2011 Stewart Smith
 
6
 *  All rights reserved.
 
7
 *
 
8
 *  Redistribution and use in source and binary forms, with or without
 
9
 *  modification, are permitted provided that the following conditions are
 
10
 *  met:
 
11
 *
 
12
 *      * Redistributions of source code must retain the above copyright
 
13
 *  notice, this list of conditions and the following disclaimer.
 
14
 *
 
15
 *      * Redistributions in binary form must reproduce the above
 
16
 *  copyright notice, this list of conditions and the following disclaimer
 
17
 *  in the documentation and/or other materials provided with the
 
18
 *  distribution.
 
19
 *
 
20
 *      * The names of its contributors may not be used to endorse or
 
21
 *  promote products derived from this software without specific prior
 
22
 *  written permission.
 
23
 *
 
24
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
25
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
26
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
27
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
28
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
29
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
30
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
31
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
32
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
33
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
34
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
35
 *
 
36
 */
 
37
 
 
38
#pragma once
 
39
#ifndef JSON_WRITER_H_INCLUDED
 
40
# define JSON_WRITER_H_INCLUDED
 
41
 
 
42
# include "value.h"
 
43
# include <vector>
 
44
# include <string>
 
45
# include <iostream>
 
46
 
 
47
namespace Json {
 
48
 
 
49
   class Value;
 
50
 
 
51
   /** \brief Abstract class for writers.
 
52
    */
 
53
   class JSON_API Writer
 
54
   {
 
55
   public:
 
56
      virtual ~Writer();
 
57
 
 
58
      virtual std::string write( const Value &root ) = 0;
 
59
   };
 
60
 
 
61
   /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format without formatting (not human friendly).
 
62
    *
 
63
    * The JSON document is written in a single line. It is not intended for 'human' consumption,
 
64
    * but may be usefull to support feature such as RPC where bandwith is limited.
 
65
    * \sa Reader, Value
 
66
    */
 
67
   class JSON_API FastWriter : public Writer
 
68
   {
 
69
   public:
 
70
      FastWriter();
 
71
      virtual ~FastWriter(){}
 
72
 
 
73
      void enableYAMLCompatibility();
 
74
 
 
75
   public: // overridden from Writer
 
76
      virtual std::string write( const Value &root );
 
77
 
 
78
   private:
 
79
      void writeValue( const Value &value );
 
80
 
 
81
      std::string document_;
 
82
      bool yamlCompatiblityEnabled_;
 
83
   };
 
84
 
 
85
   /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way.
 
86
    *
 
87
    * The rules for line break and indent are as follow:
 
88
    * - Object value:
 
89
    *     - if empty then print {} without indent and line break
 
90
    *     - if not empty the print '{', line break & indent, print one value per line
 
91
    *       and then unindent and line break and print '}'.
 
92
    * - Array value:
 
93
    *     - if empty then print [] without indent and line break
 
94
    *     - if the array contains no object value, empty array or some other value types,
 
95
    *       and all the values fit on one lines, then print the array on a single line.
 
96
    *     - otherwise, it the values do not fit on one line, or the array contains
 
97
    *       object or non empty array, then print one value per line.
 
98
    *
 
99
    * If the Value have comments then they are outputed according to their #CommentPlacement.
 
100
    *
 
101
    * \sa Reader, Value, Value::setComment()
 
102
    */
 
103
   class JSON_API StyledWriter: public Writer
 
104
   {
 
105
   public:
 
106
      StyledWriter();
 
107
      virtual ~StyledWriter(){}
 
108
 
 
109
   public: // overridden from Writer
 
110
      /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
 
111
       * \param root Value to serialize.
 
112
       * \return String containing the JSON document that represents the root value.
 
113
       */
 
114
      virtual std::string write( const Value &root );
 
115
 
 
116
   private:
 
117
      void writeValue( const Value &value );
 
118
      void writeArrayValue( const Value &value );
 
119
      bool isMultineArray( const Value &value );
 
120
      void pushValue( const std::string &value );
 
121
      void writeIndent();
 
122
      void writeWithIndent( const std::string &value );
 
123
      void indent();
 
124
      void unindent();
 
125
      void writeCommentBeforeValue( const Value &root );
 
126
      void writeCommentAfterValueOnSameLine( const Value &root );
 
127
      bool hasCommentForValue( const Value &value );
 
128
      static std::string normalizeEOL( const std::string &text );
 
129
 
 
130
      typedef std::vector<std::string> ChildValues;
 
131
 
 
132
      ChildValues childValues_;
 
133
      std::string document_;
 
134
      std::string indentString_;
 
135
      int rightMargin_;
 
136
      int indentSize_;
 
137
      bool addChildValues_;
 
138
   };
 
139
 
 
140
   /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way,
 
141
        to a stream rather than to a string.
 
142
    *
 
143
    * The rules for line break and indent are as follow:
 
144
    * - Object value:
 
145
    *     - if empty then print {} without indent and line break
 
146
    *     - if not empty the print '{', line break & indent, print one value per line
 
147
    *       and then unindent and line break and print '}'.
 
148
    * - Array value:
 
149
    *     - if empty then print [] without indent and line break
 
150
    *     - if the array contains no object value, empty array or some other value types,
 
151
    *       and all the values fit on one lines, then print the array on a single line.
 
152
    *     - otherwise, it the values do not fit on one line, or the array contains
 
153
    *       object or non empty array, then print one value per line.
 
154
    *
 
155
    * If the Value have comments then they are outputed according to their #CommentPlacement.
 
156
    *
 
157
    * \param indentation Each level will be indented by this amount extra.
 
158
    * \sa Reader, Value, Value::setComment()
 
159
    */
 
160
   class JSON_API StyledStreamWriter
 
161
   {
 
162
   public:
 
163
      StyledStreamWriter( std::string indentation="\t" );
 
164
      ~StyledStreamWriter(){}
 
165
 
 
166
   public:
 
167
      /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
 
168
       * \param out Stream to write to. (Can be ostringstream, e.g.)
 
169
       * \param root Value to serialize.
 
170
       * \note There is no point in deriving from Writer, since write() should not return a value.
 
171
       */
 
172
      void write( std::ostream &out, const Value &root );
 
173
 
 
174
   private:
 
175
      void writeValue( const Value &value );
 
176
      void writeArrayValue( const Value &value );
 
177
      bool isMultineArray( const Value &value );
 
178
      void pushValue( const std::string &value );
 
179
      void writeIndent();
 
180
      void writeWithIndent( const std::string &value );
 
181
      void indent();
 
182
      void unindent();
 
183
      void writeCommentBeforeValue( const Value &root );
 
184
      void writeCommentAfterValueOnSameLine( const Value &root );
 
185
      bool hasCommentForValue( const Value &value );
 
186
      static std::string normalizeEOL( const std::string &text );
 
187
 
 
188
      typedef std::vector<std::string> ChildValues;
 
189
 
 
190
      ChildValues childValues_;
 
191
      std::ostream* document_;
 
192
      std::string indentString_;
 
193
      int rightMargin_;
 
194
      std::string indentation_;
 
195
      bool addChildValues_;
 
196
   };
 
197
 
 
198
   std::string JSON_API valueToString( Int value );
 
199
   std::string JSON_API valueToString( UInt value );
 
200
   std::string JSON_API valueToString( double value );
 
201
   std::string JSON_API valueToString( bool value );
 
202
   std::string JSON_API valueToQuotedString( const char *value );
 
203
 
 
204
   /// \brief Output using the StyledStreamWriter.
 
205
   /// \see Json::operator>>()
 
206
   std::ostream& operator<<( std::ostream&, const Value &root );
 
207
 
 
208
} // namespace Json
 
209
 
 
210
 
 
211
 
 
212
#endif // JSON_WRITER_H_INCLUDED