backend/json/json_writer.cpp

#include <json/writer.h>
#include <utility>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <sstream>
#include <iomanip>

#if _MSC_VER >= 1400 // VC++ 8.0
#pragma warning( disable : 4996 )   // disable warning about strdup being deprecated.
#endif

namespace Json
{

static bool
isControlCharacter (char ch)
{
  return ch > 0 && ch <= 0x1F;
}

static bool
containsControlCharacter (const char *str)
{
  while (*str)
    if (isControlCharacter (*(str++)))
      return true;
  return false;
}

static void
uintToString (unsigned int 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 (UInt (value), current);
  if (isNegative)
    *--current = '-';
  assert (current >= buffer);
  return current;
}

std::string
valueToString (UInt 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];

#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) /* Use secure version with visual studio 2005 to avoid warning. */
  sprintf_s (buffer, sizeof (buffer), "%#.16g", value);
#else
  sprintf (buffer, "%#.16g", value);
#endif
  char *ch = buffer + strlen (buffer) - 1;
  if (*ch != '0')
    return buffer;                /* nothing to truncate, so save time */
  while (ch > buffer && *ch == '0')
    --ch;
  char *last_nonzero = ch;
  while (ch >= buffer)
    {
      switch (*ch)
        {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
          --ch;
          continue;
        case '.':
          /* Truncate zeroes to save bytes in output, but keep one. */
          *(last_nonzero + 2) = '\0';
          return buffer;
        default:
          return buffer;
        }
    }
  return buffer;
}

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

std::string
valueToQuotedString (const char *value)
{
  /* Not sure how to handle unicode... */
  if (strpbrk (value, "\"\\\b\f\n\r\t") == NULL && !containsControlCharacter (value))
    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 mallocs */
  result += "\"";
  for (const char *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.
         * blep notes: actually escaping \/ may be useful in javascript to avoid </
         * sequence.
         * Should add a flag to allow this compatibility mode and prevent this
         * sequence from occurring.
         */
        default:
          if (isControlCharacter (*c))
            {
              std::ostringstream oss;
              oss << "\\u" << std::hex << std::uppercase << std::setfill ('0') << std::setw (4) << static_cast<int> (*c);
              result += oss.str ();
            }
          else
            result += *c;
          break;
        }
    }
  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);
  return document_;
}

void
FastWriter::writeValue (const Value &value)
{
  switch (value.type ())
    {
    case nullValue:
      document_ += "null";
      break;
    case intValue:
      document_ += valueToString (value.asInt ());
      break;
    case uintValue:
      document_ += valueToString (value.asUInt ());
      break;
    case realValue:
      document_ += valueToString (value.asDouble ());
      break;
    case stringValue:
      document_ += valueToQuotedString (value.asCString ());
      break;
    case booleanValue:
      document_ += valueToString (value.asBool ());
      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 (value.asInt ()));
      break;
    case uintValue:
      pushValue (valueToString (value.asUInt ()));
      break;
    case realValue:
      pushValue (valueToString (value.asDouble ()));
      break;
    case stringValue:
      pushValue (valueToQuotedString (value.asCString ()));
      break;
    case booleanValue:
      pushValue (valueToString (value.asBool ()));
      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 ());
  const char *begin = text.c_str ();
  const char *end = begin + text.length ();
  const char *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;
}

/*
 * Class StyledStreamWriter
 * //////////////////////////////////////////////////////////////////
 */

StyledStreamWriter::StyledStreamWriter (std::string indentation)
  : document_ (NULL)
  , indentation_ (indentation)
  , rightMargin_ (74)
{
}

void
StyledStreamWriter::write (std::ostream &out, const Value &root)
{
  document_ = &out;
  addChildValues_ = false;
  indentString_ = "";
  writeCommentBeforeValue (root);
  writeValue (root);
  writeCommentAfterValueOnSameLine (root);
  *document_ << "\n";
  document_ = NULL;  /* Forget the stream, for safety. */
}

void
StyledStreamWriter::writeValue (const Value &value)
{
  switch (value.type ())
    {
    case nullValue:
      pushValue ("null");
      break;
    case intValue:
      pushValue (valueToString (value.asInt ()));
      break;
    case uintValue:
      pushValue (valueToString (value.asUInt ()));
      break;
    case realValue:
      pushValue (valueToString (value.asDouble ()));
      break;
    case stringValue:
      pushValue (valueToQuotedString (value.asCString ()));
      break;
    case booleanValue:
      pushValue (valueToString (value.asBool ()));
      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
StyledStreamWriter::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
StyledStreamWriter::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
StyledStreamWriter::pushValue (const std::string &value)
{
  if (addChildValues_)
    childValues_.push_back (value);
  else
    *document_ << value;
}

void
StyledStreamWriter::writeIndent ()
{
  /*
   * Some comments in this method would have been nice. ;-)
   *
   * 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_ << '\n' << indentString_;
}

void
StyledStreamWriter::writeWithIndent (const std::string &value)
{
  writeIndent ();
  *document_ << value;
}

void
StyledStreamWriter::indent ()
{
  indentString_ += indentation_;
}

void
StyledStreamWriter::unindent ()
{
  assert (indentString_.size () >= indentation_.size ());
  indentString_.resize (indentString_.size () - indentation_.size ());
}

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

void
StyledStreamWriter::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
StyledStreamWriter::hasCommentForValue (const Value &value)
{
  return value.hasComment (commentBefore)
         || value.hasComment (commentAfterOnSameLine)
         || value.hasComment (commentAfter);
}

std::string
StyledStreamWriter::normalizeEOL (const std::string &text)
{
  std::string normalized;

  normalized.reserve (text.length ());
  const char *begin = text.c_str ();
  const char *end = begin + text.length ();
  const char *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)
{
  Json::FastWriter writer;

  return sout << writer.write (root);
}

} // namespace Json
Revision:	1.1
Committed:	Sun Oct 17 08:15:06 2010 UTC (15 years, 11 months ago) by sf-pippijn
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	initial import
#	Content
1	#include <json/writer.h>
2	#include <utility>
3	#include <assert.h>
4	#include <stdio.h>
5	#include <string.h>
6	#include <iostream>
7	#include <sstream>
8	#include <iomanip>
9
10	#if _MSC_VER >= 1400 // VC++ 8.0
11	#pragma warning( disable : 4996 ) // disable warning about strdup being deprecated.
12	#endif
13
14	namespace Json
15	{
16
17	static bool
18	isControlCharacter (char ch)
19	{
20	return ch > 0 && ch <= 0x1F;
21	}
22
23	static bool
24	containsControlCharacter (const char *str)
25	{
26	while (*str)
27	if (isControlCharacter (*(str++)))
28	return true;
29	return false;
30	}
31
32	static void
33	uintToString (unsigned int value, char * &current)
34	{
35	*--current = 0;
36	do
37	{
38	*--current = (value % 10) + '0';
39	value /= 10;
40	}
41	while (value != 0);
42	}
43
44	std::string
45	valueToString (Int value)
46	{
47	char buffer[32];
48	char *current = buffer + sizeof (buffer);
49	bool isNegative = value < 0;
50
51	if (isNegative)
52	value = -value;
53	uintToString (UInt (value), current);
54	if (isNegative)
55	*--current = '-';
56	assert (current >= buffer);
57	return current;
58	}
59
60	std::string
61	valueToString (UInt value)
62	{
63	char buffer[32];
64	char *current = buffer + sizeof (buffer);
65
66	uintToString (value, current);
67	assert (current >= buffer);
68	return current;
69	}
70
71	std::string
72	valueToString (double value)
73	{
74	char buffer[32];
75
76	#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) /* Use secure version with visual studio 2005 to avoid warning. */
77	sprintf_s (buffer, sizeof (buffer), "%#.16g", value);
78	#else
79	sprintf (buffer, "%#.16g", value);
80	#endif
81	char *ch = buffer + strlen (buffer) - 1;
82	if (*ch != '0')
83	return buffer; /* nothing to truncate, so save time */
84	while (ch > buffer && *ch == '0')
85	--ch;
86	char *last_nonzero = ch;
87	while (ch >= buffer)
88	{
89	switch (*ch)
90	{
91	case '0':
92	case '1':
93	case '2':
94	case '3':
95	case '4':
96	case '5':
97	case '6':
98	case '7':
99	case '8':
100	case '9':
101	--ch;
102	continue;
103	case '.':
104	/* Truncate zeroes to save bytes in output, but keep one. */
105	*(last_nonzero + 2) = '\0';
106	return buffer;
107	default:
108	return buffer;
109	}
110	}
111	return buffer;
112	}
113
114	std::string
115	valueToString (bool value)
116	{
117	return value ? "true" : "false";
118	}
119
120	std::string
121	valueToQuotedString (const char *value)
122	{
123	/* Not sure how to handle unicode... */
124	if (strpbrk (value, "\"\\\b\f\n\r\t") == NULL && !containsControlCharacter (value))
125	return std::string ("\"") + value + "\"";
126	/*
127	* We have to walk value and escape any special characters.
128	* Appending to std::string is not efficient, but this should be rare.
129	* (Note: forward slashes are not rare, but I am not escaping them.)
130	*/
131	unsigned maxsize = strlen (value) * 2 + 3; /* allescaped+quotes+NULL */
132	std::string result;
133	result.reserve (maxsize); /* to avoid lots of mallocs */
134	result += "\"";
135	for (const char c = value; c != 0; ++c)
136	{
137	switch (*c)
138	{
139	case '\"':
140	result += "\\\"";
141	break;
142	case '\\':
143	result += "\\\\";
144	break;
145	case '\b':
146	result += "\\b";
147	break;
148	case '\f':
149	result += "\\f";
150	break;
151	case '\n':
152	result += "\\n";
153	break;
154	case '\r':
155	result += "\\r";
156	break;
157	case '\t':
158	result += "\\t";
159	break;
160	/*
161	* case '/':
162	* Even though \/ is considered a legal escape in JSON, a bare
163	* slash is also legal, so I see no reason to escape it.
164	* (I hope I am not misunderstanding something.
165	* blep notes: actually escaping \/ may be useful in javascript to avoid </
166	* sequence.
167	* Should add a flag to allow this compatibility mode and prevent this
168	* sequence from occurring.
169	*/
170	default:
171	if (isControlCharacter (*c))
172	{
173	std::ostringstream oss;
174	oss << "\\u" << std::hex << std::uppercase << std::setfill ('0') << std::setw (4) << static_cast<int> (*c);
175	result += oss.str ();
176	}
177	else
178	result += *c;
179	break;
180	}
181	}
182	result += "\"";
183	return result;
184	}
185
186	/*
187	* Class Writer
188	* //////////////////////////////////////////////////////////////////
189	*/
190	Writer::~Writer ()
191	{
192	}
193
194	/*
195	* Class FastWriter
196	* //////////////////////////////////////////////////////////////////
197	*/
198
199	FastWriter::FastWriter ()
200	: yamlCompatiblityEnabled_ (false)
201	{
202	}
203
204	void
205	FastWriter::enableYAMLCompatibility ()
206	{
207	yamlCompatiblityEnabled_ = true;
208	}
209
210	std::string
211	FastWriter::write (const Value &root)
212	{
213	document_ = "";
214	writeValue (root);
215	return document_;
216	}
217
218	void
219	FastWriter::writeValue (const Value &value)
220	{
221	switch (value.type ())
222	{
223	case nullValue:
224	document_ += "null";
225	break;
226	case intValue:
227	document_ += valueToString (value.asInt ());
228	break;
229	case uintValue:
230	document_ += valueToString (value.asUInt ());
231	break;
232	case realValue:
233	document_ += valueToString (value.asDouble ());
234	break;
235	case stringValue:
236	document_ += valueToQuotedString (value.asCString ());
237	break;
238	case booleanValue:
239	document_ += valueToString (value.asBool ());
240	break;
241	case arrayValue:
242	{
243	document_ += "[";
244	int size = value.size ();
245	for (int index = 0; index < size; ++index)
246	{
247	if (index > 0)
248	document_ += ",";
249	writeValue (value[index]);
250	}
251	document_ += "]";
252	break;
253	}
254	case objectValue:
255	{
256	Value::Members members (value.getMemberNames ());
257	document_ += "{";
258	for (Value::Members::iterator it = members.begin ();
259	it != members.end ();
260	++it)
261	{
262	const std::string &name = *it;
263	if (it != members.begin ())
264	document_ += ",";
265	document_ += valueToQuotedString (name.c_str ());
266	document_ += yamlCompatiblityEnabled_ ? ": "
267	: ":";
268	writeValue (value[name]);
269	}
270	document_ += "}";
271	break;
272	}
273	}
274	}
275
276	/*
277	* Class StyledWriter
278	* //////////////////////////////////////////////////////////////////
279	*/
280
281	StyledWriter::StyledWriter ()
282	: rightMargin_ (74)
283	, indentSize_ (3)
284	{
285	}
286
287	std::string
288	StyledWriter::write (const Value &root)
289	{
290	document_ = "";
291	addChildValues_ = false;
292	indentString_ = "";
293	writeCommentBeforeValue (root);
294	writeValue (root);
295	writeCommentAfterValueOnSameLine (root);
296	document_ += "\n";
297	return document_;
298	}
299
300	void
301	StyledWriter::writeValue (const Value &value)
302	{
303	switch (value.type ())
304	{
305	case nullValue:
306	pushValue ("null");
307	break;
308	case intValue:
309	pushValue (valueToString (value.asInt ()));
310	break;
311	case uintValue:
312	pushValue (valueToString (value.asUInt ()));
313	break;
314	case realValue:
315	pushValue (valueToString (value.asDouble ()));
316	break;
317	case stringValue:
318	pushValue (valueToQuotedString (value.asCString ()));
319	break;
320	case booleanValue:
321	pushValue (valueToString (value.asBool ()));
322	break;
323	case arrayValue:
324	writeArrayValue (value);
325	break;
326	case objectValue:
327	{
328	Value::Members members (value.getMemberNames ());
329	if (members.empty ())
330	pushValue ("{}");
331	else
332	{
333	writeWithIndent ("{");
334	indent ();
335	Value::Members::iterator it = members.begin ();
336	while (true)
337	{
338	const std::string &name = *it;
339	const Value &childValue = value[name];
340	writeCommentBeforeValue (childValue);
341	writeWithIndent (valueToQuotedString (name.c_str ()));
342	document_ += " : ";
343	writeValue (childValue);
344	if (++it == members.end ())
345	{
346	writeCommentAfterValueOnSameLine (childValue);
347	break;
348	}
349	document_ += ",";
350	writeCommentAfterValueOnSameLine (childValue);
351	}
352	unindent ();
353	writeWithIndent ("}");
354	}
355	break;
356	}
357	}
358	}
359
360	void
361	StyledWriter::writeArrayValue (const Value &value)
362	{
363	unsigned size = value.size ();
364
365	if (size == 0)
366	pushValue ("[]");
367	else
368	{
369	bool isArrayMultiLine = isMultineArray (value);
370	if (isArrayMultiLine)
371	{
372	writeWithIndent ("[");
373	indent ();
374	bool hasChildValue = !childValues_.empty ();
375	unsigned index = 0;
376	while (true)
377	{
378	const Value &childValue = value[index];
379	writeCommentBeforeValue (childValue);
380	if (hasChildValue)
381	writeWithIndent (childValues_[index]);
382	else
383	{
384	writeIndent ();
385	writeValue (childValue);
386	}
387	if (++index == size)
388	{
389	writeCommentAfterValueOnSameLine (childValue);
390	break;
391	}
392	document_ += ",";
393	writeCommentAfterValueOnSameLine (childValue);
394	}
395	unindent ();
396	writeWithIndent ("]");
397	}
398	else /* output on a single line */
399	{
400	assert (childValues_.size () == size);
401	document_ += "[ ";
402	for (unsigned index = 0; index < size; ++index)
403	{
404	if (index > 0)
405	document_ += ", ";
406	document_ += childValues_[index];
407	}
408	document_ += " ]";
409	}
410	}
411	}
412
413	bool
414	StyledWriter::isMultineArray (const Value &value)
415	{
416	int size = value.size ();
417	bool isMultiLine = size * 3 >= rightMargin_;
418
419	childValues_.clear ();
420	for (int index = 0; index < size && !isMultiLine; ++index)
421	{
422	const Value &childValue = value[index];
423	isMultiLine = isMultiLine \|\|
424	((childValue.isArray () \|\| childValue.isObject ()) &&
425	childValue.size () > 0);
426	}
427	if (!isMultiLine) /* check if line length > max line length */
428	{
429	childValues_.reserve (size);
430	addChildValues_ = true;
431	int lineLength = 4 + (size - 1) * 2; /* '[ ' + ', 'n + ' ]' /
432	for (int index = 0; index < size && !isMultiLine; ++index)
433	{
434	writeValue (value[index]);
435	lineLength += int(childValues_[index].length ());
436	isMultiLine = isMultiLine && hasCommentForValue (value[index]);
437	}
438	addChildValues_ = false;
439	isMultiLine = isMultiLine \|\| lineLength >= rightMargin_;
440	}
441	return isMultiLine;
442	}
443
444	void
445	StyledWriter::pushValue (const std::string &value)
446	{
447	if (addChildValues_)
448	childValues_.push_back (value);
449	else
450	document_ += value;
451	}
452
453	void
454	StyledWriter::writeIndent ()
455	{
456	if (!document_.empty ())
457	{
458	char last = document_[document_.length () - 1];
459	if (last == ' ') /* already indented */
460	return;
461	if (last != '\n') /* Comments may add new-line */
462	document_ += '\n';
463	}
464	document_ += indentString_;
465	}
466
467	void
468	StyledWriter::writeWithIndent (const std::string &value)
469	{
470	writeIndent ();
471	document_ += value;
472	}
473
474	void
475	StyledWriter::indent ()
476	{
477	indentString_ += std::string (indentSize_, ' ');
478	}
479
480	void
481	StyledWriter::unindent ()
482	{
483	assert (int(indentString_.size ()) >= indentSize_);
484	indentString_.resize (indentString_.size () - indentSize_);
485	}
486
487	void
488	StyledWriter::writeCommentBeforeValue (const Value &root)
489	{
490	if (!root.hasComment (commentBefore))
491	return;
492	document_ += normalizeEOL (root.getComment (commentBefore));
493	document_ += "\n";
494	}
495
496	void
497	StyledWriter::writeCommentAfterValueOnSameLine (const Value &root)
498	{
499	if (root.hasComment (commentAfterOnSameLine))
500	document_ += " " + normalizeEOL (root.getComment (commentAfterOnSameLine));
501
502	if (root.hasComment (commentAfter))
503	{
504	document_ += "\n";
505	document_ += normalizeEOL (root.getComment (commentAfter));
506	document_ += "\n";
507	}
508	}
509
510	bool
511	StyledWriter::hasCommentForValue (const Value &value)
512	{
513	return value.hasComment (commentBefore)
514	\|\| value.hasComment (commentAfterOnSameLine)
515	\|\| value.hasComment (commentAfter);
516	}
517
518	std::string
519	StyledWriter::normalizeEOL (const std::string &text)
520	{
521	std::string normalized;
522
523	normalized.reserve (text.length ());
524	const char *begin = text.c_str ();
525	const char *end = begin + text.length ();
526	const char *current = begin;
527	while (current != end)
528	{
529	char c = *current++;
530	if (c == '\r') /* mac or dos EOL */
531	{
532	if (current == '\n') / convert dos EOL */
533	++current;
534	normalized += '\n';
535	}
536	else /* handle unix EOL & other char */
537	normalized += c;
538	}
539	return normalized;
540	}
541
542	/*
543	* Class StyledStreamWriter
544	* //////////////////////////////////////////////////////////////////
545	*/
546
547	StyledStreamWriter::StyledStreamWriter (std::string indentation)
548	: document_ (NULL)
549	, indentation_ (indentation)
550	, rightMargin_ (74)
551	{
552	}
553
554	void
555	StyledStreamWriter::write (std::ostream &out, const Value &root)
556	{
557	document_ = &out;
558	addChildValues_ = false;
559	indentString_ = "";
560	writeCommentBeforeValue (root);
561	writeValue (root);
562	writeCommentAfterValueOnSameLine (root);
563	*document_ << "\n";
564	document_ = NULL; /* Forget the stream, for safety. */
565	}
566
567	void
568	StyledStreamWriter::writeValue (const Value &value)
569	{
570	switch (value.type ())
571	{
572	case nullValue:
573	pushValue ("null");
574	break;
575	case intValue:
576	pushValue (valueToString (value.asInt ()));
577	break;
578	case uintValue:
579	pushValue (valueToString (value.asUInt ()));
580	break;
581	case realValue:
582	pushValue (valueToString (value.asDouble ()));
583	break;
584	case stringValue:
585	pushValue (valueToQuotedString (value.asCString ()));
586	break;
587	case booleanValue:
588	pushValue (valueToString (value.asBool ()));
589	break;
590	case arrayValue:
591	writeArrayValue (value);
592	break;
593	case objectValue:
594	{
595	Value::Members members (value.getMemberNames ());
596	if (members.empty ())
597	pushValue ("{}");
598	else
599	{
600	writeWithIndent ("{");
601	indent ();
602	Value::Members::iterator it = members.begin ();
603	while (true)
604	{
605	const std::string &name = *it;
606	const Value &childValue = value[name];
607	writeCommentBeforeValue (childValue);
608	writeWithIndent (valueToQuotedString (name.c_str ()));
609	*document_ << " : ";
610	writeValue (childValue);
611	if (++it == members.end ())
612	{
613	writeCommentAfterValueOnSameLine (childValue);
614	break;
615	}
616	*document_ << ",";
617	writeCommentAfterValueOnSameLine (childValue);
618	}
619	unindent ();
620	writeWithIndent ("}");
621	}
622	break;
623	}
624	}
625	}
626
627	void
628	StyledStreamWriter::writeArrayValue (const Value &value)
629	{
630	unsigned size = value.size ();
631
632	if (size == 0)
633	pushValue ("[]");
634	else
635	{
636	bool isArrayMultiLine = isMultineArray (value);
637	if (isArrayMultiLine)
638	{
639	writeWithIndent ("[");
640	indent ();
641	bool hasChildValue = !childValues_.empty ();
642	unsigned index = 0;
643	while (true)
644	{
645	const Value &childValue = value[index];
646	writeCommentBeforeValue (childValue);
647	if (hasChildValue)
648	writeWithIndent (childValues_[index]);
649	else
650	{
651	writeIndent ();
652	writeValue (childValue);
653	}
654	if (++index == size)
655	{
656	writeCommentAfterValueOnSameLine (childValue);
657	break;
658	}
659	*document_ << ",";
660	writeCommentAfterValueOnSameLine (childValue);
661	}
662	unindent ();
663	writeWithIndent ("]");
664	}
665	else /* output on a single line */
666	{
667	assert (childValues_.size () == size);
668	*document_ << "[ ";
669	for (unsigned index = 0; index < size; ++index)
670	{
671	if (index > 0)
672	*document_ << ", ";
673	*document_ << childValues_[index];
674	}
675	*document_ << " ]";
676	}
677	}
678	}
679
680	bool
681	StyledStreamWriter::isMultineArray (const Value &value)
682	{
683	int size = value.size ();
684	bool isMultiLine = size * 3 >= rightMargin_;
685
686	childValues_.clear ();
687	for (int index = 0; index < size && !isMultiLine; ++index)
688	{
689	const Value &childValue = value[index];
690	isMultiLine = isMultiLine \|\|
691	((childValue.isArray () \|\| childValue.isObject ()) &&
692	childValue.size () > 0);
693	}
694	if (!isMultiLine) /* check if line length > max line length */
695	{
696	childValues_.reserve (size);
697	addChildValues_ = true;
698	int lineLength = 4 + (size - 1) * 2; /* '[ ' + ', 'n + ' ]' /
699	for (int index = 0; index < size && !isMultiLine; ++index)
700	{
701	writeValue (value[index]);
702	lineLength += int(childValues_[index].length ());
703	isMultiLine = isMultiLine && hasCommentForValue (value[index]);
704	}
705	addChildValues_ = false;
706	isMultiLine = isMultiLine \|\| lineLength >= rightMargin_;
707	}
708	return isMultiLine;
709	}
710
711	void
712	StyledStreamWriter::pushValue (const std::string &value)
713	{
714	if (addChildValues_)
715	childValues_.push_back (value);
716	else
717	*document_ << value;
718	}
719
720	void
721	StyledStreamWriter::writeIndent ()
722	{
723	/*
724	* Some comments in this method would have been nice. ;-)
725	*
726	* if ( !document_.empty() )
727	* {
728	* char last = document_[document_.length()-1];
729	* if ( last == ' ' ) // already indented
730	* return;
731	* if ( last != '\n' ) // Comments may add new-line
732	* *document_ << '\n';
733	* }
734	*/
735	*document_ << '\n' << indentString_;
736	}
737
738	void
739	StyledStreamWriter::writeWithIndent (const std::string &value)
740	{
741	writeIndent ();
742	*document_ << value;
743	}
744
745	void
746	StyledStreamWriter::indent ()
747	{
748	indentString_ += indentation_;
749	}
750
751	void
752	StyledStreamWriter::unindent ()
753	{
754	assert (indentString_.size () >= indentation_.size ());
755	indentString_.resize (indentString_.size () - indentation_.size ());
756	}
757
758	void
759	StyledStreamWriter::writeCommentBeforeValue (const Value &root)
760	{
761	if (!root.hasComment (commentBefore))
762	return;
763	*document_ << normalizeEOL (root.getComment (commentBefore));
764	*document_ << "\n";
765	}
766
767	void
768	StyledStreamWriter::writeCommentAfterValueOnSameLine (const Value &root)
769	{
770	if (root.hasComment (commentAfterOnSameLine))
771	*document_ << " " + normalizeEOL (root.getComment (commentAfterOnSameLine));
772
773	if (root.hasComment (commentAfter))
774	{
775	*document_ << "\n";
776	*document_ << normalizeEOL (root.getComment (commentAfter));
777	*document_ << "\n";
778	}
779	}
780
781	bool
782	StyledStreamWriter::hasCommentForValue (const Value &value)
783	{
784	return value.hasComment (commentBefore)
785	\|\| value.hasComment (commentAfterOnSameLine)
786	\|\| value.hasComment (commentAfter);
787	}
788
789	std::string
790	StyledStreamWriter::normalizeEOL (const std::string &text)
791	{
792	std::string normalized;
793
794	normalized.reserve (text.length ());
795	const char *begin = text.c_str ();
796	const char *end = begin + text.length ();
797	const char *current = begin;
798	while (current != end)
799	{
800	char c = *current++;
801	if (c == '\r') /* mac or dos EOL */
802	{
803	if (current == '\n') / convert dos EOL */
804	++current;
805	normalized += '\n';
806	}
807	else /* handle unix EOL & other char */
808	normalized += c;
809	}
810	return normalized;
811	}
812
813	std::ostream &
814	operator << (std::ostream &sout, const Value &root)
815	{
816	Json::FastWriter writer;
817
818	return sout << writer.write (root);
819	}
820
821	} // namespace Json