extlibs/cereal/cereal/include/cereal/external/rapidjson/writer.h

   1 #ifndef RAPIDJSON_WRITER_H_
   2 #define RAPIDJSON_WRITER_H_
   3
   4 #include "rapidjson.h"
   5 #include "internal/stack.h"
   6 #include "internal/strfunc.h"
   7 #include <cstdio>       // snprintf() or _sprintf_s()
   8 #include <new>          // placement new
   9 #include <limits>
  10
  11 #ifdef _MSC_VER
  12 #pragma warning(push)
  13 #pragma warning(disable : 4127) // conditional expression is constant
  14 #endif
  15
  16 namespace rapidjson {
  17
  18 //! JSON writer
  19 /*! Writer implements the concept Handler.
  20         It generates JSON text by events to an output stream.
  21
  22         User may programmatically calls the functions of a writer to generate JSON text.
  23
  24         On the other side, a writer can also be passed to objects that generates events,
  25
  26         for example Reader::Parse() and Document::Accept().
  27
  28         \tparam Stream Type of ouptut stream.
  29         \tparam Encoding Encoding of both source strings and output.
  30         \implements Handler
  31 */
  32 template<typename Stream, typename Encoding = UTF8<>, typename Allocator = MemoryPoolAllocator<> >
  33 class Writer {
  34 public:
  35         typedef typename Encoding::Ch Ch;
  36
  37         Writer(Stream& stream, int precision = 20, Allocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
  38                 stream_(stream), level_stack_(allocator, levelDepth * sizeof(Level))
  39   {
  40 #if _MSC_VER
  41     (void) sprintf_s(double_format, sizeof(double_format), "%%0.%dg", precision);
  42     (void) sprintf_s( long_double_format, sizeof( long_double_format ), "%%0.%dLg", precision );
  43 #else
  44     (void) snprintf(double_format, sizeof(double_format), "%%0.%dg", precision);
  45     (void) snprintf( long_double_format, sizeof( long_double_format ), "%%0.%dLg", precision );
  46 #endif
  47
  48   }
  49
  50 protected:
  51   char double_format[32];
  52   char long_double_format[32];
  53 public:
  54
  55         //@name Implementation of Handler
  56         //@{
  57
  58         Writer& Null_()                          { Prefix(kNull_Type);   WriteNull_();                  return *this;             }
  59         Writer& Bool_(bool b)                    { Prefix(b ? kTrueType : kFalseType); WriteBool_(b); return *this; }
  60         Writer& Int(int i)                      { Prefix(kNumberType); WriteInt(i);                     return *this;             }
  61         Writer& Uint(unsigned u)                { Prefix(kNumberType); WriteUint(u);            return *this;             }
  62         Writer& Int64(int64_t i64)              { Prefix(kNumberType); WriteInt64(i64);         return *this;           }
  63         Writer& Uint64(uint64_t u64)            { Prefix(kNumberType); WriteUint64(u64);        return *this;           }
  64         Writer& Double(double d)                { Prefix(kNumberType); WriteDouble(d);          return *this;           }
  65         Writer& LongDouble(long double d)       { Prefix(kNumberType); WriteLongDouble(d);              return *this;       }
  66         Writer& LongLong(long long d)           { Prefix(kNumberType); WriteLongLong(d);                return *this;         }
  67         Writer& ULongLong(unsigned long long d) { Prefix(kNumberType); WriteULongLong(d);               return *this;         }
  68
  69         Writer& String(const Ch* str, SizeType length, bool copy = false) {
  70                 (void)copy;
  71                 Prefix(kStringType);
  72                 WriteString(str, length);
  73                 return *this;
  74         }
  75
  76         Writer& StartObject() {
  77                 Prefix(kObjectType);
  78                 new (level_stack_.template Push<Level>()) Level(false);
  79                 WriteStartObject();
  80                 return *this;
  81         }
  82
  83         Writer& EndObject(SizeType memberCount = 0) {
  84                 (void)memberCount;
  85                 RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
  86                 RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray);
  87                 level_stack_.template Pop<Level>(1);
  88                 WriteEndObject();
  89                 return *this;
  90         }
  91
  92         Writer& StartArray() {
  93                 Prefix(kArrayType);
  94                 new (level_stack_.template Push<Level>()) Level(true);
  95                 WriteStartArray();
  96                 return *this;
  97         }
  98
  99         Writer& EndArray(SizeType elementCount = 0) {
 100                 (void)elementCount;
 101                 RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
 102                 RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
 103                 level_stack_.template Pop<Level>(1);
 104                 WriteEndArray();
 105                 return *this;
 106         }
 107         //@}
 108
 109         //! Simpler but slower overload.
 110         Writer& String(const Ch* str) { return String(str, internal::StrLen(str)); }
 111
 112 protected:
 113         //! Information for each nested level
 114         struct Level {
 115                 Level(bool inArray_) : inArray(inArray_), valueCount(0) {}
 116                 bool inArray;           //!< true if in array, otherwise in object
 117                 size_t valueCount;      //!< number of values in this level
 118         };
 119
 120         static const size_t kDefaultLevelDepth = 32;
 121
 122         void WriteNull_()  {
 123                 stream_.Put('n'); stream_.Put('u'); stream_.Put('l'); stream_.Put('l');
 124         }
 125
 126         void WriteBool_(bool b)  {
 127                 if (b) {
 128                         stream_.Put('t'); stream_.Put('r'); stream_.Put('u'); stream_.Put('e');
 129                 }
 130                 else {
 131                         stream_.Put('f'); stream_.Put('a'); stream_.Put('l'); stream_.Put('s'); stream_.Put('e');
 132                 }
 133         }
 134
 135         void WriteInt(int i) {
 136                 if (i < 0) {
 137                         stream_.Put('-');
 138                         i = -i;
 139                 }
 140                 WriteUint((unsigned)i);
 141         }
 142
 143         void WriteUint(unsigned u) {
 144                 char buffer[10];
 145                 char *p = buffer;
 146                 do {
 147                         *p++ = (u % 10) + '0';
 148                         u /= 10;
 149                 } while (u > 0);
 150
 151                 do {
 152                         --p;
 153                         stream_.Put(*p);
 154                 } while (p != buffer);
 155         }
 156
 157         void WriteInt64(int64_t i64) {
 158                 if (i64 < 0) {
 159                         stream_.Put('-');
 160                         i64 = -i64;
 161                 }
 162                 WriteUint64((uint64_t)i64);
 163         }
 164
 165         void WriteUint64(uint64_t u64) {
 166                 char buffer[20];
 167                 char *p = buffer;
 168                 do {
 169                         *p++ = char(u64 % 10) + '0';
 170                         u64 /= 10;
 171                 } while (u64 > 0);
 172
 173                 do {
 174                         --p;
 175                         stream_.Put(*p);
 176                 } while (p != buffer);
 177         }
 178
 179   // cereal Temporary until constexpr support is added in RTM
 180 //#ifdef _MSC_VER
 181   template <class Ch>
 182   bool characterOk( Ch c )
 183   {
 184     return c < 256;
 185   }
 186
 187 /*#else
 188   // As part of a fix for GCC 4.7
 189   template <class T>
 190   static constexpr int to_int( T t ){ return t; }
 191
 192   template<class Ch>
 193   typename std::enable_if < to_int(std::numeric_limits<Ch>::max()) < to_int(256), bool>::type
 194     characterOk( Ch )
 195   {
 196     return true;
 197   }
 198
 199   template<class Ch>
 200   typename std::enable_if< to_int(std::numeric_limits<Ch>::max()) >= to_int(256), bool>::type
 201     characterOk(Ch c)
 202   { return c < 256; }
 203 #endif*/
 204
 205         //! \todo Optimization with custom double-to-string converter.
 206         void WriteDouble(double d) {
 207                 char buffer[100];
 208 #if _MSC_VER
 209                 int ret = sprintf_s(buffer, sizeof(buffer), double_format, d);
 210 #else
 211                 int ret = snprintf(buffer, sizeof(buffer), double_format, d);
 212 #endif
 213                 RAPIDJSON_ASSERT(ret >= 1);
 214                 for (int i = 0; i < ret; i++)
 215                         stream_.Put(buffer[i]);
 216         }
 217
 218         void WriteLongDouble(long double d) {
 219                 char buffer[256];
 220 #if _MSC_VER
 221                 int ret = sprintf_s(buffer, sizeof(buffer), long_double_format, d);
 222 #else
 223                 int ret = snprintf(buffer, sizeof(buffer), long_double_format, d);
 224 #endif
 225                 RAPIDJSON_ASSERT(ret >= 1);
 226                 for (int i = 0; i < ret; i++)
 227                         stream_.Put(buffer[i]);
 228         }
 229
 230         void WriteLongLong(long long d) {
 231                 char buffer[256];
 232 #if _MSC_VER
 233                 int ret = sprintf_s(buffer, sizeof(buffer), "%lld", d);
 234 #else
 235                 int ret = snprintf(buffer, sizeof(buffer), "%lld", d);
 236 #endif
 237                 RAPIDJSON_ASSERT(ret >= 1);
 238                 for (int i = 0; i < ret; i++)
 239                         stream_.Put(buffer[i]);
 240         }
 241
 242         void WriteULongLong(unsigned long long d) {
 243                 char buffer[256];
 244 #if _MSC_VER
 245                 int ret = sprintf_s(buffer, sizeof(buffer), "%llu", d);
 246 #else
 247                 int ret = snprintf(buffer, sizeof(buffer), "%llu", d);
 248 #endif
 249                 RAPIDJSON_ASSERT(ret >= 1);
 250                 for (int i = 0; i < ret; i++)
 251                         stream_.Put(buffer[i]);
 252         }
 253
 254         void WriteString(const Ch* str, SizeType length)  {
 255                 static const char hexDigits[] = "0123456789ABCDEF";
 256                 static const char escape[256] = {
 257 #define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 258                         //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
 259                         'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
 260                         'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
 261                           0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
 262                         Z16, Z16,                                                                                                                                               // 30~4F
 263                           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
 264                         Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                                                // 60~FF
 265 #undef Z16
 266                 };
 267
 268                 stream_.Put('\"');
 269                 for (const Ch* p = str; p != str + length; ++p) {
 270                         if ((sizeof(Ch) == 1 || characterOk(*p)) && escape[(unsigned char)*p])  {
 271                         //if ((sizeof(Ch) == 1 || *p < 256) && escape[(unsigned char)*p])  {
 272                                 stream_.Put('\\');
 273                                 stream_.Put(escape[(unsigned char)*p]);
 274                                 if (escape[(unsigned char)*p] == 'u') {
 275                                         stream_.Put('0');
 276                                         stream_.Put('0');
 277                                         stream_.Put(hexDigits[(*p) >> 4]);
 278                                         stream_.Put(hexDigits[(*p) & 0xF]);
 279                                 }
 280                         }
 281                         else
 282                                 stream_.Put(*p);
 283                 }
 284                 stream_.Put('\"');
 285         }
 286
 287         void WriteStartObject() { stream_.Put('{'); }
 288         void WriteEndObject()   { stream_.Put('}'); }
 289         void WriteStartArray()  { stream_.Put('['); }
 290         void WriteEndArray()    { stream_.Put(']'); }
 291
 292         void Prefix(Type type) {
 293                 (void)type;
 294                 if (level_stack_.GetSize() != 0) { // this value is not at root
 295                         Level* level = level_stack_.template Top<Level>();
 296                         if (level->valueCount > 0) {
 297                                 if (level->inArray)
 298                                         stream_.Put(','); // add comma if it is not the first element in array
 299                                 else  // in object
 300                                         stream_.Put((level->valueCount % 2 == 0) ? ',' : ':');
 301                         }
 302                         if (!level->inArray && level->valueCount % 2 == 0)
 303                                 RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
 304                         level->valueCount++;
 305                 }
 306                 else
 307                         RAPIDJSON_ASSERT(type == kObjectType || type == kArrayType);
 308         }
 309
 310         Stream& stream_;
 311         internal::Stack<Allocator> level_stack_;
 312
 313 private:
 314         // Prohibit assignment for VC C4512 warning
 315         Writer& operator=(const Writer& w);
 316 };
 317
 318 } // namespace rapidjson
 319
 320 #ifdef _MSC_VER
 321 #pragma warning(pop)
 322 #endif
 323
 324 #endif // RAPIDJSON_RAPIDJSON_H_