include/nrt/Core/Util/AutoBind.H

Go to the documentation of this file.

/*! @file
    @author Edward T. Kaszubski ( ekaszubski@gmail.com )
    @copyright GNU Public License (GPL v3)
    @section License
    @verbatim
    // ////////////////////////////////////////////////////////////////////////
    //              The iLab Neuromorphic Robotics Toolkit (NRT)             //
    // Copyright 2010-2012 by the University of Southern California (USC)    //
    //                          and the iLab at USC.                         //
    //                                                                       //
    //                iLab - University of Southern California               //
    //                Hedco Neurociences Building, Room HNB-10               //
    //                    Los Angeles, Ca 90089-2520 - USA                   //
    //                                                                       //
    //      See http://ilab.usc.edu for information about this project.      //
    // ////////////////////////////////////////////////////////////////////////
    // This file is part of The iLab Neuromorphic Robotics Toolkit.          //
    //                                                                       //
    // The iLab Neuromorphic Robotics Toolkit is free software: you can      //
    // redistribute it and/or modify it under the terms of the GNU General   //
    // Public License as published by the Free Software Foundation, either   //
    // version 3 of the License, or (at your option) any later version.      //
    //                                                                       //
    // The iLab Neuromorphic Robotics Toolkit is distributed in the hope     //
    // that it will be useful, but WITHOUT ANY WARRANTY; without even the    //
    // implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR       //
    // PURPOSE.  See the GNU General Public License for more details.        //
    //                                                                       //
    // You should have received a copy of the GNU General Public License     //
    // along with The iLab Neuromorphic Robotics Toolkit.  If not, see       //
    // <http://www.gnu.org/licenses/>.                                       //
    // ////////////////////////////////////////////////////////////////////////
    @endverbatim */

#ifndef INCLUDE_NRT_CORE_UTIL_AUTOBIND_H
#define INCLUDE_NRT_CORE_UTIL_AUTOBIND_H

#include <functional>

/* auto_binder inspired by code written by "superbonzo" and "Chris_F" (http://www.codeguru.com/forum/showthread.php?t=512875) */

#define __AUTO_BIND_FUNCTION_TYPE \
        std::function

namespace details
{

template<typename... __ArgTypes> struct container{};

} // details

namespace details
{

template<class __FunctionType>
struct funct_types {};

template<class __ReturnType, class... __ArgTypes>
struct funct_types<__AUTO_BIND_FUNCTION_TYPE<__ReturnType(__ArgTypes...)> >
{
    typedef container<__ArgTypes...> _ArgTypesContainer;
    typedef __ReturnType _ReturnType;
};

template<int N>
struct auto_binder
{
    template <typename __CallerType, typename __ReturnType, typename... __ArgTypes, typename... __PlaceHolders>
    static __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__ArgTypes...)> auto_bind(__ReturnType(__CallerType::*function_ptr)(__ArgTypes...), __CallerType* const caller, __PlaceHolders... placeholders )
    {
        return auto_binder<N-1>::auto_bind( function_ptr, caller, std::_Placeholder<N>(), placeholders... );
    }

    template <typename __ReturnType, typename... __ArgTypes, typename... __PlaceHolders>
    static __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__ArgTypes...)> auto_bind(__ReturnType(*function_ptr)(__ArgTypes...), __PlaceHolders... placeholders )
    {
        return auto_binder<N-1>::auto_bind( function_ptr, std::_Placeholder<N>(), placeholders... );
    }

    template <typename... __OutputArgTypes, typename __ReturnType, typename... __InputArgTypes, typename... __Appends>
    static __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__OutputArgTypes...)> auto_bind_append( const container<__OutputArgTypes...> & container, const __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__InputArgTypes...)> & function, __Appends... appends )
    {
        return auto_binder<N-1>::auto_bind_append( container, function, std::_Placeholder<N>(), appends... );
    }
};

template<>
struct auto_binder<0>
{
    template <typename __CallerType, typename __ReturnType, typename... __ArgTypes, typename... __PlaceHolders>
    static __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__ArgTypes...)> auto_bind(__ReturnType(__CallerType::*function_ptr)(__ArgTypes...), __CallerType* const caller, __PlaceHolders... placeholders )
    {
        return __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__ArgTypes...)>( std::bind( function_ptr, caller, placeholders... ) );
    }

    template <typename __ReturnType, typename... __ArgTypes, typename... __PlaceHolders>
    static __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__ArgTypes...)> auto_bind(__ReturnType(*function_ptr)(__ArgTypes...), __PlaceHolders... placeholders )
    {
        return __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__ArgTypes...)>( std::bind( function_ptr, placeholders... ) );
    }

    template <typename... __OutputArgTypes, typename __ReturnType, typename... __InputArgTypes, typename... __Appends>
    static __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__OutputArgTypes...)> auto_bind_append( const container<__OutputArgTypes...> & container, const __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__InputArgTypes...)> & function, __Appends... appends )
    {
        return __AUTO_BIND_FUNCTION_TYPE<__ReturnType( __OutputArgTypes... )>( std::bind( function, appends... ) );
    }
};

} // details

namespace nrt
{

template <typename __CallerType, typename __ReturnType, typename... __ArgTypes>
__AUTO_BIND_FUNCTION_TYPE<__ReturnType(__ArgTypes...)> auto_bind(__ReturnType(__CallerType::*function_ptr)(__ArgTypes...), __CallerType* const caller)
{
    return details::auto_binder<sizeof...(__ArgTypes)>::auto_bind( function_ptr, caller );
}

template <typename __ReturnType, typename... __ArgTypes>
__AUTO_BIND_FUNCTION_TYPE<__ReturnType(__ArgTypes...)> auto_bind(__ReturnType(*function_ptr)(__ArgTypes...))
{
    return details::auto_binder<sizeof...(__ArgTypes)>::auto_bind( function_ptr );
}

// this a bit ugly because the compiler was failing to pick up on the output function's args, so now the function type has to be manually specified with __OutputFunctionType and the output args can then be extracted
/* usage:
 *  std::auto_bind<__OutputFunctionType>( @input_function, @args_to_append... )
 *
 * example:
 *  typedef std::function<void(int, int, int)> _FunctionType1
 *  typedef std::function<void(int, int, int, int)> _FunctionType2
 *
 *  void some_function( int arg1, int arg2, int arg3, int arg4 ){};
 *  const int value_of_arg4 = 5;
 *
 *  // the usual thing to do is:
 *  _FunctionType1 other_function_boost ( boost::bind( &some_function, _1, _2, _3, value_of_arg4 ) );
 *  other_function_boost( 4, 5, 6 ); // calls some_function( 4, 5, 6, value_of_arg4 );
 *
 *  // but now you can do:
 *  _FunctionType1 other_function ( std::bind<_FunctionType1>( &some_function, value_of_arg4 ) );
 *  other_function( 4, 5, 6 ); // calls some_function( 4, 5, 6, value_of_arg4 );
 *
 *  // the improvement here is that placeholders are automatically calculated
 *  // so if _FunctionType1 had N more arguments, the code for std::bind would remain the same
 *  // whereas with boost it would be necessary to specify an additional N placeholders for those arguments
 *
 *  // the downside is that you can't re-order arguments like you can with boost
 *
 */

/*template <typename __OutputFunctionType, typename __ReturnType, typename __CallerType, typename... __InputArgTypes, typename... __Appends>
auto auto_bind( __ReturnType(__CallerType::*function_ptr)(__InputArgTypes...), __CallerType* caller, __Appends... appends ) -> decltype( auto_bind( details::auto_binder<sizeof...(__InputArgTypes)>::auto_bind( function_ptr, caller ), appends... ) )
{
    return auto_bind( details::auto_binder<sizeof...(__InputArgTypes)>::auto_bind( function_ptr, caller ), appends... );
}*/

template <typename __OutputFunctionType, typename __ReturnType, typename... __InputArgTypes, typename... __Appends>
auto auto_bind( const __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__InputArgTypes...)> & function, __Appends... appends ) -> decltype( auto_bind( typename details::funct_types<__OutputFunctionType>::_ArgTypesContainer(), function, appends... ) )
{
    // first, we need to find out how many args are in the return function type, since we need a placeholder for each of those args
    return auto_bind( typename details::funct_types<__OutputFunctionType>::_ArgTypesContainer(), function, appends... );
}

// we need to make a placeholder for each item of __OutputArgTypes...
template <typename... __OutputArgTypes, typename __ReturnType, typename... __InputArgTypes, typename... __Appends>
static __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__OutputArgTypes...)> auto_bind( const details::container<__OutputArgTypes...> & container, const __AUTO_BIND_FUNCTION_TYPE<__ReturnType(__InputArgTypes...)> & function, __Appends... appends )
{
    return details::auto_binder<sizeof...(__OutputArgTypes)>::auto_bind_append( container, function, appends... );
}

} // nrt

#endif // INCLUDE_NRT_CORE_UTIL_AUTOBIND_H