/xmlbench/trunk

/*  stringpool.h - Coterminal String Pools.

    Copyright (c) 2008, Robert D. Cameron.

    Licensed to the public under the Open Software License 3.0.

    Licensed to International Characters, Inc., under the Academic

    Free License 3.0.

 

    A storage pool for strings all of which remain allocated

    until the pool is destroyed.

*/

#ifndef STRINGPOOL_H

#define STRINGPOOL_H

 

template <int BasePoolSize, int ExpansionPercent>

class StringPool {

public:

        StringPool();

        ~StringPool();

        char * Insert(const char * full_string, int lgth);

        /* The following methods provide for incremental construction of strings

           each constructed by a sequence of calls of the form:

           OpenString(); AppendSegment(...)+; CloseString(). */

        void OpenString();

        void AppendSegment(char * segment, int segment_lgth);

        char * CloseString();  /* Return the pointer to the constructed string. */

private:

        /* The initial buffer is allocated as part of the StringPool object.

           For stack allocated StringPools that do not exceed the initial

           BasePoolSize, this completely eliminates the overhead and memory

           fragmentation associated with calls to new and delete. */

        struct buffer_node {

                buffer_node * more_buffers;

                size_t buffer_size;

                char buffer[BasePoolSize];

        };

        buffer_node node1;

        buffer_node * current_node;

        size_t total_size;

        char * insertion_ptr;

        size_t space_avail;

        char * opened_string_ptr;

 

        void ExtendPool();  /* Adds a new buffer to the pool. */

};

 

template <int BasePoolSize, int ExpansionPercent>

StringPool<BasePoolSize, ExpansionPercent>::StringPool() {

        node1.more_buffers = NULL;

        node1.buffer_size = BasePoolSize;

        total_size = node1.buffer_size;

        insertion_ptr = (char *) &(node1.buffer);

        space_avail = node1.buffer_size;

        opened_string_ptr = NULL; /* not open */

        current_node = &node1;

}

 

template <int BasePoolSize, int ExpansionPercent>

StringPool<BasePoolSize, ExpansionPercent>::~StringPool() {

        while (current_node != &node1) {

                buffer_node * allocated_node = current_node;

                current_node = allocated_node->more_buffers;

                free(allocated_node);

        }

}

 

template <int BasePoolSize, int ExpansionPercent>

void StringPool<BasePoolSize, ExpansionPercent>::ExtendPool() {

        size_t new_buffer_size = (size_t) ((total_size * ExpansionPercent)/100);

        buffer_node * new_node = (buffer_node *) malloc(sizeof(buffer_node) + new_buffer_size - BasePoolSize);

        if (new_node == NULL) {

                fprintf(stderr, "Allocation failure in StringPool<BasePoolSize, ExpansionPercent>::ExtendPool\n");

                exit(-1);

        }

        new_node->more_buffers = current_node;

        new_node->buffer_size = new_buffer_size;

        total_size += new_buffer_size;

        current_node = new_node;

        if (opened_string_ptr != NULL) {

                size_t open_string_prefix_size = (size_t) insertion_ptr - (size_t) opened_string_ptr;

                memcpy(new_node->buffer, opened_string_ptr, open_string_prefix_size);

                insertion_ptr = &(new_node->buffer[open_string_prefix_size]);

                opened_string_ptr = new_node->buffer;

                space_avail = new_buffer_size - open_string_prefix_size;

        }

        else {

                insertion_ptr = new_node->buffer;

                space_avail = new_buffer_size;

        }

#ifdef DEBUG

        printf("ExtendPool() called: space_avail = %i\n", space_avail);

#endif

}

 

template <int BasePoolSize, int ExpansionPercent>

char * StringPool<BasePoolSize, ExpansionPercent>::Insert(const char * s, int lgth) {

        int total_lgth = lgth + 1;

        while (total_lgth > space_avail) ExtendPool();

        memcpy(insertion_ptr, s, lgth);

        char * this_string_ptr = insertion_ptr;

        insertion_ptr[lgth] = '\0';

        insertion_ptr += total_lgth;

        space_avail -= total_lgth;

#ifdef DEBUG

        printf("Insert(%s, %i)\n", this_string_ptr, lgth);

#endif

        return this_string_ptr;

}

 

template <int BasePoolSize, int ExpansionPercent>

void StringPool<BasePoolSize, ExpansionPercent>::OpenString() {

        opened_string_ptr = insertion_ptr;

}

 

template <int BasePoolSize, int ExpansionPercent>

void StringPool<BasePoolSize, ExpansionPercent>::AppendSegment(char * segment, int segment_lgth) {

        /* Make sure that there is length for this segment plus null byte. */

        while (segment_lgth + 1 > space_avail) ExtendPool();

        memcpy(insertion_ptr, segment, segment_lgth);

        insertion_ptr += segment_lgth;

        space_avail -= segment_lgth;

}

 

template <int BasePoolSize, int ExpansionPercent>

char * StringPool<BasePoolSize, ExpansionPercent>::CloseString() {

        insertion_ptr[0] = '\0';

        insertion_ptr++;

        space_avail--;

        char * this_string_ptr = opened_string_ptr;

        opened_string_ptr = NULL;

        return this_string_ptr;

}

#endif