static_table.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
/**************************************************************************************************/
 
#ifndef ADOBE_STATIC_TABLE_HPP
#define ADOBE_STATIC_TABLE_HPP
 
/**************************************************************************************************/
 
#include <adobe/config.hpp>
 
#include <functional>
#include <stdexcept>
#include <utility>
 
#include <adobe/algorithm/lower_bound.hpp>
#include <adobe/algorithm/sort.hpp>
 
/**************************************************************************************************/
 
namespace adobe {
 
/**************************************************************************************************/
 
//***************************************************************************//
//***************************************************************************//
//***************************************************************************//









 
//***************************************************************************//
//***************************************************************************//
//***************************************************************************//








 
 
template <typename KeyType, typename ValueType>
struct static_table_traits {
    typedef bool result_type;
    typedef KeyType key_type;
    typedef ValueType value_type;
    typedef std::pair<key_type, value_type> entry_type;
 
    result_type operator()(const entry_type& x, const entry_type& y) const {
        return (*this)(x, y.first);
    }
 
    // revisit: MM. For debugging purposes, VC 8 requires the definition of
    // this (unnecessary overload) in debug versions.
    result_type operator()(const key_type& x, const entry_type& y) const { return x < y.first; }
 
    result_type operator()(const entry_type& x, const key_type& y) const { return x.first < y; }
 
    result_type equal(const key_type& x, const key_type& y) const { return x == y; }
};
 
/**************************************************************************************************/
 
template <typename KeyType, typename ValueType, std::size_t Size,
          typename Traits = static_table_traits<KeyType, ValueType>>
struct static_table {
    typedef Traits traits_type;
    typedef typename traits_type::key_type key_type;
    typedef typename traits_type::value_type value_type;
    typedef typename traits_type::entry_type entry_type;
 
    const value_type& operator()(const key_type& key) const {
        const entry_type* iter(adobe::lower_bound(table_m, key, traits_type()));
 
        if (iter == boost::end(table_m) || !traits_type().equal(iter->first, key))
            throw std::logic_error("static_table key not found");
 
        return iter->second;
    }
 
    bool operator()(const key_type& key, value_type& result) const {
        const entry_type* iter(adobe::lower_bound(table_m, key, traits_type()));
 
        if (iter == boost::end(table_m) || !traits_type().equal(iter->first, key))
            return false;
 
        result = iter->second;
 
        return true;
    }
 
    void sort() { adobe::sort(table_m, traits_type()); }
 
public:
    entry_type table_m[Size];
};
 
/**************************************************************************************************/
 
} // namespace adobe
 
/**************************************************************************************************/
 
#endif // ADOBE_STATIC_TABLE_HPP
 
/**************************************************************************************************/