ceph/src/boost/libs/gil/include/boost/gil/extension/dynamic_image/dynamic_at_c.hpp

   1 /*
   2     Copyright 2005-2007 Adobe Systems Incorporated
   3
   4     Use, modification and distribution are subject to the Boost Software License,
   5     Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   6     http://www.boost.org/LICENSE_1_0.txt).
   7
   8     See http://opensource.adobe.com/gil for most recent version including documentation.
   9 */
  10
  11 /*************************************************************************************************/
  12
  13 #ifndef GIL_DYNAMIC_AT_C_HPP
  14 #define GIL_DYNAMIC_AT_C_HPP
  15
  16 #include "../../gil_config.hpp"
  17 #include <cassert>
  18 #include <stdexcept>
  19 #include <boost/mpl/at.hpp>
  20 #include <boost/mpl/size.hpp>
  21
  22
  23 ////////////////////////////////////////////////////////////////////////////////////////
  24 /// \file
  25 /// \brief Constructs for static-to-dynamic integer convesion
  26 /// \author Lubomir Bourdev and Hailin Jin \n
  27 ///         Adobe Systems Incorporated
  28 /// \date 2005-2007 \n Last updated on May 4, 2006
  29 ///
  30 ////////////////////////////////////////////////////////////////////////////////////////
  31
  32 namespace boost { namespace gil {
  33
  34 #define GIL_AT_C_VALUE(z, N, text)    mpl::at_c<IntTypes,S+N>::type::value,
  35 #define GIL_DYNAMIC_AT_C_LIMIT        226    // size of the maximum vector to handle
  36
  37 #define GIL_AT_C_LOOKUP(z, NUM, text)                                   \
  38     template<std::size_t S>                                             \
  39     struct at_c_fn<S,NUM> {                                             \
  40     template <typename IntTypes, typename ValueType> inline           \
  41         static ValueType apply(std::size_t index) {                    \
  42             static ValueType table[] = {                               \
  43                 BOOST_PP_REPEAT(NUM, GIL_AT_C_VALUE, BOOST_PP_EMPTY)    \
  44             };                                                          \
  45             return table[index];                                        \
  46         }                                                               \
  47     };
  48
  49 namespace detail {
  50     namespace at_c {
  51         template <std::size_t START, std::size_t NUM> struct at_c_fn;
  52         BOOST_PP_REPEAT(GIL_DYNAMIC_AT_C_LIMIT, GIL_AT_C_LOOKUP, BOOST_PP_EMPTY)
  53
  54         template <std::size_t QUOT> struct at_c_impl;
  55
  56         template <>
  57         struct at_c_impl<0> {
  58             template <typename IntTypes, typename ValueType> inline
  59             static ValueType apply(std::size_t index) {
  60                 return at_c_fn<0,mpl::size<IntTypes>::value>::template apply<IntTypes,ValueType>(index);
  61             }
  62         };
  63
  64         template <>
  65         struct at_c_impl<1> {
  66             template <typename IntTypes, typename ValueType> inline
  67             static ValueType apply(std::size_t index) {
  68                 const std::size_t SIZE=mpl::size<IntTypes>::value;
  69                 const std::size_t REM = SIZE % GIL_DYNAMIC_AT_C_LIMIT;
  70                 switch (index / GIL_DYNAMIC_AT_C_LIMIT) {
  71                     case 0: return at_c_fn<0                   ,GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index);
  72                     case 1: return at_c_fn<GIL_DYNAMIC_AT_C_LIMIT  ,REM                 >::template apply<IntTypes,ValueType>(index - GIL_DYNAMIC_AT_C_LIMIT);
  73                 };
  74                 throw;
  75             }
  76         };
  77
  78         template <>
  79         struct at_c_impl<2> {
  80             template <typename IntTypes, typename ValueType> inline
  81             static ValueType apply(std::size_t index) {
  82                 const std::size_t SIZE=mpl::size<IntTypes>::value;
  83                 const std::size_t REM = SIZE % GIL_DYNAMIC_AT_C_LIMIT;
  84                 switch (index / GIL_DYNAMIC_AT_C_LIMIT) {
  85                     case 0: return at_c_fn<0                   ,GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index);
  86                     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);
  87                     case 2: return at_c_fn<GIL_DYNAMIC_AT_C_LIMIT*2,REM                 >::template apply<IntTypes,ValueType>(index - GIL_DYNAMIC_AT_C_LIMIT*2);
  88                 };
  89                 throw;
  90             }
  91         };
  92
  93         template <>
  94         struct at_c_impl<3> {
  95             template <typename IntTypes, typename ValueType> inline
  96             static ValueType apply(std::size_t index) {
  97                 const std::size_t SIZE=mpl::size<IntTypes>::value;
  98                 const std::size_t REM = SIZE % GIL_DYNAMIC_AT_C_LIMIT;
  99                 switch (index / GIL_DYNAMIC_AT_C_LIMIT) {
 100                     case 0: return at_c_fn<0                   ,GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index);
 101                     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);
 102                     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);
 103                     case 3: return at_c_fn<GIL_DYNAMIC_AT_C_LIMIT*3,REM                 >::template apply<IntTypes,ValueType>(index - GIL_DYNAMIC_AT_C_LIMIT*3);
 104                 };
 105                 throw;
 106             }
 107         };
 108     }
 109 }
 110
 111 ////////////////////////////////////////////////////////////////////////////////////
 112 ///
 113 ///    \brief Given an MPL Random Access Sequence and a dynamic index n, returns the value of the n-th element
 114 ///  It constructs a lookup table at compile time
 115 ///
 116 ////////////////////////////////////////////////////////////////////////////////////
 117
 118 template <typename IntTypes, typename ValueType> inline
 119 ValueType at_c(std::size_t index) {
 120     const std::size_t Size=mpl::size<IntTypes>::value;
 121     return detail::at_c::at_c_impl<Size/GIL_DYNAMIC_AT_C_LIMIT>::template apply<IntTypes,ValueType>(index);
 122 }
 123
 124 #undef GIL_AT_C_VALUE
 125 #undef GIL_DYNAMIC_AT_C_LIMIT
 126 #undef GIL_AT_C_LOOKUP
 127
 128 } }  // namespace boost::gil
 129
 130 #endif