rapidjson.h

Go to the documentation of this file.

#ifndef RAPIDJSON_RAPIDJSON_H_
#define RAPIDJSON_RAPIDJSON_H_

// Copyright (c) 2011-2012 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 {
        kNullType = 0,          
        kFalseType = 1,         
        kTrueType = 2,          
        kObjectType = 3,        
        kArrayType = 4,         
        kStringType = 5,        
        kNumberType = 6,        
};

} // namespace rapidjson

#endif // RAPIDJSON_RAPIDJSON_H_