pooledstring.h

Go to the documentation of this file.

#if !defined(INCLUDED_POOLEDSTRING_H)
#define INCLUDED_POOLEDSTRING_H

#include <map>
#include "generic/static.h"
#include "string/string.h"
#include "container/hashtable.h"
#include "container/hashfunc.h"

class StringPool : public HashTable<char*, std::size_t, RawStringHash, RawStringEqual> {
};

inline void StringPool_analyse(StringPool& pool) {
    typedef std::multimap<std::size_t, const char*> Ordered;
    Ordered ordered;
    std::size_t total = 0;
    std::size_t pooled = 0;
    for (StringPool::iterator i = pool.begin(); i != pool.end(); ++i) {
        std::size_t size =  string_length((*i).key) + 1;
        total += size * (*i).value;
        pooled += size + 20;
        ordered.insert(Ordered::value_type((*i).value, (*i).key));
    }
    globalOutputStream() << "total: " << Unsigned(total) << " pooled:" << Unsigned(pooled) << "\n";
    for (Ordered::iterator i = ordered.begin(); i != ordered.end(); ++i) {
        globalOutputStream() << (*i).second << " " << Unsigned((*i).first) << "\n";
    }
}


template<typename PoolContext>
class PooledString {
    StringPool::iterator m_i;
    static StringPool::iterator increment(StringPool::iterator i) {
        ++(*i).value;
        return i;
    }
    static StringPool::iterator insert(const char* string) {
        StringPool::iterator i = PoolContext::instance().find(const_cast<char*>(string));
        if (i == PoolContext::instance().end()) {
            return PoolContext::instance().insert(string_clone(string), 1);
        }
        return increment(i);
    }
    static void erase(StringPool::iterator i) {
        if (--(*i).value == 0) {
            char* string = (*i).key;
            PoolContext::instance().erase(i);
            string_release(string, string_length(string));
        }
    }
public:
    PooledString() : m_i(insert("")) {
    }
    PooledString(const PooledString& other) : m_i(increment(other.m_i)) {
    }
    PooledString(const char* string) : m_i(insert(string)) {
    }
    ~PooledString() {
        erase(m_i);
    }
    PooledString& operator=(const PooledString& other) {
        PooledString tmp(other);
        tmp.swap(*this);
        return *this;
    }
    PooledString& operator=(const char* string) {
        PooledString tmp(string);
        tmp.swap(*this);
        return *this;
    }
    void swap(PooledString& other) {
        std::swap(m_i, other.m_i);
    }
    bool operator==(const PooledString& other) const {
        return m_i == other.m_i;
    }
    const char* c_str() const {
        return (*m_i).key;
    }
};


#endif