rapidjson::internal::Stack< Allocator > Class Template Reference

A type-unsafe stack for storing different types of data. More...

#include <stack.h>

Public Member Functions
	Stack (Allocator *allocator, size_t stackCapacity)
	~Stack ()
void	Clear ()
void	ShrinkToFit ()
template<typename T >
RAPIDJSON_FORCEINLINE T *	Push (size_t count=1)
template<typename T >
T *	Pop (size_t count)
template<typename T >
T *	Top ()
template<typename T >
T *	Bottom ()
Allocator &	GetAllocator ()
bool	Empty () const
size_t	GetSize () const
size_t	GetCapacity () const

Private Member Functions
template<typename T >
void	Expand (size_t count)
void	Resize (size_t newCapacity)
void	Destroy ()
	Stack (const Stack &)
Stack &	operator= (const Stack &)

Private Attributes
Allocator *	allocator_
Allocator *	ownAllocator_
char *	stack_
char *	stackTop_
char *	stackEnd_
size_t	initialCapacity_

Detailed Description

template<typename Allocator>
class rapidjson::internal::Stack< Allocator >

A type-unsafe stack for storing different types of data.

Template Parameters

Allocator

Allocator for allocating stack memory.

Definition at line 34 of file stack.h.

Constructor & Destructor Documentation

template<typename Allocator>

rapidjson::internal::Stack< Allocator >::Stack ( Allocator *  allocator, size_t  stackCapacity  )

inline

Definition at line 38 of file stack.h.

                                                      : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
        RAPIDJSON_ASSERT(stackCapacity > 0);
    }

template<typename Allocator>

rapidjson::internal::Stack< Allocator >::~Stack ( )

inline

Definition at line 60 of file stack.h.

             {
        Destroy();
    }

template<typename Allocator>

rapidjson::internal::Stack< Allocator >::Stack ( const Stack< Allocator > &  )

private

Member Function Documentation

template<typename Allocator>

template<typename T >

T* rapidjson::internal::Stack< Allocator >::Bottom ( )

inline

Definition at line 129 of file stack.h.

{ return (T*)stack_; }

template<typename Allocator>

void rapidjson::internal::Stack< Allocator >::Clear ( )

inline

Definition at line 88 of file stack.h.

{ stackTop_ = stack_; }

template<typename Allocator>

void rapidjson::internal::Stack< Allocator >::Destroy ( )

inlineprivate

Definition at line 163 of file stack.h.

                   {
        Allocator::Free(stack_);
        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
    }

template<typename Allocator>

bool rapidjson::internal::Stack< Allocator >::Empty ( ) const

inline

Definition at line 132 of file stack.h.

{ return stackTop_ == stack_; }

template<typename Allocator>

template<typename T >

void rapidjson::internal::Stack< Allocator >::Expand ( size_t  count )

inlineprivate

Definition at line 138 of file stack.h.

                              {
        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
        size_t newCapacity;
        if (stack_ == 0) {
            if (!allocator_)
                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
            newCapacity = initialCapacity_;
        } else {
            newCapacity = GetCapacity();
            newCapacity += (newCapacity + 1) / 2;
        }
        size_t newSize = GetSize() + sizeof(T) * count;
        if (newCapacity < newSize)
            newCapacity = newSize;

        Resize(newCapacity);
    }

template<typename Allocator>

Allocator& rapidjson::internal::Stack< Allocator >::GetAllocator ( )

inline

Definition at line 131 of file stack.h.

{ return *allocator_; }

template<typename Allocator>

size_t rapidjson::internal::Stack< Allocator >::GetCapacity ( ) const

inline

Definition at line 134 of file stack.h.

{ return static_cast<size_t>(stackEnd_ - stack_); }

template<typename Allocator>

size_t rapidjson::internal::Stack< Allocator >::GetSize ( ) const

inline

Definition at line 133 of file stack.h.

{ return static_cast<size_t>(stackTop_ - stack_); }

template<typename Allocator>

Stack& rapidjson::internal::Stack< Allocator >::operator= ( const Stack< Allocator > &  )

private

template<typename Allocator>

template<typename T >

T* rapidjson::internal::Stack< Allocator >::Pop ( size_t  count )

inline

Definition at line 116 of file stack.h.

                         {
        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
        stackTop_ -= count * sizeof(T);
        return reinterpret_cast<T*>(stackTop_);
    }

template<typename Allocator>

template<typename T >

RAPIDJSON_FORCEINLINE T* rapidjson::internal::Stack< Allocator >::Push ( size_t  count = 1 )

inline

Definition at line 105 of file stack.h.

                                                    {
         // Expand the stack if needed
        if (stackTop_ + sizeof(T) * count >= stackEnd_)
            Expand<T>(count);

        T* ret = reinterpret_cast<T*>(stackTop_);
        stackTop_ += sizeof(T) * count;
        return ret;
    }

template<typename Allocator>

void rapidjson::internal::Stack< Allocator >::Resize ( size_t  newCapacity )

inlineprivate

Definition at line 156 of file stack.h.

                                    {
        const size_t size = GetSize();  // Backup the current size
        stack_ = (char*)allocator_->Realloc(stack_, GetCapacity(), newCapacity);
        stackTop_ = stack_ + size;
        stackEnd_ = stack_ + newCapacity;
    }

template<typename Allocator>

void rapidjson::internal::Stack< Allocator >::ShrinkToFit ( )

inline

Definition at line 90 of file stack.h.

                       { 
        if (Empty()) {
            // If the stack is empty, completely deallocate the memory.
            Allocator::Free(stack_);
            stack_ = 0;
            stackTop_ = 0;
            stackEnd_ = 0;
        }
        else
            Resize(GetSize());
    }

template<typename Allocator>

template<typename T >

T* rapidjson::internal::Stack< Allocator >::Top ( )

inline

Definition at line 123 of file stack.h.

             { 
        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
    }

Member Data Documentation

template<typename Allocator>

Allocator* rapidjson::internal::Stack< Allocator >::allocator_

private

Definition at line 172 of file stack.h.

template<typename Allocator>

size_t rapidjson::internal::Stack< Allocator >::initialCapacity_

private

Definition at line 177 of file stack.h.

template<typename Allocator>

Allocator* rapidjson::internal::Stack< Allocator >::ownAllocator_

private

Definition at line 173 of file stack.h.

template<typename Allocator>

char* rapidjson::internal::Stack< Allocator >::stack_

private

Definition at line 174 of file stack.h.

template<typename Allocator>

char* rapidjson::internal::Stack< Allocator >::stackEnd_

private

Definition at line 176 of file stack.h.

template<typename Allocator>

char* rapidjson::internal::Stack< Allocator >::stackTop_

private

Definition at line 175 of file stack.h.

---

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

• art/rapidjson/internal/stack.h