prettywriter.h

Go to the documentation of this file.

//Copyright (c) 2013-2023, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
#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, int precision = 20, Allocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
        Base(stream, precision, 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(kNull_Type);   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_