constant_mapping.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include <functional>
#include "interop/util/map.h"
#include "interop/util/length_of.h"

namespace illumina { namespace interop { namespace util
{

    namespace detail
    {
        struct enum_hash
        {
            template<typename T>
            std::size_t operator()(const T val)const
            {
                return static_cast<std::size_t>(val);
            }
#ifdef INTEROP_HAS_UNORDERED_MAP

            std::size_t operator()(const std::string& val)const
            {
                return std::hash<std::string>{}(val);
            }
#endif
        };
    }

    template<class Key, class Value>
    class constant_mapping
    {
        typedef INTEROP_UNORDERED_HASHMAP(Key, Value, detail::enum_hash) constant_map_t;
    private:
        constant_mapping(const std::pair<Key, Value>* pairs, size_t n)
        {
            for (size_t i = 0; i < n; ++i)
            {
                m_mapping.insert(std::make_pair(pairs[i].first, pairs[i].second));
            }
        }
        constant_mapping(const std::pair<Value, Key>* pairs, size_t n)
        {
            for (size_t i = 0; i < n; ++i)
            {
                m_mapping.insert(std::make_pair(pairs[i].second, pairs[i].first));
            }
        }

    public:
        static const constant_mapping<Key, Value> &fmapping(const std::pair<Key, Value>* pairs, size_t pair_count)
        {
            static constant_mapping<Key, Value> singleton(pairs, pair_count); // Only called once
            return singleton;
        }
        static const constant_mapping<Key, Value> &rmapping(const std::pair<Value, Key>* pairs, size_t pair_count)
        {
            static constant_mapping<Key, Value> singleton(pairs, pair_count); // Only called once
            return singleton;
        }
        const Value &get(const Key &key, const Value &default_value) const
        {
            typename constant_map_t::const_iterator it = m_mapping.find(key);
            if (it == m_mapping.end()) return default_value;
            return it->second;
        }

    private:
        constant_map_t m_mapping;
    };

    template<class Key, class Value, size_t N>
    const Value &constant_mapping_get(const std::pair<Key, Value> (&pairs)[N], const Key &key,
                                      const Value &default_value)
    {
        return constant_mapping<Key, Value>::fmapping(pairs, N).get(key, default_value);
    }

}}}