rapidjson.h

Go to the documentation of this file.

#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_