rapidjson.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_RAPIDJSON_H_
#define RAPIDJSON_RAPIDJSON_H_
 
// Copyright (c) 2011-2023 Milo Yip (miloyip@gmail.com)
// Version 0.11
 
#include <cstdlib>  // malloc(), realloc(), free()
#include <cstring>  // memcpy()
 
// RAPIDJSON_NO_INT64DEFINE
 
// Here defines int64_t and uint64_t types in global namespace.
// If user have their own definition, can define RAPIDJSON_NO_INT64DEFINE to disable this.
#ifndef RAPIDJSON_NO_INT64DEFINE
#ifdef _MSC_VER
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#else
#include <inttypes.h>
#endif
#endif // RAPIDJSON_NO_INT64TYPEDEF
 
// RAPIDJSON_ENDIAN
#define RAPIDJSON_LITTLEENDIAN  0   
#define RAPIDJSON_BIGENDIAN     1   
 
 
#ifndef RAPIDJSON_ENDIAN
#ifdef __BYTE_ORDER__
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
#else
#define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
#endif // __BYTE_ORDER__
#else
#define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN // Assumes little endian otherwise.
#endif
#endif // RAPIDJSON_ENDIAN
 
// RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_SIMD
 
// Enable SSE2 optimization.
//#define RAPIDJSON_SSE2
 
// Enable SSE4.2 optimization.
//#define RAPIDJSON_SSE42
 
#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
#define RAPIDJSON_SIMD
#endif
 
// RAPIDJSON_NO_SIZETYPEDEFINE
 
#ifndef RAPIDJSON_NO_SIZETYPEDEFINE
namespace rapidjson {
 
typedef unsigned SizeType;
} // namespace rapidjson
#endif
 
// RAPIDJSON_ASSERT
 
 
#ifndef RAPIDJSON_ASSERT
#include <cassert>
#define RAPIDJSON_ASSERT(x) assert(x)
#endif // RAPIDJSON_ASSERT
 
// Helpers
 
#define RAPIDJSON_MULTILINEMACRO_BEGIN do {  
#define RAPIDJSON_MULTILINEMACRO_END \
} while((void)0, 0)
 
namespace rapidjson {
 
// Allocator
 
// CrtAllocator
 
 
class CrtAllocator {
public:
    static const bool kNeedFree = true;
    void* Malloc(size_t size) { return malloc(size); }
    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) { (void)originalSize; return realloc(originalPtr, newSize); }
    static void Free(void *ptr) { free(ptr); }
};
 
// MemoryPoolAllocator
 
 
template <typename BaseAllocator = CrtAllocator>
class MemoryPoolAllocator {
public:
    static const bool kNeedFree = false;    
 
 
    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 
        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
    {
        if (!baseAllocator_)
            ownBaseAllocator_ = baseAllocator_ = new BaseAllocator();
        AddChunk(chunk_capacity_);
    }
 
 
    MemoryPoolAllocator(char *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) :
        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
    {
        RAPIDJSON_ASSERT(buffer != 0);
        RAPIDJSON_ASSERT(size > sizeof(ChunkHeader));
        chunkHead_ = (ChunkHeader*)buffer;
        chunkHead_->capacity = size - sizeof(ChunkHeader);
        chunkHead_->size = 0;
        chunkHead_->next = 0;
    }
 
 
    ~MemoryPoolAllocator() {
        Clear();
        delete ownBaseAllocator_;
    }
 
    void Clear() {
        while(chunkHead_ != 0 && chunkHead_ != (ChunkHeader *)userBuffer_) {
            ChunkHeader* next = chunkHead_->next;
            baseAllocator_->Free(chunkHead_);
            chunkHead_ = next;
        }
    }
 
 
    size_t Capacity() {
        size_t capacity = 0;
        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
            capacity += c->capacity;
        return capacity;
    }
 
 
    size_t Size() {
        size_t size = 0;
        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
            size += c->size;
        return size;
    }
 
    void* Malloc(size_t size) {
        size = (size + 3) & ~3; // Force aligning size to 4
 
        if (chunkHead_->size + size > chunkHead_->capacity)
            AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size);
 
        char *buffer = (char *)(chunkHead_ + 1) + chunkHead_->size;
        RAPIDJSON_ASSERT(((uintptr_t)buffer & 3) == 0); // returned buffer is aligned to 4
        chunkHead_->size += size;
 
        return buffer;
    }
 
    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
        if (originalPtr == 0)
            return Malloc(newSize);
 
        // Do not shrink if new size is smaller than original
        if (originalSize >= newSize)
            return originalPtr;
 
        // Simply expand it if it is the last allocation and there is sufficient space
        if (originalPtr == (char *)(chunkHead_ + 1) + chunkHead_->size - originalSize) {
            size_t increment = newSize - originalSize;
            increment = (increment + 3) & ~3;   // Force aligning size to 4
            if (chunkHead_->size + increment <= chunkHead_->capacity) {
                chunkHead_->size += increment;
                RAPIDJSON_ASSERT(((uintptr_t)originalPtr & 3) == 0);    // returned buffer is aligned to 4
                return originalPtr;
            }
        }
 
        // Realloc process: allocate and copy memory, do not free original buffer.
        void* newBuffer = Malloc(newSize);
        RAPIDJSON_ASSERT(newBuffer != 0);   // Do not handle out-of-memory explicitly.
        return memcpy(newBuffer, originalPtr, originalSize);
    }
 
    static void Free(void *) {} // Do nothing
 
private:
 
    void AddChunk(size_t capacity) {
        ChunkHeader* chunk = (ChunkHeader*)baseAllocator_->Malloc(sizeof(ChunkHeader) + capacity);
        chunk->capacity = capacity;
        chunk->size = 0;
        chunk->next = chunkHead_;
        chunkHead_ =  chunk;
    }
 
    static const int kDefaultChunkCapacity = 64 * 1024; 
 
 
    struct ChunkHeader {
        size_t capacity;    
        size_t size;        
        ChunkHeader *next;  
    };
 
    ChunkHeader *chunkHead_;    
    size_t chunk_capacity_;     
    char *userBuffer_;          
    BaseAllocator* baseAllocator_;  
    BaseAllocator* ownBaseAllocator_;   
};
 
// Encoding
 
 
// UTF8
 
 
template<typename CharType = char>
struct UTF8 {
    typedef CharType Ch;
 
    static Ch* Encode(Ch *buffer, unsigned codepoint) {
        if (codepoint <= 0x7F) 
            *buffer++ = codepoint & 0xFF;
        else if (codepoint <= 0x7FF) {
            *buffer++ = 0xC0 | ((codepoint >> 6) & 0xFF);
            *buffer++ = 0x80 | ((codepoint & 0x3F));
        }
        else if (codepoint <= 0xFFFF) {
            *buffer++ = 0xE0 | ((codepoint >> 12) & 0xFF);
            *buffer++ = 0x80 | ((codepoint >> 6) & 0x3F);
            *buffer++ = 0x80 | (codepoint & 0x3F);
        }
        else {
            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
            *buffer++ = 0xF0 | ((codepoint >> 18) & 0xFF);
            *buffer++ = 0x80 | ((codepoint >> 12) & 0x3F);
            *buffer++ = 0x80 | ((codepoint >> 6) & 0x3F);
            *buffer++ = 0x80 | (codepoint & 0x3F);
        }
        return buffer;
    }
};
 
// UTF16
 
 
template<typename CharType = wchar_t>
struct UTF16 {
    typedef CharType Ch;
 
    static Ch* Encode(Ch* buffer, unsigned codepoint) {
        if (codepoint <= 0xFFFF) {
            RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
            *buffer++ = static_cast<Ch>(codepoint);
        }
        else {
            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
            unsigned v = codepoint - 0x10000;
            *buffer++ = static_cast<Ch>((v >> 10) + 0xD800);
            *buffer++ = (v & 0x3FF) + 0xDC00;
        }
        return buffer;
    }
};
 
// UTF32
 
 
template<typename CharType = unsigned>
struct UTF32 {
    typedef CharType Ch;
 
    static Ch *Encode(Ch* buffer, unsigned codepoint) {
        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
        *buffer++ = codepoint;
        return buffer;
    }
};
 
//  Stream
 
 
 
 
 
 
 
template<typename Stream, typename Ch>
inline void PutN(Stream& stream, Ch c, size_t n) {
    for (size_t i = 0; i < n; i++)
        stream.Put(c);
}
 
// StringStream
 
 
template <typename Encoding>
struct GenericStringStream {
    typedef typename Encoding::Ch Ch;
 
    GenericStringStream(const Ch *src) : src_(src), head_(src) {}
 
    Ch Peek() const { return *src_; }
    Ch Take() { return *src_++; }
    size_t Tell() const { return src_ - head_; }
 
    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
    void Put(Ch) { RAPIDJSON_ASSERT(false); }
    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
 
    const Ch* src_;     
    const Ch* head_;    
};
 
typedef GenericStringStream<UTF8<> > StringStream;
 
// InsituStringStream
 
 
template <typename Encoding>
struct GenericInsituStringStream {
    typedef typename Encoding::Ch Ch;
 
    GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
 
    // Read
    Ch Peek() { return *src_; }
    Ch Take() { return *src_++; }
    size_t Tell() { return src_ - head_; }
 
    // Write
    Ch* PutBegin() { return dst_ = src_; }
    void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
    size_t PutEnd(Ch* begin) { return dst_ - begin; }
 
    Ch* src_;
    Ch* dst_;
    Ch* head_;
};
 
typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
 
// Type
 
enum Type {
    kNull_Type = 0,     
    kFalseType = 1,     
    kTrueType = 2,      
    kObjectType = 3,    
    kArrayType = 4,     
    kStringType = 5,    
    kNumberType = 6,    
};
 
} // namespace rapidjson
 
#endif // RAPIDJSON_RAPIDJSON_H_