---

AtomicId.cc

Go to the documentation of this file.

#include <algorithm>
#include <cstdlib>
#include <cstddef>
#include <cstring>
#include <set>

#include <boost/thread.hpp>

#include "PhysicsTools/MVAComputer/interface/AtomicId.h"

namespace { // anonymous
        struct StringLess {
                bool operator()(const char *id1, const char *id2) const
                { return std::strcmp(id1, id2) < 0; }
        };

        class IdCache {
            public:
                ~IdCache();

                inline const char *findOrInsert(const char *string) throw();

            private:
                typedef std::multiset<const char *, StringLess> IdSet;

                IdSet                           idSet;
                static std::allocator<char>     stringAllocator;
                mutable boost::mutex            mutex;
        };
} // anonymous namespace

std::allocator<char> IdCache::stringAllocator;

IdCache::~IdCache()
{
        for(std::multiset<const char*, StringLess>::iterator iter =
            idSet.begin(); iter != idSet.end(); iter++)
                stringAllocator.deallocate(const_cast<char*>(*iter),
                                           std::strlen(*iter));
}

const char *IdCache::findOrInsert(const char *string) throw()
{
        boost::mutex::scoped_lock scoped_lock(mutex);

        IdSet::iterator pos = idSet.lower_bound(string);
        if (pos != idSet.end() && std::strcmp(*pos, string) == 0)
                return *pos;

        std::size_t size = std::strlen(string) + 1;
        char *unique = stringAllocator.allocate(size);
        std::memcpy(unique, string, size);

        idSet.insert(pos, unique);

        return unique;
}

namespace PhysicsTools {

static IdCache &getAtomicIdCache()
{
        static IdCache atomicIdCache;
        return atomicIdCache;
}

const char *AtomicId::lookup(const char *string) throw()
{
        if (string)
                return getAtomicIdCache().findOrInsert(string);

        return 0;
}

} // namespace PhysicsTools

---