| /* |
| Copyright 2005-2007 Adobe Systems Incorporated |
| |
| Use, modification and distribution are subject to 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). |
| |
| See http://opensource.adobe.com/gil for most recent version including documentation. |
| */ |
| |
| /*************************************************************************************************/ |
| |
| #ifndef GIL_DYNAMIC_AT_C_HPP |
| #define GIL_DYNAMIC_AT_C_HPP |
| |
| #include "../../gil_config.hpp" |
| #include <cassert> |
| #include <stdexcept> |
| #include <boost/mpl/at.hpp> |
| #include <boost/mpl/size.hpp> |
| |
| |
| //////////////////////////////////////////////////////////////////////////////////////// |
| /// \file |
| /// \brief Constructs for static-to-dynamic integer convesion |
| /// \author Lubomir Bourdev and Hailin Jin \n |
| /// Adobe Systems Incorporated |
| /// \date 2005-2007 \n Last updated on May 4, 2006 |
| /// |
| //////////////////////////////////////////////////////////////////////////////////////// |
| |
| namespace boost { namespace gil { |
| |
| #define GIL_AT_C_VALUE(z, N, text) mpl::at_c<IntTypes,S+N>::type::value, |
| #define GIL_DYNAMIC_AT_C_LIMIT 226 // size of the maximum vector to handle |
| |
| #define GIL_AT_C_LOOKUP(z, NUM, text) \ |
| template<std::size_t S> \ |
| struct at_c_fn<S,NUM> { \ |
| template <typename IntTypes, typename ValueType> inline \ |
| static ValueType apply(std::size_t index) { \ |
| static ValueType table[] = { \ |
| BOOST_PP_REPEAT(NUM, GIL_AT_C_VALUE, BOOST_PP_EMPTY) \ |
| }; \ |
| return table[index]; \ |
| } \ |
| }; |
| |
| namespace detail { |
| namespace at_c { |
| template <std::size_t START, std::size_t NUM> struct at_c_fn; |
| BOOST_PP_REPEAT(GIL_DYNAMIC_AT_C_LIMIT, GIL_AT_C_LOOKUP, BOOST_PP_EMPTY) |
| |
| template <std::size_t QUOT> struct at_c_impl; |
| |
| template <> |
| struct at_c_impl<0> { |
| template <typename IntTypes, typename ValueType> inline |
| static ValueType apply(std::size_t index) { |
| return at_c_fn<0,mpl::size<IntTypes>::value>::template apply<IntTypes,ValueType>(index); |
| } |
| }; |
| |
| template <> |
| struct at_c_impl<1> { |
| template <typename IntTypes, typename ValueType> inline |
| static ValueType apply(std::size_t index) { |
| const std::size_t SIZE=mpl::size<IntTypes>::value; |
| const std::size_t REM = SIZE % GIL_DYNAMIC_AT_C_LIMIT; |
| switch (index / GIL_DYNAMIC_AT_C_LIMIT) { |
| case 0: return at_c_fn<0 ,GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index); |
| case 1: return at_c_fn<GIL_DYNAMIC_AT_C_LIMIT ,REM >::template apply<IntTypes,ValueType>(index - GIL_DYNAMIC_AT_C_LIMIT); |
| }; |
| throw; |
| } |
| }; |
| |
| template <> |
| struct at_c_impl<2> { |
| template <typename IntTypes, typename ValueType> inline |
| static ValueType apply(std::size_t index) { |
| const std::size_t SIZE=mpl::size<IntTypes>::value; |
| const std::size_t REM = SIZE % GIL_DYNAMIC_AT_C_LIMIT; |
| switch (index / GIL_DYNAMIC_AT_C_LIMIT) { |
| case 0: return at_c_fn<0 ,GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index); |
| case 1: return at_c_fn<GIL_DYNAMIC_AT_C_LIMIT ,GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index - GIL_DYNAMIC_AT_C_LIMIT); |
| case 2: return at_c_fn<GIL_DYNAMIC_AT_C_LIMIT*2,REM >::template apply<IntTypes,ValueType>(index - GIL_DYNAMIC_AT_C_LIMIT*2); |
| }; |
| throw; |
| } |
| }; |
| |
| template <> |
| struct at_c_impl<3> { |
| template <typename IntTypes, typename ValueType> inline |
| static ValueType apply(std::size_t index) { |
| const std::size_t SIZE=mpl::size<IntTypes>::value; |
| const std::size_t REM = SIZE % GIL_DYNAMIC_AT_C_LIMIT; |
| switch (index / GIL_DYNAMIC_AT_C_LIMIT) { |
| case 0: return at_c_fn<0 ,GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index); |
| case 1: return at_c_fn<GIL_DYNAMIC_AT_C_LIMIT ,GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index - GIL_DYNAMIC_AT_C_LIMIT); |
| case 2: return at_c_fn<GIL_DYNAMIC_AT_C_LIMIT*2,GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index - GIL_DYNAMIC_AT_C_LIMIT*2); |
| case 3: return at_c_fn<GIL_DYNAMIC_AT_C_LIMIT*3,REM >::template apply<IntTypes,ValueType>(index - GIL_DYNAMIC_AT_C_LIMIT*3); |
| }; |
| throw; |
| } |
| }; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| /// |
| /// \brief Given an MPL Random Access Sequence and a dynamic index n, returns the value of the n-th element |
| /// It constructs a lookup table at compile time |
| /// |
| //////////////////////////////////////////////////////////////////////////////////// |
| |
| template <typename IntTypes, typename ValueType> inline |
| ValueType at_c(std::size_t index) { |
| const std::size_t Size=mpl::size<IntTypes>::value; |
| return detail::at_c::at_c_impl<Size/GIL_DYNAMIC_AT_C_LIMIT>::template apply<IntTypes,ValueType>(index); |
| } |
| |
| #undef GIL_AT_C_VALUE |
| #undef GIL_DYNAMIC_AT_C_LIMIT |
| #undef GIL_AT_C_LOOKUP |
| |
| } } // namespace boost::gil |
| |
| #endif |