source: src/Common/Symbol.cpp@ 35cc6d4

#include "Symbol.hpp"

#include <unordered_map>

// This class (and the member-like helpers) are the implementation details
// of the Symbol class. It is just does reference counting to share strings.
// It is designed for maintainablity, but also to optimize the copy cases.
class SymbolData {
public:
        std::string const value;
        // As long as we are using a pointer sized counter,
        // overflow should never be an issue.
        std::size_t refCount;

        SymbolData(std::string const & value, std::size_t refCount) :
                value(value), refCount(refCount)
        {}
};

namespace {
        template<typename T>
        struct IndirectHash {
                std::hash<T> hasher;
                std::size_t operator()(T const * const & val) const {
                        return hasher(*val);
                }
        };

        template<typename T>
        struct IndirectEqualTo {
                std::equal_to<T> equals;
                bool operator()(T const * const & lhs, T const * const & rhs) const {
                        return equals(*lhs, *rhs);
                }
        };
} // namespace

using SymbolMap = std::unordered_map<std::string const *, SymbolData *,
        IndirectHash<std::string>, IndirectEqualTo<std::string>>;

/// Get the storage for the map of symbol data.
// Note: This is basically static memory, but wrapping the data in a function
// causes the constructor to run with the proper timing.
static SymbolMap & getAllSymbols() {
        static SymbolMap allSymbols;
        return allSymbols;
}

/// Clear out all unsed SymbolData.
static void eraseUnused() {
        SymbolMap & allSymbols = getAllSymbols();

        auto it = allSymbols.begin();
        while (it != allSymbols.end()) {
                if (it->second->refCount) {
                        ++it;
                } else {
                        delete it->second;
                        it = allSymbols.erase(it);
                }
        }
}

/// Convert a string to a new or existing SymbolData.
static SymbolData * getSymbolData(std::string const & str) {
        SymbolMap & allSymbols = getAllSymbols();

        // If there is an existing symbol, re-use it.
        auto it = allSymbols.find(&str);
        if (it != allSymbols.end()) {
                SymbolData * data = it->second;
                ++data->refCount;
                return data;
        }

        // If these is no existing symbol, create the required data.
        SymbolData * data = new SymbolData(str, 1);
        allSymbols.insert(std::make_pair(&data->value, data));
        return data;
}

/// Reduce reference count and free the SymbolData as needed.
static void decSymbolData(SymbolData * data) {
        // First comes the actual decrement.
        --data->refCount;

        // If it has hit zero, remove it from the map.
        if (0 == data->refCount) {
                eraseUnused();
        }
}

Symbol::Symbol() : data(getSymbolData(std::string())) {}

Symbol::Symbol(std::string const & str) : data(getSymbolData(str)) {}

Symbol::Symbol(char const * str) : data(getSymbolData(str)) {}

Symbol::Symbol(Symbol const & other) : data(other.data) {
        ++data->refCount;
}

Symbol::Symbol(Symbol && other) : data(other.data) {
        ++data->refCount;
}

Symbol::~Symbol() {
        decSymbolData(data);
}

Symbol & Symbol::operator=(std::string const & str) {
        SymbolData * dat = getSymbolData(str);
        decSymbolData(data);
        data = dat;
        return *this;
}

Symbol & Symbol::operator=(char const * str) {
        return this->operator=(std::string(str));
}

Symbol & Symbol::operator=(Symbol const & other) {
        ++other.data->refCount;
        decSymbolData(data);
        data = other.data;
        return *this;
}

Symbol & Symbol::operator=(Symbol && other) {
        Symbol const & ref = other;
        return this->operator=(ref);
}

bool Symbol::operator==(Symbol const & other) const {
        return data == other.data;
}

bool Symbol::operator!=(Symbol const & other) const {
        return data != other.data;
}

std::string const & Symbol::str() const {
        return data->value;
}

char const * Symbol::c_str() const {
        return data->value.c_str();
}