Boost C++ Libraries

boost/gil/extension/dynamic_image/apply_operation_base.hpp

//
// Copyright 2005-2007 Adobe Systems Incorporated
//
// 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 BOOST_GIL_EXTENSION_DYNAMIC_IMAGE_APPLY_OPERATION_BASE_HPP
#define BOOST_GIL_EXTENSION_DYNAMIC_IMAGE_APPLY_OPERATION_BASE_HPP

#include <boost/gil/utilities.hpp>

#include <boost/config.hpp>
#include <boost/mpl/begin.hpp>
#include <boost/mpl/next.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/size.hpp>
#include <boost/preprocessor/repeat.hpp> 

namespace boost { namespace gil {

/// Given an object with run-time specified type (denoted as an array of Bits,
/// dynamic index, and a static set of Types) and a generic operation,
/// casts the object to its appropriate type and applies the operation

/*
GENERATE_APPLY_FWD_OPS generates for every N functions that look like this (for N==2):

    template <> struct apply_operation_fwd_fn<3> {
        template <typename Types, typename Bits, typename UnaryOp>
        typename UnaryOp::result_type apply(Bits& bits, std::size_t index, UnaryOp op) const {
            typedef typename mpl::begin<Types>::type T0;
            typedef typename mpl::next<T0>::type T1;
            typedef typename mpl::next<T1>::type T2;
            switch (index) {
                case 0: return op(reinterpret_cast<typename mpl::deref<T0>::type&>(bits));
                case 1: return op(reinterpret_cast<typename mpl::deref<T1>::type&>(bits));
                case 2: return op(reinterpret_cast<typename mpl::deref<T2>::type&>(bits));
            }
            throw;
        }

        template <typename Types, typename Bits, typename UnaryOp>
        typename UnaryOp::result_type applyc(const Bits& bits, std::size_t index, UnaryOp op) const {
            typedef typename mpl::begin<Types>::type T0;
            typedef typename mpl::next<T0>::type T1;
            typedef typename mpl::next<T1>::type T2;
            switch (index) {
                case 0: return op(reinterpret_cast<const typename mpl::deref<T0>::type&>(bits));
                case 1: return op(reinterpret_cast<const typename mpl::deref<T1>::type&>(bits));
                case 2: return op(reinterpret_cast<const typename mpl::deref<T2>::type&>(bits));
            }
            throw;
        }
    };
*/

#define GIL_FWD_TYPEDEFS(z, N, text)   T##N; typedef typename mpl::next<T##N>::type 
#define GIL_FWD_CASE(z, N, SUM)       case N: return op(*gil_reinterpret_cast<typename mpl::deref<T##N>::type*>(&bits));
#define GIL_FWD_CONST_CASE(z, N, SUM) case N: return op(*gil_reinterpret_cast_c<const typename mpl::deref<T##N>::type*>(&bits));

#define GIL_FWD_CASE_WITH_INFO(z, N, SUM)       case N: return op(*gil_reinterpret_cast<typename mpl::deref<T##N>::type*>(&bits), info);
#define GIL_FWD_CONST_CASE_WITH_INFO(z, N, SUM) case N: return op(*gil_reinterpret_cast_c<const typename mpl::deref<T##N>::type*>(&bits), info);

#define GIL_APPLY_FWD_OP(z, N, text)                                                                        \
    template <> struct apply_operation_fwd_fn<BOOST_PP_ADD(N,1)> {                                      \
        template <typename Types, typename Bits, typename UnaryOp>                                     \
        typename UnaryOp::result_type apply(Bits& bits, std::size_t index, UnaryOp op) const {        \
            typedef typename mpl::begin<Types>::type                                             \
            BOOST_PP_REPEAT(N, GIL_FWD_TYPEDEFS, BOOST_PP_EMPTY)                                            \
            T##N;                                                                                       \
            switch (index) {                                                                            \
                BOOST_PP_REPEAT(BOOST_PP_ADD(N,1), GIL_FWD_CASE, BOOST_PP_EMPTY)                            \
            }                                                                                           \
            throw;                                                                                      \
        }                                                                                               \
        template <typename Types, typename Bits, typename UnaryOp>                                     \
        typename UnaryOp::result_type applyc(const Bits& bits, std::size_t index, UnaryOp op) const { \
            typedef typename mpl::begin<Types>::type                                             \
            BOOST_PP_REPEAT(N, GIL_FWD_TYPEDEFS, BOOST_PP_EMPTY)                                            \
            T##N;                                                                                       \
            switch (index) {                                                                            \
                BOOST_PP_REPEAT(BOOST_PP_ADD(N,1), GIL_FWD_CONST_CASE,BOOST_PP_EMPTY)                       \
            }                                                                                           \
            throw;                                                                                      \
        }                                                                                               \
        template <typename Types, typename Info, typename Bits, typename UnaryOp>                                     \
        typename UnaryOp::result_type apply(Bits& bits, std::size_t index, const Info& info, UnaryOp op) const {        \
            typedef typename mpl::begin<Types>::type                                             \
            BOOST_PP_REPEAT(N, GIL_FWD_TYPEDEFS, BOOST_PP_EMPTY)                                            \
            T##N;                                                                                       \
            switch (index) {                                                                            \
                BOOST_PP_REPEAT(BOOST_PP_ADD(N,1), GIL_FWD_CASE_WITH_INFO, BOOST_PP_EMPTY)                            \
            }                                                                                           \
            throw;                                                                                      \
        }                                                                                               \
        template <typename Types, typename Bits, typename Info, typename UnaryOp>                                     \
        typename UnaryOp::result_type applyc(const Bits& bits, std::size_t index, const Info& info, UnaryOp op) const { \
            typedef typename mpl::begin<Types>::type                                             \
            BOOST_PP_REPEAT(N, GIL_FWD_TYPEDEFS, BOOST_PP_EMPTY)                                            \
            T##N;                                                                                       \
            switch (index) {                                                                            \
                BOOST_PP_REPEAT(BOOST_PP_ADD(N,1), GIL_FWD_CONST_CASE_WITH_INFO,BOOST_PP_EMPTY)                       \
            }                                                                                           \
            throw;                                                                                      \
        }                                                                                               \
    };

#define GIL_GENERATE_APPLY_FWD_OPS(N) BOOST_PP_REPEAT(N, GIL_APPLY_FWD_OP, BOOST_PP_EMPTY)

namespace detail {
template <std::size_t N> struct apply_operation_fwd_fn {};

// Create specializations of apply_operation_fn for each N 0..100
GIL_GENERATE_APPLY_FWD_OPS(99)
} // namespace detail

// unary application
template <typename Types, typename Bits, typename Op> 
typename Op::result_type BOOST_FORCEINLINE apply_operation_basec(const Bits& bits, std::size_t index, Op op) {
    return detail::apply_operation_fwd_fn<mpl::size<Types>::value>().template applyc<Types>(bits,index,op);
}

// unary application
template <typename Types, typename Bits, typename Op> 
typename Op::result_type BOOST_FORCEINLINE apply_operation_base(      Bits& bits, std::size_t index, Op op) {
    return detail::apply_operation_fwd_fn<mpl::size<Types>::value>().template apply<Types>(bits,index,op);
}

namespace detail {
    template <typename T2, typename Op>
    struct reduce_bind1 {
        const T2& _t2;
        Op&  _op;

        typedef typename Op::result_type result_type;

        reduce_bind1(const T2& t2, Op& op) : _t2(t2), _op(op) {}

        template <typename T1> BOOST_FORCEINLINE result_type operator()(const T1& t1) { return _op(t1, _t2); }
    };

    template <typename Types1, typename Bits1, typename Op>
    struct reduce_bind2 {
        const Bits1& _bits1;
        std::size_t _index1;
        Op&  _op;

        typedef typename Op::result_type result_type;

        reduce_bind2(const Bits1& bits1, std::size_t index1, Op& op) : _bits1(bits1), _index1(index1), _op(op) {}

        template <typename T2> BOOST_FORCEINLINE result_type operator()(const T2& t2) { 
            return apply_operation_basec<Types1>(_bits1, _index1, reduce_bind1<T2,Op>(t2, _op));
        }
    };
} // namespace detail

// Binary application by applying on each dimension separately
template <typename Types1, typename Types2, typename Bits1, typename Bits2, typename Op>
static typename Op::result_type BOOST_FORCEINLINE apply_operation_base(const Bits1& bits1, std::size_t index1, const Bits2& bits2, std::size_t index2, Op op) {
    return apply_operation_basec<Types2>(bits2,index2,detail::reduce_bind2<Types1,Bits1,Op>(bits1,index1,op));
}

#undef GIL_FWD_TYPEDEFS
#undef GIL_FWD_CASE
#undef GIL_FWD_CONST_CASE
#undef GIL_APPLY_FWD_OP
#undef GIL_GENERATE_APPLY_FWD_OPS
#undef BHS

}}  // namespace boost::gil

#endif