cached_string.cpp

Go to the documentation of this file.

#include <boost/unordered_set.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/shared_mutex.hpp>
#include <boost/thread/locks.hpp>

#include "utils/cached_string.hpp"

bool CachedString::StringStorageElement::operator == (const StringStorageElement& other) const
{
    return (hash == other.hash) || (value == other.value);
}

struct CachedString::StringStorageElement::Hasher
    : public std::unary_function<StringStorageElement, std::size_t>
{
    std::size_t operator()(const StringStorageElement& sse) const
    {
        return sse.hash;
    }
};

struct CachedString::StringStorageElement::StringComparator
    : public std::binary_function<string, StringStorageElement, bool>
{
    bool operator()(const string& str, const StringStorageElement& sse) const
    {
        return sse.value == str;
    }
};

CachedString::StringStorageElement::StringStorageElement( const string& str )
    : value(str)
    , hash(boost::hash<string>()(str))
{
}

CachedString::StringStorageElement::StringStorageElement(const StringStorageElement& other)
    : value(other.value)
    , hash(other.hash)
{
}

class CachedString::StringStorage
    : public boost::noncopyable
{
public:
    static StringStorage& Inst()
    {
        static StringStorage inst;
        return inst;
    }

    void shutdown()
    {
        emptyString = nullptr;
        storage.clear();
    }

    const StringStorageElement* getEmptyString() const
    {
        return emptyString;
    }
    
    const StringStorageElement* resolveString(const string& str)
    {
        boost::upgrade_lock<boost::shared_mutex> guard(accessMutex);
        // Search for the string using a direct string search
        auto it = storage.find(str, stringStorageElementHasher, stringComperator);

        // check if string was already in storage
        if(it == storage.end())
        {
            boost::upgrade_to_unique_lock<boost::shared_mutex> unique(guard);
            it = storage.insert(StringStorageElement(str)).first;
        }

        return &(*it);
    }
private:
    StringStorage()
    {
        emptyString = resolveString("");
    }

private:
    StringStorageElement::Hasher stringStorageElementHasher;
    StringStorageElement::StringComparator stringComperator;

    const StringStorageElement* emptyString;
    boost::unordered_set<StringStorageElement, StringStorageElement::Hasher> storage;
    boost::shared_mutex accessMutex;
};



CachedString::CachedString()
{
    clear();
}

CachedString::CachedString(const char* str)
{
    internalString = StringStorage::Inst().resolveString(str);
}

CachedString::CachedString( const string& str )
{
    assign(str);
}

CachedString::CachedString( const CachedString& other )
{
    assign(other);
}


CachedString::~CachedString()
{
}

bool CachedString::equals( const string& other ) const
{
    return str() == other;
}

bool CachedString::equals( const CachedString& other ) const
{
    return this->internalString == other.internalString;
}

/*
CachedString& CachedString::operator =(const char* str)
{
    return *this = CachedString(str);
}*/

CachedString& CachedString::operator =(const string& str)
{
    assign(str);
    return *this;
}

CachedString& CachedString::operator=( const CachedString& other )
{
    assign(other);
    return *this;
}


void CachedString::assign( const string& str )
{
    internalString = StringStorage::Inst().resolveString(str);
}

void CachedString::assign( const CachedString& other )
{
    this->internalString = other.internalString;
}


void CachedString::clear()
{
    internalString = StringStorage::Inst().getEmptyString();
}


const char* CachedString::c_str() const
{
    assert(internalString);
    return internalString->value.c_str();
}

const string& CachedString::str() const
{
    assert(internalString);
    return internalString->value;
}

std::size_t CachedString::hash() const
{
    assert(internalString);
    return internalString->hash;
}

void CachedString::Shutdown()
{
    CachedString::StringStorage::Inst().shutdown();
}


MaybeCachedString::MaybeCachedString()
    : cached(true)
{
    clear();
}

/*
MaybeCachedString::MaybeCachedString( const char* str )
{

}*/

MaybeCachedString::MaybeCachedString( const string& str )
    : cached(true)
{
    assign(str);
}

MaybeCachedString::MaybeCachedString( const CachedString& other )
    : cached(true)
{
    assign(other);
}

MaybeCachedString::MaybeCachedString( const MaybeCachedString& other )
    : cached(true)
{
    assign(other);
}

MaybeCachedString::~MaybeCachedString()
{
    reset();
}

/*
MaybeCachedString& MaybeCachedString::operator=( const char* str )
{

}*/

MaybeCachedString& MaybeCachedString::operator=( const string& str )
{
    assign(str);
    return *this;
}

MaybeCachedString& MaybeCachedString::operator =(const CachedString& other)
{
    assign(other);
    return *this;
}

MaybeCachedString& MaybeCachedString::operator=( const MaybeCachedString& other )
{
    assign(other);
    return *this;
}


void MaybeCachedString::assign( const string& str )
{
    reset();
    cached = false;
    internalString = new StringStorageElement(str);
}

void MaybeCachedString::assign( const MaybeCachedString& other )
{
    reset();
    cached = other.cached;
    if (cached) {
        internalString = other.internalString;
    } else {
        internalString = new StringStorageElement(*other.internalString);
    }
}

void MaybeCachedString::assign( const CachedString& other )
{
    cached = true;
    internalString = other.internalString;
}

bool MaybeCachedString::equals( const string& other ) const
{
    return str() == other;
}

bool MaybeCachedString::equals( const CachedString& other ) const
{
    if(cached)
    {
        return internalString == other.internalString;
    } else {
        return equals(other.str());
    }
}

bool MaybeCachedString::equals( const MaybeCachedString& other ) const
{
    if(cached && other.cached)
    {
        return internalString == other.internalString;
    } else {
        return equals(other.str());
    }
}

const char* MaybeCachedString::c_str() const
{
    assert(internalString);
    return internalString->value.c_str();
}

const string& MaybeCachedString::str() const
{
    assert(internalString);
    return internalString->value;
}

std::size_t MaybeCachedString::hash() const
{
    assert(internalString);
    return internalString->hash;
}

void MaybeCachedString::clear()
{
    reset();
    cached = true;
    internalString = StringStorage::Inst().getEmptyString();
}

void MaybeCachedString::reset()
{
    if(!cached)
        delete internalString;
}

bool MaybeCachedString::isCached() const
{
    return cached;
}