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_