rapidjson::MemoryPoolAllocator< BaseAllocator > Class Template Reference

Default memory allocator used by the parser and DOM. More...

#include <rapidjson.h>

Inheritance diagram for rapidjson::MemoryPoolAllocator< BaseAllocator >:

Classes
struct	ChunkHeader
	Chunk header for perpending to each chunk. More...

Public Member Functions
	MemoryPoolAllocator (size_t chunkSize=kDefaultChunkCapacity, BaseAllocator *baseAllocator=0)
	Constructor with chunkSize. More...
	MemoryPoolAllocator (char *buffer, size_t size, size_t chunkSize=kDefaultChunkCapacity, BaseAllocator *baseAllocator=0)
	Constructor with user-supplied buffer. More...
	~MemoryPoolAllocator ()
	Destructor. More...
void	Clear ()
	Deallocates all memory chunks, excluding the user-supplied buffer. More...
size_t	Capacity ()
	Computes the total capacity of allocated memory chunks. More...
size_t	Size ()
	Computes the memory blocks allocated. More...
void *	Malloc (size_t size)
	Allocates a memory block. (concept Allocator) More...
void *	Realloc (void *originalPtr, size_t originalSize, size_t newSize)
	Resizes a memory block (concept Allocator) More...

Static Public Member Functions
static void	Free (void *)
	Frees a memory block (concept Allocator) More...

Static Public Attributes
static const bool	kNeedFree = false
	Tell users that no need to call Free() with this allocator. (concept Allocator) More...

Private Member Functions
void	AddChunk (size_t capacity)
	Creates a new chunk. More...

Private Attributes
ChunkHeader *	chunkHead_
	Head of the chunk linked-list. Only the head chunk serves allocation. More...
size_t	chunk_capacity_
	The minimum capacity of chunk when they are allocated. More...
char *	userBuffer_
	User supplied buffer. More...
BaseAllocator *	baseAllocator_
	base allocator for allocating memory chunks. More...
BaseAllocator *	ownBaseAllocator_
	base allocator created by this object. More...

Static Private Attributes
static const int	kDefaultChunkCapacity = 64 * 1024
	Default chunk capacity. More...

Detailed Description

template<typename BaseAllocator = CrtAllocator>
class rapidjson::MemoryPoolAllocator< BaseAllocator >

Default memory allocator used by the parser and DOM.

This allocator allocate memory blocks from pre-allocated memory chunks.

It does not free memory blocks. And Realloc() only allocate new memory.

The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.

User may also supply a buffer as the first chunk.

If the user-buffer is full then additional chunks are allocated by BaseAllocator.

The user-buffer is not deallocated by this allocator.

Template Parameters

BaseAllocator

the allocator type for allocating memory chunks. Default is CrtAllocator.

Constructor & Destructor Documentation

MemoryPoolAllocator() [1/2]

template<typename BaseAllocator = CrtAllocator>

rapidjson::MemoryPoolAllocator< BaseAllocator >::MemoryPoolAllocator ( size_t  chunkSize = kDefaultChunkCapacity, BaseAllocator *  baseAllocator = 0  )

inline

Constructor with chunkSize.

Parameters

chunkSize	The size of memory chunk. The default is kDefaultChunkSize.
baseAllocator	The allocator for allocating memory chunks.

                                                                                                    : 
        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
    {
        if (!baseAllocator_)
            ownBaseAllocator_ = baseAllocator_ = new BaseAllocator();
        AddChunk(chunk_capacity_);
    }

References rapidjson::MemoryPoolAllocator< BaseAllocator >::AddChunk(), rapidjson::MemoryPoolAllocator< BaseAllocator >::baseAllocator_, rapidjson::MemoryPoolAllocator< BaseAllocator >::chunk_capacity_, and rapidjson::MemoryPoolAllocator< BaseAllocator >::ownBaseAllocator_.

MemoryPoolAllocator() [2/2]

template<typename BaseAllocator = CrtAllocator>

rapidjson::MemoryPoolAllocator< BaseAllocator >::MemoryPoolAllocator ( char *  buffer, size_t  size, size_t  chunkSize = kDefaultChunkCapacity, BaseAllocator *  baseAllocator = 0  )

inline

Constructor with user-supplied buffer.

The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.

The user buffer will not be deallocated when this allocator is destructed.

Parameters

buffer	User supplied buffer.
size	Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
chunkSize	The size of memory chunk. The default is kDefaultChunkSize.
baseAllocator	The allocator for allocating memory chunks.

                                                                                                                               :
        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;
    }

References rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::capacity, rapidjson::MemoryPoolAllocator< BaseAllocator >::chunkHead_, rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::next, RAPIDJSON_ASSERT, and rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::size.

~MemoryPoolAllocator()

template<typename BaseAllocator = CrtAllocator>

rapidjson::MemoryPoolAllocator< BaseAllocator >::~MemoryPoolAllocator ( )

inline

Destructor.

This deallocates all memory chunks, excluding the user-supplied buffer.

                           {
        Clear();
        delete ownBaseAllocator_;
    }

References rapidjson::MemoryPoolAllocator< BaseAllocator >::Clear(), and rapidjson::MemoryPoolAllocator< BaseAllocator >::ownBaseAllocator_.

Member Function Documentation

AddChunk()

template<typename BaseAllocator = CrtAllocator>

void rapidjson::MemoryPoolAllocator< BaseAllocator >::AddChunk ( size_t  capacity )

inlineprivate

Creates a new chunk.

Parameters

capacity

Capacity of the chunk in bytes.

                                   {
        ChunkHeader* chunk = (ChunkHeader*)baseAllocator_->Malloc(sizeof(ChunkHeader) + capacity);
        chunk->capacity = capacity;
        chunk->size = 0;
        chunk->next = chunkHead_;
        chunkHead_ =  chunk;
    }

References rapidjson::MemoryPoolAllocator< BaseAllocator >::baseAllocator_, rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::capacity, rapidjson::MemoryPoolAllocator< BaseAllocator >::chunkHead_, rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::next, and rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::size.

Referenced by rapidjson::MemoryPoolAllocator< BaseAllocator >::Malloc(), and rapidjson::MemoryPoolAllocator< BaseAllocator >::MemoryPoolAllocator().

Capacity()

template<typename BaseAllocator = CrtAllocator>

size_t rapidjson::MemoryPoolAllocator< BaseAllocator >::Capacity ( )

inline

Computes the total capacity of allocated memory chunks.

Returns

total capacity in bytes.

                      {
        size_t capacity = 0;
        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
            capacity += c->capacity;
        return capacity;
    }

References rapidjson::MemoryPoolAllocator< BaseAllocator >::chunkHead_, and rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::next.

Clear()

template<typename BaseAllocator = CrtAllocator>

void rapidjson::MemoryPoolAllocator< BaseAllocator >::Clear ( )

inline

Deallocates all memory chunks, excluding the user-supplied buffer.

                 {
        while(chunkHead_ != 0 && chunkHead_ != (ChunkHeader *)userBuffer_) {
            ChunkHeader* next = chunkHead_->next;
            baseAllocator_->Free(chunkHead_);
            chunkHead_ = next;
        }
    }

References rapidjson::MemoryPoolAllocator< BaseAllocator >::baseAllocator_, rapidjson::MemoryPoolAllocator< BaseAllocator >::chunkHead_, rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::next, and rapidjson::MemoryPoolAllocator< BaseAllocator >::userBuffer_.

Referenced by rapidjson::MemoryPoolAllocator< BaseAllocator >::~MemoryPoolAllocator().

Free()

template<typename BaseAllocator = CrtAllocator>

static void rapidjson::MemoryPoolAllocator< BaseAllocator >::Free ( void *  )

inlinestatic

Frees a memory block (concept Allocator)

{} // Do nothing

Malloc()

template<typename BaseAllocator = CrtAllocator>

void* rapidjson::MemoryPoolAllocator< BaseAllocator >::Malloc ( size_t  size )

inline

Allocates a memory block. (concept Allocator)

                              {
        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;
    }

References rapidjson::MemoryPoolAllocator< BaseAllocator >::AddChunk(), rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::capacity, rapidjson::MemoryPoolAllocator< BaseAllocator >::chunk_capacity_, rapidjson::MemoryPoolAllocator< BaseAllocator >::chunkHead_, RAPIDJSON_ASSERT, and rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::size.

Referenced by rapidjson::MemoryPoolAllocator< BaseAllocator >::Realloc().

Realloc()

template<typename BaseAllocator = CrtAllocator>

void* rapidjson::MemoryPoolAllocator< BaseAllocator >::Realloc ( void *  originalPtr, size_t  originalSize, size_t  newSize  )

inline

Resizes a memory block (concept Allocator)

                                                                          {
        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);
    }

References rapidjson::MemoryPoolAllocator< BaseAllocator >::chunkHead_, rapidjson::MemoryPoolAllocator< BaseAllocator >::Malloc(), RAPIDJSON_ASSERT, and rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::size.

Size()

template<typename BaseAllocator = CrtAllocator>

size_t rapidjson::MemoryPoolAllocator< BaseAllocator >::Size ( )

inline

Computes the memory blocks allocated.

Returns

total used bytes.

                  {
        size_t size = 0;
        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
            size += c->size;
        return size;
    }

References rapidjson::MemoryPoolAllocator< BaseAllocator >::chunkHead_, and rapidjson::MemoryPoolAllocator< BaseAllocator >::ChunkHeader::next.

Member Data Documentation

baseAllocator_

template<typename BaseAllocator = CrtAllocator>

BaseAllocator* rapidjson::MemoryPoolAllocator< BaseAllocator >::baseAllocator_

private

base allocator for allocating memory chunks.

Referenced by rapidjson::MemoryPoolAllocator< BaseAllocator >::AddChunk(), rapidjson::MemoryPoolAllocator< BaseAllocator >::Clear(), and rapidjson::MemoryPoolAllocator< BaseAllocator >::MemoryPoolAllocator().

chunk_capacity_

template<typename BaseAllocator = CrtAllocator>

size_t rapidjson::MemoryPoolAllocator< BaseAllocator >::chunk_capacity_

private

The minimum capacity of chunk when they are allocated.

Referenced by rapidjson::MemoryPoolAllocator< BaseAllocator >::Malloc(), and rapidjson::MemoryPoolAllocator< BaseAllocator >::MemoryPoolAllocator().

chunkHead_

template<typename BaseAllocator = CrtAllocator>

ChunkHeader* rapidjson::MemoryPoolAllocator< BaseAllocator >::chunkHead_

private

Head of the chunk linked-list. Only the head chunk serves allocation.

Referenced by rapidjson::MemoryPoolAllocator< BaseAllocator >::AddChunk(), rapidjson::MemoryPoolAllocator< BaseAllocator >::Capacity(), rapidjson::MemoryPoolAllocator< BaseAllocator >::Clear(), rapidjson::MemoryPoolAllocator< BaseAllocator >::Malloc(), rapidjson::MemoryPoolAllocator< BaseAllocator >::MemoryPoolAllocator(), rapidjson::MemoryPoolAllocator< BaseAllocator >::Realloc(), and rapidjson::MemoryPoolAllocator< BaseAllocator >::Size().

kDefaultChunkCapacity

template<typename BaseAllocator = CrtAllocator>

const int rapidjson::MemoryPoolAllocator< BaseAllocator >::kDefaultChunkCapacity = 64 * 1024

staticprivate

Default chunk capacity.

kNeedFree

template<typename BaseAllocator = CrtAllocator>

const bool rapidjson::MemoryPoolAllocator< BaseAllocator >::kNeedFree = false

static

Tell users that no need to call Free() with this allocator. (concept Allocator)

ownBaseAllocator_

template<typename BaseAllocator = CrtAllocator>

BaseAllocator* rapidjson::MemoryPoolAllocator< BaseAllocator >::ownBaseAllocator_

private

base allocator created by this object.

Referenced by rapidjson::MemoryPoolAllocator< BaseAllocator >::MemoryPoolAllocator(), and rapidjson::MemoryPoolAllocator< BaseAllocator >::~MemoryPoolAllocator().

userBuffer_

template<typename BaseAllocator = CrtAllocator>

char* rapidjson::MemoryPoolAllocator< BaseAllocator >::userBuffer_

private

User supplied buffer.

Referenced by rapidjson::MemoryPoolAllocator< BaseAllocator >::Clear().

---

The documentation for this class was generated from the following file:

• rapidjson.h