proto/Source/strings.h

Go to the documentation of this file.

#ifndef _STRINGS_H
#define _STRINGS_H

#include <limits>
#include <set>
#include <vector>

//
#include "exceptions.h"
// Memory pool needed.
#include "pool.h"

namespace ace {

// Forward declaration needed.
template<class _IndType>
class StringStoreLessComparator;

// Forward declaration needed.
template<class _IndType>
class StringStoreEqualComparator;

template<class _IndType>
class StringStore {
public:
    typedef std::vector<const char *> table_t;

private:
    typedef typename std::set<_IndType, StringStoreLessComparator<_IndType> > _index_t;
    
    RandomSizedMemoryPool<char> _memory_pool;

    table_t _strings_table;

    _index_t _strings_index;

    StringStoreEqualComparator<_IndType> _str_equal_comp;

public:
    StringStore(size_t max_string_length);
    void clear(void);
    inline bool is_full(void) const { return _strings_table.size() == std::numeric_limits<_IndType>::max(); }
    inline const char * get(_IndType index) const { return _strings_table[index]; }
    _IndType store(const char *str);
    inline size_t size(void) const { return _strings_table.size(); }
};


template <class _IndType>
class StringStoreLessComparator: public std::binary_function<_IndType, _IndType, bool> {
    const typename StringStore<_IndType>::table_t& _table;
public:
    StringStoreLessComparator(const typename StringStore<_IndType>::table_t& table): _table(table) {}
    inline bool operator()(_IndType lhs, _IndType rhs) const {
        return strcmp(_table[lhs], _table[rhs]) == -1;
    }
};

template <class _IndType>
class StringStoreEqualComparator: public std::binary_function<_IndType, _IndType, bool> {
    const typename StringStore<_IndType>::table_t& _table;
public:
    StringStoreEqualComparator(const typename StringStore<_IndType>::table_t& table): _table(table) {}
    inline bool operator()(_IndType lhs, _IndType rhs) const {
        // We can't compare just the indices, because newly stored string must be first
        // inserted into store, then compared (and eventually popped out, if founded).
        return strcmp(_table[lhs], _table[rhs]) == 0;
    }
};



/*  Interface item definition.
 */
template <class _IndType>
StringStore<_IndType>::StringStore(size_t max_string_length): _memory_pool(max_string_length + 1), _strings_table(), _strings_index(StringStoreLessComparator<_IndType>(_strings_table)), _str_equal_comp(_strings_table) {}

/*  Interface item definition.
 */
template <class _IndType>
void StringStore<_IndType>::clear(void) {
    _strings_index.clear();
    _strings_table.clear();
    _memory_pool.clear();
}

/*  Interface item definition.
 */
template <class _IndType>
_IndType StringStore<_IndType>::store(const char *str) {            

    // String must be stored to be comparable.
    _IndType index = static_cast<_IndType>(_strings_table.size());
    _strings_table.push_back(str);

    // Search for given string in string index.
    typename _index_t::iterator i_str = _strings_index.lower_bound(index);
    if ( i_str != _strings_index.end() ) {
        // Compare strings for equality.
        if ( _str_equal_comp(static_cast<_IndType>(*i_str), index) ) {
            // Already exists. Pop string back.
            _strings_table.pop_back();
            return static_cast<_IndType>(*i_str);
        }
    }

    if ( this->is_full() ) {
        // No index left to spend...
        throw index_overflow("String store overflow!");
    }

    // New object - new memory needed...
    size_t memory_needed = strlen(str) + 1;
    char* mem = _memory_pool.get_memory(memory_needed); // This may throw!

    // Copy passed string into brand new memory.
    memcpy(mem, str, memory_needed);
    // Store pointer between strings (overwrite temporary stored param).
    _strings_table[index] = mem;
    // Insert and return dereferenced iterator.
    return static_cast<_IndType>(*_strings_index.insert(i_str, index));
}

} // namespace ace

#endif

---