ParamAdderImpl.h

 
namespace mel
{
    namespace mpl
    {
    #if VARIABLE_NUM_ARGS == VARIABLE_MAX_ARGS
 
        template <class T,class TRet,class NewArg>
        class ParamAdder_Base
        {
        public:
            ParamAdder_Base( T&& functor ):mFunctor( std::forward<T>(functor) ){};
            template <class F>
            bool operator ==( const F& ob2 ) const
            {
                return equality( Int2Type< Conversion<F, ParamAdder_Base<T,TRet,NewArg> >::exists >(),ob2 );
            }
        private:
            template <class F>
            bool equality( Int2Type<false>,const F&) const
            {
                return false;
            }
            bool equality( Int2Type<true >,const ParamAdder_Base<T,TRet,NewArg>& me2) const
            {
    
                return::mel::mpl::equal<true>( mFunctor,me2.mFunctor );
            }
 
        protected:
            T mFunctor;
        };
 
        template <class T,class TRet,class NewArg,VARIABLE_ARGS>
        class ParamAdder 
        : public ParamAdder_Base<T,TRet,NewArg>
        {
        public:
            ParamAdder( T&& functor ):ParamAdder_Base<T,TRet,NewArg>(std::forward<T>(functor)){};
 
            TRet operator()( VARIABLE_ARGS_IMPL,NewArg newarg )
            {
                return ParamAdder_Base<T,TRet,NewArg>::mFunctor( VARIABLE_ARGS_USE );
            };
        };
        //specialization for void arguments
        template <class T, class TRet, class NewArg >
        class ParamAdder<T,TRet,NewArg,void> : public ParamAdder_Base<T,TRet,NewArg>
        {
        public:
            ParamAdder( T&& functor ): ParamAdder_Base<T,TRet,NewArg>( std::forward<T>(functor) ){};
            TRet operator()( NewArg )
            {
                return ParamAdder_Base<T,TRet,NewArg>::mFunctor();
            }
            /*bool operator ==( const ParamAdder<T,TRet,NewArg,void>& ob2 ) const
            {
                return ParamAdder_Base<T,TRet,NewArg>::operator ==( ob2 );
            }*/
 
        };
        template <class TRet, class NewArg,VARIABLE_ARGS_NODEFAULT,class T> inline
            ParamAdder<T,TRet,VARIABLE_ARGS_DECL, NewArg> addParam( T functor )
        {
            return ParamAdder<T,TRet,NewArg, VARIABLE_ARGS_DECL>( std::forward<T>(functor) );
        }
    #else
        template <class T,class TRet,class NewArg,VARIABLE_ARGS>
        class ParamAdder<T,TRet,NewArg,VARIABLE_ARGS_DECL,void> : public ParamAdder_Base<T,TRet,NewArg>
        {
        public:
            ParamAdder( T&& functor ):ParamAdder_Base<T,TRet,NewArg>( std::forward<T>(functor) ){};
 
            TRet operator()( VARIABLE_ARGS_IMPL,NewArg )
            {
                return ParamAdder_Base<T,TRet,NewArg>::mFunctor( VARIABLE_ARGS_USE );
            };
            /*bool operator ==( const ParamAdder<T,TRet,NewArg,VARIABLE_ARGS_DECL,void>& ob2 ) const
            {
                return ParamAdder_Base<T,TRet,NewArg>::operator ==( ob2 );
            }*/
 
        };
 
 
        template <class TRet, class NewArg,VARIABLE_ARGS,class T> inline
            ParamAdder<T,TRet,NewArg,VARIABLE_ARGS_DECL > addParam( T functor )
        {
            return ParamAdder<T,TRet,NewArg,VARIABLE_ARGS_DECL>( std::forward<T>(functor) );
        }
    #endif
        }
 
    namespace mpl
    {
    #if VARIABLE_NUM_ARGS == VARIABLE_MAX_ARGS
 
        template <class T,class TRet,class NewArg>
        class ParamAdder_prev_Base
        {
        public:
            ParamAdder_prev_Base( T&& functor ):mFunctor( std::forward<T>(functor) ){};
            template <class F>
            bool operator ==( const F& ob2 ) const
            {
                return equality( Int2Type< Conversion<F, ParamAdder_prev_Base<T,TRet,NewArg> >::exists >(),ob2 );
            }
        private:
            template <class F>
            bool equality( Int2Type<false>,const F&) const
            {
                return false;
            }
            bool equality( Int2Type<true >,const ParamAdder_prev_Base<T,TRet,NewArg>& me2) const
            {
                return (mFunctor == me2.mFunctor);
            }
 
        protected:
            T mFunctor;
        };
        template <class T,class TRet,class NewArg,VARIABLE_ARGS>
        class ParamAdder_prev : public ParamAdder_prev_Base<T,TRet,NewArg>
        {
        public:
            ParamAdder_prev( const T& functor ):ParamAdder_prev_Base<T,TRet,NewArg>(functor){};
 
            TRet operator()( NewArg newarg,VARIABLE_ARGS_IMPL )
            {
                return ParamAdder_prev_Base<T,TRet,NewArg>::mFunctor( VARIABLE_ARGS_USE );
            };
            /*bool operator ==( const ParamAdder_prev& ob2 ) const
            {
                return ParamAdder_prev_Base<T,TRet,NewArg>::operator ==( ob2 );
            }*/
        };
        //specialization for void arguments
        template <class T, class TRet, class NewArg >
        class ParamAdder_prev<T,TRet,NewArg,void> : public ParamAdder_prev_Base<T,TRet,NewArg>
        {
        public:
            ParamAdder_prev( const T& functor ): ParamAdder_prev_Base<T,TRet,NewArg>( functor ){};
            TRet operator()( NewArg )
            {
                return ParamAdder_prev_Base<T,TRet,NewArg>::mFunctor();
            }
            /*bool operator ==( const ParamAdder_prev<T,TRet,NewArg,void>& ob2 ) const
            {
                return ParamAdder_prev_Base<T,TRet,NewArg>::operator ==( ob2 );
            }*/
 
        };
        template <class TRet, class NewArg,VARIABLE_ARGS_NODEFAULT,class T> inline
            ParamAdder_prev<T,TRet,VARIABLE_ARGS_DECL, NewArg> addParam_prev( T functor )
        {
            return ParamAdder_prev<T,TRet,NewArg, VARIABLE_ARGS_DECL>( functor );
        }
    #else
        template <class T,class TRet,class NewArg,VARIABLE_ARGS>
        class ParamAdder_prev<T,TRet,NewArg,VARIABLE_ARGS_DECL,void> : public ParamAdder_prev_Base<T,TRet,NewArg>
        {
        public:
            ParamAdder_prev( const T& functor ):ParamAdder_prev_Base<T,TRet,NewArg>( functor ){};
 
            TRet operator()( NewArg, VARIABLE_ARGS_IMPL)
            {
                return ParamAdder_prev_Base<T,TRet,NewArg>::mFunctor( VARIABLE_ARGS_USE );
            };
            /*bool operator ==( const ParamAdder_prev<T,TRet,NewArg,VARIABLE_ARGS_DECL,void>& ob2 ) const
            {
                return ParamAdder_prev_Base<T,TRet,NewArg>::operator ==( ob2 );
            }*/
        };
 
 
        template <class TRet, class NewArg,VARIABLE_ARGS,class T> inline
            ParamAdder_prev<T,TRet,NewArg,VARIABLE_ARGS_DECL > addParam_prev( T functor )
        {
            return ParamAdder_prev<T,TRet,NewArg,VARIABLE_ARGS_DECL>( functor );
        }
    #endif
        }
}