static_table.hpp

Go to the documentation of this file.

/*
    Copyright 2005-2007 Adobe Systems Incorporated
    Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
    or a copy at http://stlab.adobe.com/licenses.html)
*/

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

#ifndef ADOBE_STATIC_TABLE_HPP
#define ADOBE_STATIC_TABLE_HPP

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

#include <adobe/config.hpp>

#include <utility>
#include <stdexcept>

#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

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