StringManager.hpp

// <StringManager> -*- C++ -*-
 
#pragma once
 
#include <string>
#include <map>
#include <memory>
#include <iostream>
#include <iomanip>
 
#include "sparta/utils/StaticInit.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
namespace sparta
{
    class StringManager;
 
    class StringManager
    {
 
        class Deleter {
 
            const bool should_free_;
 
        public:
 
            Deleter() = delete;
 
            Deleter(bool should_free) : should_free_(should_free) {;}
 
            Deleter(const Deleter&) = default;
 
            Deleter& operator=(Deleter&) = delete;
 
            void operator()(std::string* sp) const {
                if(should_free_){
                    delete sp;
                }
            }
        };
 
 
        Deleter do_delete_;
 
        Deleter dont_delete_;
 
    public:
 
        friend class SpartaStaticInitializer;
 
        using StringUniquePtr = std::unique_ptr<std::string, Deleter>;
        typedef std::map<std::string, StringUniquePtr> StringMap;
 
        StringMap string_map_;
        uint32_t max_string_len_; 
 
        const uint64_t is_constructed;
 
        static const uint64_t IS_CONSTRUCTED_CONST = 0x0123456789abcdef;
 
        StringManager() :
            do_delete_(true),
            dont_delete_(false),
            max_string_len_(0),
            is_constructed(IS_CONSTRUCTED_CONST),
            EMPTY(internString(""))
        { }
 
        std::string* internString(const std::string& s) {
            std::string* result = findString(s);
            if(result){
                return result;
            }
 
            // Unfortunately cannot point to key as it is not guaranteed
            // stable. Duplicating the string string is minor waste.
            max_string_len_ = std::max<decltype(max_string_len_)>(max_string_len_, s.size());
            StringUniquePtr ns(new std::string(s), do_delete_);
            string_map_.emplace(s, std::move(ns));
            return string_map_.find(s)->second.get();
        }
 
        std::string* findString(const std::string& s) const {
            auto itr = string_map_.find(s);
            if(itr != string_map_.end()){
                std::string* result = itr->second.get();
                sparta_assert(result != nullptr);
                return result;
            }
            return nullptr;
        }
 
        bool hasString(const std::string& s) const {
            return nullptr != findString(s);
        }
 
        bool isInterned(const std::string* s) const {
            for(auto & p : string_map_){
                if(p.second.get() == s){
                    return true;
                }
            }
 
            return false;
        }
 
        void dumpStrings(std::ostream& o, bool pretty=false) const {
            (void) pretty;
 
            std::ios::fmtflags f = o.flags();
 
            for(auto& pair : string_map_){
                o << "\"" << pair.first << "\" "
                  << std::setw((max_string_len_+4)-pair.first.size())
                  << " @ " << std::setw(10) << pair.second.get() << "\n";
            }
 
            // restore ostream flags
            o.flags(f);
        }
 
        uint32_t getNumStrings() const {
            return string_map_.size();
        }
 
        const std::string* const EMPTY;
 
        static StringManager& getStringManager() {
            sparta_assert(_GBL_string_manager && _GBL_string_manager->is_constructed == IS_CONSTRUCTED_CONST,
                              "Attempted to access StringManager singleton before it was "
                              "statically constructed.")
            return *_GBL_string_manager;
        }
 
    private:
 
        static sparta::StringManager* _GBL_string_manager;
    };
 
} // namespace sparta