StackAllocator.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://github.com/matzke1/sawyer.
 
 
 
 
#ifndef SAWYER_STACK_ALLOCATOR
#define SAWYER_STACK_ALLOCATOR
 
#include <Sawyer/Sawyer.h>
 
namespace Sawyer {
 
template<typename T>
class StackAllocator {
public:
    typedef T Value;                                    
private:
    const size_t elmtsPerBlock_;                        // elements per large block of memory requested
    std::list<T*> blocks_;                              // front() is the most recent block from which an element is allocated
    size_t available_;                                  // number of elements available in most recent block
    std::list<T*> freeBlocks_;                          // blocks that aren't being used currently
 
public:
    explicit StackAllocator(size_t elmtsPerBlock)
        : elmtsPerBlock_(elmtsPerBlock), available_(0) {}
 
    ~StackAllocator() {
        prune();
        BOOST_FOREACH (T *ptr, blocks_)
            delete[] ptr;
        blocks_.clear();
        available_ = 0;
    }
 
    void prune() {
        BOOST_FOREACH (T *ptr, freeBlocks_)
            delete[] ptr;
        freeBlocks_.clear();
    }
 
    T* reserve(size_t nElmts) {
        if (nElmts > available_) {
            ASSERT_require(nElmts <= elmtsPerBlock_);
            allocateBlock();
        }
        return blocks_.front() + (elmtsPerBlock_ - available_);
    }
 
    T* allocNext() {
        if (0 == available_)
            allocateBlock();
        return blocks_.front() + (elmtsPerBlock_ - available_--);
    }
 
    void revert(T *ptr) {
        ASSERT_not_null(ptr);
        while (!blocks_.empty() && (ptr < blocks_.front() || ptr >= blocks_.front() + elmtsPerBlock_))
            freeBlock();
        ASSERT_always_forbid2(blocks_.empty(), "bad address or previously reverted");
        available_ = elmtsPerBlock_ - (ptr - blocks_.front());
    }
 
private:
    void allocateBlock() {
        if (freeBlocks_.empty()) {
            blocks_.insert(blocks_.begin(), new T[elmtsPerBlock_]);
        } else {
            blocks_.insert(blocks_.begin(), freeBlocks_.front());
            freeBlocks_.erase(freeBlocks_.begin());
        }
        available_ = elmtsPerBlock_;
    }
 
    void freeBlock() {
        ASSERT_forbid(blocks_.empty());
        freeBlocks_.insert(freeBlocks_.begin(), blocks_.front());
        blocks_.erase(blocks_.begin());
        available_ = 0;
    }
};
 
} // namespace
 
#endif