prettywriter.h

Go to the documentation of this file.

#ifndef RAPIDJSON_PRETTYWRITER_H_
#define RAPIDJSON_PRETTYWRITER_H_

#include "writer.h"

namespace rapidjson {


template<typename Stream, typename Encoding = UTF8<>, typename Allocator = MemoryPoolAllocator<> >
class PrettyWriter : public Writer<Stream, Encoding, Allocator> {
public:
   typedef Writer<Stream, Encoding, Allocator> Base;
   typedef typename Base::Ch Ch;


   PrettyWriter(Stream& stream, Allocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
      Base(stream, allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}


   PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) {
      RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
      indentChar_ = indentChar;
      indentCharCount_ = indentCharCount;
      return *this;
   }

   //@name Implementation of Handler.

   PrettyWriter& Null()          { PrettyPrefix(kNullType);   Base::WriteNull();       return *this; }
   PrettyWriter& Bool(bool b)       { PrettyPrefix(b ? kTrueType : kFalseType); Base::WriteBool(b); return *this; }
   PrettyWriter& Int(int i)         { PrettyPrefix(kNumberType); Base::WriteInt(i);       return *this; }
   PrettyWriter& Uint(unsigned u)      { PrettyPrefix(kNumberType); Base::WriteUint(u);      return *this; }
   PrettyWriter& Int64(int64_t i64) { PrettyPrefix(kNumberType); Base::WriteInt64(i64);      return *this; }
   PrettyWriter& Uint64(uint64_t u64)  { PrettyPrefix(kNumberType); Base::WriteUint64(u64);  return *this; }
   PrettyWriter& Double(double d)      { PrettyPrefix(kNumberType); Base::WriteDouble(d);    return *this; }

   PrettyWriter& String(const Ch* str, SizeType length, bool copy = false) {
      (void)copy;
      PrettyPrefix(kStringType);
      Base::WriteString(str, length);
      return *this;
   }

   PrettyWriter& StartObject() {
      PrettyPrefix(kObjectType);
      new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
      Base::WriteStartObject();
      return *this;
   }

   PrettyWriter& EndObject(SizeType memberCount = 0) {
      (void)memberCount;
      RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
      RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray);
      bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;

      if (!empty) {
         Base::stream_.Put('\n');
         WriteIndent();
      }
      Base::WriteEndObject();
      return *this;
   }

   PrettyWriter& StartArray() {
      PrettyPrefix(kArrayType);
      new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
      Base::WriteStartArray();
      return *this;
   }

   PrettyWriter& EndArray(SizeType memberCount = 0) {
      (void)memberCount;
      RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
      RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
      bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;

      if (!empty) {
         Base::stream_.Put('\n');
         WriteIndent();
      }
      Base::WriteEndArray();
      return *this;
   }


   PrettyWriter& String(const Ch* str) { return String(str, internal::StrLen(str)); }

protected:
   void PrettyPrefix(Type type) {
      (void)type;
      if (Base::level_stack_.GetSize() != 0) { // this value is not at root
         typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();

         if (level->inArray) {
            if (level->valueCount > 0) {
               Base::stream_.Put(','); // add comma if it is not the first element in array
               Base::stream_.Put('\n');
            }
            else
               Base::stream_.Put('\n');
            WriteIndent();
         }
         else {   // in object
            if (level->valueCount > 0) {
               if (level->valueCount % 2 == 0) {
                  Base::stream_.Put(',');
                  Base::stream_.Put('\n');
               }
               else {
                  Base::stream_.Put(':');
                  Base::stream_.Put(' ');
               }
            }
            else
               Base::stream_.Put('\n');

            if (level->valueCount % 2 == 0)
               WriteIndent();
         }
         if (!level->inArray && level->valueCount % 2 == 0)
            RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
         level->valueCount++;
      }
      else
         RAPIDJSON_ASSERT(type == kObjectType || type == kArrayType);
   }

   void WriteIndent()  {
      size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
      PutN(Base::stream_, indentChar_, count);
   }

   Ch indentChar_;
   unsigned indentCharCount_;
};

} // namespace rapidjson

#endif // RAPIDJSON_RAPIDJSON_H_