rpc/json/writer.C

/*
 * Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
 * Rights to this code are as documented in doc/pod/license.pod.
 *
 * JSON-RPC for Ermyth
 *
 * $Id: writer.C,v 1.2 2007-08-28 17:08:12 pippijn Exp $
 */

//>>>>>>>>>>> writer.C <<<<<<<<<<<//
#include <json/value.h>
#include <json/writer.h>

#include <utility>
#include <iostream>

#include <cassert>
#include <cstdio>

namespace json
{
  static void uintToString (unsigned value, 
                            char *&current)
  {
    *--current = 0;
    do
      {
        *--current = (value % 10) + '0';
        value /= 10;
      }
    while (value != 0);
  }

  std::string valueToString (int value)
  {
    char buffer[32];
    char *current = buffer + sizeof (buffer);
    bool isNegative = value < 0;
    if (isNegative)
      value = -value;
    uintToString (unsigned (value), current);
    if (isNegative)
      *--current = '-';
    assert (current >= buffer);
    return current;
  }


  std::string valueToString (unsigned value)
  {
    char buffer[32];
    char *current = buffer + sizeof (buffer);
    uintToString (value, current);
    assert (current >= buffer);
    return current;
  }

  std::string valueToString (double value)
  {
    char buffer[32];
    sprintf (buffer, "%.16g", value); 
    return buffer;
  }


  std::string valueToString (bool value)
  {
    return value ? "true" : "false";
  }

  std::string valueToQuotedString (char const *value)
  {
    // Not sure how to handle unicode...
    if (std::strpbrk (value, "\"\\\b\f\n\r\t") == NULL)
      return std::string ("\"") + value + "\"";
    // We have to walk value and escape any special characters.
    // Appending to std::string is not efficient, but this should be rare.
    // (Note: forward slashes are *not* rare, but I am not escaping them.)
    unsigned maxsize = strlen (value) * 2 + 3; // allescaped+quotes+NULL
    std::string result;
    result.reserve (maxsize); // to avoid lots of allocs
    result += "\"";
    for (char const* c=value; *c != 0; ++c){
      switch (*c){
      case '\"':
        result += "\\\"";
        break;
      case '\\':
        result += "\\\\";
        break;
      case '\b':
        result += "\\b";
        break;
      case '\f':
        result += "\\f";
        break;
      case '\n':
        result += "\\n";
        break;
      case '\r':
        result += "\\r";
        break;
      case '\t':
        result += "\\t";
        break;
      case '/':
        // Even though \/ is considered a legal escape in JSON, a bare
        // slash is also legal, so I see no reason to escape it.
        // (I hope I am not misunderstanding something.)
      default:
        result += *c;
      }
    }
    result += "\"";
    return result;
  }

  // Class Writer
  Writer::~Writer ()
  {
  }


  // Class FastWriter
  FastWriter::FastWriter ()
    : yamlCompatiblityEnabled_ (false)
  {
  }


  void 
  FastWriter::enableYAMLCompatibility ()
  {
    yamlCompatiblityEnabled_ = true;
  }


  std::string 
  FastWriter::write (const Value &root)
  {
    document_ = "";
    writeValue (root);
    document_ += "\n";
    return document_;
  }


  void 
  FastWriter::writeValue (const Value &value)
  {
    switch (value.type ())
      {
      case nullValue:
        document_ += "null";
        break;
      case intValue:
        document_ += valueToString (static_cast<int> (value));
        break;
      case uintValue:
        document_ += valueToString (static_cast<unsigned> (value));
        break;
      case realValue:
        document_ += valueToString (static_cast<double> (value));
        break;
      case stringValue:
        document_ += valueToQuotedString (static_cast<char const *> (value));
        break;
      case booleanValue:
        document_ += valueToString (static_cast<bool> (value));
        break;
      case arrayValue:
        {
          document_ += "[";
          int size = value.size ();
          for (int index = 0; index < size; ++index)
            {
              if (index > 0)
                document_ += ",";
              writeValue (value[index]);
            }
          document_ += "]";
        }
        break;
      case objectValue:
        {
          Value::Members members (value.getMemberNames ());
          document_ += "{";
          for (Value::Members::iterator it = members.begin (); 
                it != members.end (); 
                ++it)
            {
              const std::string &name = *it;
              if (it != members.begin ())
                document_ += ",";
              document_ += valueToQuotedString (name.c_str ());
              document_ += yamlCompatiblityEnabled_ ? ": " 
                : ":";
              writeValue (value[name]);
            }
          document_ += "}";
        }
        break;
      }
  }


  // Class StyledWriter
  StyledWriter::StyledWriter ()
    : rightMargin_ (74)
    , indentSize_ (3)
  {
  }


  std::string 
  StyledWriter::write (const Value &root)
  {
    document_ = "";
    addChildValues_ = false;
    indentString_ = "";
    writeCommentBeforeValue (root);
    writeValue (root);
    writeCommentAfterValueOnSameLine (root);
    document_ += "\n";
    return document_;
  }


  void 
  StyledWriter::writeValue (const Value &value)
  {
    switch (value.type ())
      {
      case nullValue:
        pushValue ("null");
        break;
      case intValue:
        pushValue (valueToString (static_cast<int> (value)));
        break;
      case uintValue:
        pushValue (valueToString (static_cast<unsigned> (value)));
        break;
      case realValue:
        pushValue (valueToString (static_cast<double> (value)));
        break;
      case stringValue:
        pushValue (valueToQuotedString (static_cast<char const *> (value)));
        break;
      case booleanValue:
        pushValue (valueToString (static_cast<bool> (value)));
        break;
      case arrayValue:
        writeArrayValue (value);
        break;
      case objectValue:
        {
          Value::Members members (value.getMemberNames ());
          if (members.empty ())
            pushValue ("{}");
          else
            {
              writeWithIndent ("{");
              indent ();
              Value::Members::iterator it = members.begin ();
              while (true)
                {
                  const std::string &name = *it;
                  const Value &childValue = value[name];
                  writeCommentBeforeValue (childValue);
                  writeWithIndent (valueToQuotedString (name.c_str ()));
                  document_ += " : ";
                  writeValue (childValue);
                  if (++it == members.end ())
                    {
                      writeCommentAfterValueOnSameLine (childValue);
                      break;
                    }
                  document_ += ",";
                  writeCommentAfterValueOnSameLine (childValue);
                }
              unindent ();
              writeWithIndent ("}");
            }
        }
        break;
      }
  }


  void 
  StyledWriter::writeArrayValue (const Value &value)
  {
    unsigned size = value.size ();
    if (size == 0)
      pushValue ("[]");
    else
      {
        bool isArrayMultiLine = isMultineArray (value);
        if (isArrayMultiLine)
          {
            writeWithIndent ("[");
            indent ();
            bool hasChildValue = !childValues_.empty ();
            unsigned index = 0;
            while (true)
              {
                const Value &childValue = value[index];
                writeCommentBeforeValue (childValue);
                if (hasChildValue)
                  writeWithIndent (childValues_[index]);
                else
                  {
                    writeIndent ();
                    writeValue (childValue);
                  }
                if (++index == size)
                  {
                    writeCommentAfterValueOnSameLine (childValue);
                    break;
                  }
                document_ += ",";
                writeCommentAfterValueOnSameLine (childValue);
              }
            unindent ();
            writeWithIndent ("]");
          }
        else // output on a single line
          {
            assert (childValues_.size () == size);
            document_ += "[ ";
            for (unsigned index = 0; index < size; ++index)
              {
                if (index > 0)
                  document_ += ", ";
                document_ += childValues_[index];
              }
            document_ += " ]";
          }
      }
  }


  bool 
  StyledWriter::isMultineArray (const Value &value)
  {
    int size = value.size ();
    bool isMultiLine = size*3 >= rightMargin_ ;
    childValues_.clear ();
    for (int index = 0; index < size && !isMultiLine; ++index)
      {
        const Value &childValue = value[index];
        isMultiLine = isMultiLine || ( (childValue.isArray () || childValue.isObject ()) && childValue.size () > 0);
      }
    if (!isMultiLine) // check if line length > max line length
      {
        childValues_.reserve (size);
        addChildValues_ = true;
        int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'
        for (int index = 0; index < size && !isMultiLine; ++index)
          {
            writeValue (value[index]);
            lineLength += int (childValues_[index].length ());
            isMultiLine = isMultiLine && hasCommentForValue (value[index]);
          }
        addChildValues_ = false;
        isMultiLine = isMultiLine || lineLength >= rightMargin_;
      }
    return isMultiLine;
  }


  void 
  StyledWriter::pushValue (const std::string &value)
  {
    if (addChildValues_)
      childValues_.push_back (value);
    else
      document_ += value;
  }


  void 
  StyledWriter::writeIndent ()
  {
    if (!document_.empty ())
      {
        char last = document_[document_.length ()-1];
        if (last == ' ')     // already indented
          return;
        if (last != '\n')    // Comments may add new-line
          document_ += '\n';
      }
    document_ += indentString_;
  }


  void 
  StyledWriter::writeWithIndent (const std::string &value)
  {
    writeIndent ();
    document_ += value;
  }


  void 
  StyledWriter::indent ()
  {
    indentString_ += std::string (indentSize_, ' ');
  }


  void 
  StyledWriter::unindent ()
  {
    assert (int (indentString_.size ()) >= indentSize_);
    indentString_.resize (indentString_.size () - indentSize_);
  }


  void 
  StyledWriter::writeCommentBeforeValue (const Value &root)
  {
    if (!root.hasComment (commentBefore))
      return;
    document_ += normalizeEOL (root.getComment (commentBefore));
    document_ += "\n";
  }


  void 
  StyledWriter::writeCommentAfterValueOnSameLine (const Value &root)
  {
    if (root.hasComment (commentAfterOnSameLine))
      document_ += " " + normalizeEOL (root.getComment (commentAfterOnSameLine));

    if (root.hasComment (commentAfter))
      {
        document_ += "\n";
        document_ += normalizeEOL (root.getComment (commentAfter));
        document_ += "\n";
      }
  }


  bool 
  StyledWriter::hasCommentForValue (const Value &value)
  {
    return value.hasComment (commentBefore)
      ||  value.hasComment (commentAfterOnSameLine)
      ||  value.hasComment (commentAfter);
  }


  std::string 
  StyledWriter::normalizeEOL (const std::string &text)
  {
    std::string normalized;
    normalized.reserve (text.length ());
    char const *begin = text.c_str ();
    char const *end = begin + text.length ();
    char const *current = begin;
    while (current != end)
      {
        char c = *current++;
        if (c == '\r') // mac or dos EOL
          {
            if (*current == '\n') // convert dos EOL
              ++current;
            normalized += '\n';
          }
        else // handle unix EOL & other char
          normalized += c;
      }
    return normalized;
  }

  std::ostream& operator << (std::ostream &sout, const Value &root)
  {
    StyledWriter writer;
    sout << writer.write (root);
    return sout;
  }
} // namespace json
Revision:	1.3
Committed:	Wed Sep 5 11:23:15 2007 UTC (19 years, 1 month ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.2:	+2 -2 lines
Log Message:	removed GPLed code and put license back to BSD
#	User	Rev	Content
1	pippijn	1.2	/*
2			* Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
3	pippijn	1.3	* Rights to this code are as documented in doc/pod/license.pod.
4	pippijn	1.2	*
5			* JSON-RPC for Ermyth
6			*
7	pippijn	1.3	* $Id: writer.C,v 1.2 2007-08-28 17:08:12 pippijn Exp $
8	pippijn	1.2	*/
9
10	pippijn	1.1	//>>>>>>>>>>> writer.C <<<<<<<<<<<//
11			#include <json/value.h>
12			#include <json/writer.h>
13
14			#include <utility>
15			#include <iostream>
16
17			#include <cassert>
18			#include <cstdio>
19
20			namespace json
21			{
22			static void uintToString (unsigned value,
23			char *&current)
24			{
25			*--current = 0;
26			do
27			{
28			*--current = (value % 10) + '0';
29			value /= 10;
30			}
31			while (value != 0);
32			}
33
34			std::string valueToString (int value)
35			{
36			char buffer[32];
37			char *current = buffer + sizeof (buffer);
38			bool isNegative = value < 0;
39			if (isNegative)
40			value = -value;
41			uintToString (unsigned (value), current);
42			if (isNegative)
43			*--current = '-';
44			assert (current >= buffer);
45			return current;
46			}
47
48
49			std::string valueToString (unsigned value)
50			{
51			char buffer[32];
52			char *current = buffer + sizeof (buffer);
53			uintToString (value, current);
54			assert (current >= buffer);
55			return current;
56			}
57
58			std::string valueToString (double value)
59			{
60			char buffer[32];
61			sprintf (buffer, "%.16g", value);
62			return buffer;
63			}
64
65
66			std::string valueToString (bool value)
67			{
68			return value ? "true" : "false";
69			}
70
71			std::string valueToQuotedString (char const *value)
72			{
73			// Not sure how to handle unicode...
74			if (std::strpbrk (value, "\"\\\b\f\n\r\t") == NULL)
75			return std::string ("\"") + value + "\"";
76			// We have to walk value and escape any special characters.
77			// Appending to std::string is not efficient, but this should be rare.
78			// (Note: forward slashes are not rare, but I am not escaping them.)
79			unsigned maxsize = strlen (value) * 2 + 3; // allescaped+quotes+NULL
80			std::string result;
81	pippijn	1.2	result.reserve (maxsize); // to avoid lots of allocs
82	pippijn	1.1	result += "\"";
83			for (char const* c=value; *c != 0; ++c){
84			switch (*c){
85			case '\"':
86			result += "\\\"";
87			break;
88			case '\\':
89			result += "\\\\";
90			break;
91			case '\b':
92			result += "\\b";
93			break;
94			case '\f':
95			result += "\\f";
96			break;
97			case '\n':
98			result += "\\n";
99			break;
100			case '\r':
101			result += "\\r";
102			break;
103			case '\t':
104			result += "\\t";
105			break;
106			case '/':
107			// Even though \/ is considered a legal escape in JSON, a bare
108			// slash is also legal, so I see no reason to escape it.
109			// (I hope I am not misunderstanding something.)
110			default:
111			result += *c;
112			}
113			}
114			result += "\"";
115			return result;
116			}
117
118			// Class Writer
119			Writer::~Writer ()
120			{
121			}
122
123
124			// Class FastWriter
125			FastWriter::FastWriter ()
126			: yamlCompatiblityEnabled_ (false)
127			{
128			}
129
130
131			void
132			FastWriter::enableYAMLCompatibility ()
133			{
134			yamlCompatiblityEnabled_ = true;
135			}
136
137
138			std::string
139			FastWriter::write (const Value &root)
140			{
141			document_ = "";
142			writeValue (root);
143			document_ += "\n";
144			return document_;
145			}
146
147
148			void
149			FastWriter::writeValue (const Value &value)
150			{
151			switch (value.type ())
152			{
153			case nullValue:
154			document_ += "null";
155			break;
156			case intValue:
157			document_ += valueToString (static_cast<int> (value));
158			break;
159			case uintValue:
160			document_ += valueToString (static_cast<unsigned> (value));
161			break;
162			case realValue:
163			document_ += valueToString (static_cast<double> (value));
164			break;
165			case stringValue:
166			document_ += valueToQuotedString (static_cast<char const *> (value));
167			break;
168			case booleanValue:
169			document_ += valueToString (static_cast<bool> (value));
170			break;
171			case arrayValue:
172			{
173			document_ += "[";
174			int size = value.size ();
175			for (int index = 0; index < size; ++index)
176			{
177			if (index > 0)
178			document_ += ",";
179			writeValue (value[index]);
180			}
181			document_ += "]";
182			}
183			break;
184			case objectValue:
185			{
186			Value::Members members (value.getMemberNames ());
187			document_ += "{";
188			for (Value::Members::iterator it = members.begin ();
189			it != members.end ();
190			++it)
191			{
192			const std::string &name = *it;
193			if (it != members.begin ())
194			document_ += ",";
195			document_ += valueToQuotedString (name.c_str ());
196			document_ += yamlCompatiblityEnabled_ ? ": "
197			: ":";
198			writeValue (value[name]);
199			}
200			document_ += "}";
201			}
202			break;
203			}
204			}
205
206
207			// Class StyledWriter
208			StyledWriter::StyledWriter ()
209			: rightMargin_ (74)
210			, indentSize_ (3)
211			{
212			}
213
214
215			std::string
216			StyledWriter::write (const Value &root)
217			{
218			document_ = "";
219			addChildValues_ = false;
220			indentString_ = "";
221			writeCommentBeforeValue (root);
222			writeValue (root);
223			writeCommentAfterValueOnSameLine (root);
224			document_ += "\n";
225			return document_;
226			}
227
228
229			void
230			StyledWriter::writeValue (const Value &value)
231			{
232			switch (value.type ())
233			{
234			case nullValue:
235			pushValue ("null");
236			break;
237			case intValue:
238			pushValue (valueToString (static_cast<int> (value)));
239			break;
240			case uintValue:
241			pushValue (valueToString (static_cast<unsigned> (value)));
242			break;
243			case realValue:
244			pushValue (valueToString (static_cast<double> (value)));
245			break;
246			case stringValue:
247			pushValue (valueToQuotedString (static_cast<char const *> (value)));
248			break;
249			case booleanValue:
250			pushValue (valueToString (static_cast<bool> (value)));
251			break;
252			case arrayValue:
253			writeArrayValue (value);
254			break;
255			case objectValue:
256			{
257			Value::Members members (value.getMemberNames ());
258			if (members.empty ())
259			pushValue ("{}");
260			else
261			{
262			writeWithIndent ("{");
263			indent ();
264			Value::Members::iterator it = members.begin ();
265			while (true)
266			{
267			const std::string &name = *it;
268			const Value &childValue = value[name];
269			writeCommentBeforeValue (childValue);
270			writeWithIndent (valueToQuotedString (name.c_str ()));
271			document_ += " : ";
272			writeValue (childValue);
273			if (++it == members.end ())
274			{
275			writeCommentAfterValueOnSameLine (childValue);
276			break;
277			}
278			document_ += ",";
279			writeCommentAfterValueOnSameLine (childValue);
280			}
281			unindent ();
282			writeWithIndent ("}");
283			}
284			}
285			break;
286			}
287			}
288
289
290			void
291			StyledWriter::writeArrayValue (const Value &value)
292			{
293			unsigned size = value.size ();
294			if (size == 0)
295			pushValue ("[]");
296			else
297			{
298			bool isArrayMultiLine = isMultineArray (value);
299			if (isArrayMultiLine)
300			{
301			writeWithIndent ("[");
302			indent ();
303			bool hasChildValue = !childValues_.empty ();
304			unsigned index = 0;
305			while (true)
306			{
307			const Value &childValue = value[index];
308			writeCommentBeforeValue (childValue);
309			if (hasChildValue)
310			writeWithIndent (childValues_[index]);
311			else
312			{
313			writeIndent ();
314			writeValue (childValue);
315			}
316			if (++index == size)
317			{
318			writeCommentAfterValueOnSameLine (childValue);
319			break;
320			}
321			document_ += ",";
322			writeCommentAfterValueOnSameLine (childValue);
323			}
324			unindent ();
325			writeWithIndent ("]");
326			}
327			else // output on a single line
328			{
329			assert (childValues_.size () == size);
330			document_ += "[ ";
331			for (unsigned index = 0; index < size; ++index)
332			{
333			if (index > 0)
334			document_ += ", ";
335			document_ += childValues_[index];
336			}
337			document_ += " ]";
338			}
339			}
340			}
341
342
343			bool
344			StyledWriter::isMultineArray (const Value &value)
345			{
346			int size = value.size ();
347			bool isMultiLine = size*3 >= rightMargin_ ;
348			childValues_.clear ();
349			for (int index = 0; index < size && !isMultiLine; ++index)
350			{
351			const Value &childValue = value[index];
352			isMultiLine = isMultiLine \|\| ( (childValue.isArray () \|\| childValue.isObject ()) && childValue.size () > 0);
353			}
354			if (!isMultiLine) // check if line length > max line length
355			{
356			childValues_.reserve (size);
357			addChildValues_ = true;
358			int lineLength = 4 + (size-1)2; // '[ ' + ', 'n + ' ]'
359			for (int index = 0; index < size && !isMultiLine; ++index)
360			{
361			writeValue (value[index]);
362			lineLength += int (childValues_[index].length ());
363			isMultiLine = isMultiLine && hasCommentForValue (value[index]);
364			}
365			addChildValues_ = false;
366			isMultiLine = isMultiLine \|\| lineLength >= rightMargin_;
367			}
368			return isMultiLine;
369			}
370
371
372			void
373			StyledWriter::pushValue (const std::string &value)
374			{
375			if (addChildValues_)
376			childValues_.push_back (value);
377			else
378			document_ += value;
379			}
380
381
382			void
383			StyledWriter::writeIndent ()
384			{
385			if (!document_.empty ())
386			{
387			char last = document_[document_.length ()-1];
388			if (last == ' ') // already indented
389			return;
390			if (last != '\n') // Comments may add new-line
391			document_ += '\n';
392			}
393			document_ += indentString_;
394			}
395
396
397			void
398			StyledWriter::writeWithIndent (const std::string &value)
399			{
400			writeIndent ();
401			document_ += value;
402			}
403
404
405			void
406			StyledWriter::indent ()
407			{
408			indentString_ += std::string (indentSize_, ' ');
409			}
410
411
412			void
413			StyledWriter::unindent ()
414			{
415			assert (int (indentString_.size ()) >= indentSize_);
416			indentString_.resize (indentString_.size () - indentSize_);
417			}
418
419
420			void
421			StyledWriter::writeCommentBeforeValue (const Value &root)
422			{
423			if (!root.hasComment (commentBefore))
424			return;
425			document_ += normalizeEOL (root.getComment (commentBefore));
426			document_ += "\n";
427			}
428
429
430			void
431			StyledWriter::writeCommentAfterValueOnSameLine (const Value &root)
432			{
433			if (root.hasComment (commentAfterOnSameLine))
434			document_ += " " + normalizeEOL (root.getComment (commentAfterOnSameLine));
435
436			if (root.hasComment (commentAfter))
437			{
438			document_ += "\n";
439			document_ += normalizeEOL (root.getComment (commentAfter));
440			document_ += "\n";
441			}
442			}
443
444
445			bool
446			StyledWriter::hasCommentForValue (const Value &value)
447			{
448			return value.hasComment (commentBefore)
449			\|\| value.hasComment (commentAfterOnSameLine)
450			\|\| value.hasComment (commentAfter);
451			}
452
453
454			std::string
455			StyledWriter::normalizeEOL (const std::string &text)
456			{
457			std::string normalized;
458			normalized.reserve (text.length ());
459			char const *begin = text.c_str ();
460			char const *end = begin + text.length ();
461			char const *current = begin;
462			while (current != end)
463			{
464			char c = *current++;
465			if (c == '\r') // mac or dos EOL
466			{
467			if (*current == '\n') // convert dos EOL
468			++current;
469			normalized += '\n';
470			}
471			else // handle unix EOL & other char
472			normalized += c;
473			}
474			return normalized;
475			}
476
477			std::ostream& operator << (std::ostream &sout, const Value &root)
478			{
479			StyledWriter writer;
480			sout << writer.write (root);
481			return sout;
482			}
483			} // namespace json