argument-tuple-accept.hpp

Go to the documentation of this file.

/*
  ARGUMENT-TUPLE-ACCEPT.hpp  -  helper template providing a bind(...) member function
 
   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef CONTROL_ARGUMENT_TUPLE_ACCEPT_H
#define CONTROL_ARGUMENT_TUPLE_ACCEPT_H
 
#include "lib/meta/typelist.hpp"
#include "lib/meta/function.hpp"
#include "lib/meta/tuple-helper.hpp"
 
#include <utility>
#include <tuple>
 
 
 
namespace steam {
namespace control {
  
  
  namespace bind_arg { // internals....
    
    using namespace lib::meta;
    using std::make_tuple;
    
    
    template< class TAR, class BA, class RET
            , typename TYPES
            >
    struct AcceptArgs ;
    
    template<class TAR, class BA, class RET, typename...ARGS>
    struct AcceptArgs<TAR,BA,RET, Types<ARGS...> >
      : BA
      {
        RET
        operator() (ARGS ...args)
          {
            return static_cast<TAR*> (this) -> bindArg (make_tuple (std::move(args) ...));
          }
      };
    
    
    
    template< class TAR, class BA, class RET
            , typename TYPES
            >
    struct AcceptBind ;
    
    template<class TAR, class BA, class RET, typename...ARGS>
    struct AcceptBind<TAR,BA,RET, Types<ARGS...> >
      : BA
      {
        RET
        bind (ARGS ...args)
          {
            return static_cast<TAR*> (this) -> bindArg (make_tuple (std::move(args)...));
          }
      };
    
    
    
    
    
    template< class TAR, class BA, class RET>
    struct AcceptAnyBind
      : BA
      {
        RET
        bind ()
          {
            return static_cast<TAR*> (this) -> bindArg (std::tuple<>());
          }
        
        template<typename...ARGS>
        RET
        bind (ARGS&& ...args)
          {
            return static_cast<TAR*> (this) -> bindArg (make_tuple (std::forward<ARGS> (args)...));
          }
      };
    
    
    
    using lib::meta::Tuple;
    using lib::meta::_Fun;
    
    
    template<typename SIG>
    struct _Type
      {
        using Args = _Fun<SIG>::Args;
        using Ret  = _Fun<SIG>::Ret;
        using Sig  = SIG;
        using ArgTuple = Tuple<Args>;
      };
    
    template<typename...TYPES>
    struct _Type<std::tuple<TYPES...> >
      {
        using Args = Types<TYPES...>::Seq;
        using Ret  = void;
        using Sig  = BuildFunType<void, Args>::Sig;
        using ArgTuple = std::tuple<TYPES...>;
      };
  
    struct Dummy {}; 
    
    
  } // (END) impl details (bind_arg)
  
  
  
  
  template<typename SIG, class TAR, class BASE =bind_arg::Dummy>
  class AcceptArgumentTuple
    : public bind_arg::AcceptArgs<TAR,BASE, typename bind_arg::_Type<SIG>::Ret
                                          , typename bind_arg::_Type<SIG>::Args>
    { };
  
  
  template<typename SIG, class TAR, class BASE =bind_arg::Dummy>
  class AcceptArgumentBinding
    : public bind_arg::AcceptBind<TAR,BASE, typename bind_arg::_Type<SIG>::Ret
                                          , typename bind_arg::_Type<SIG>::Args>
    { };
  
  
  template<typename RET, typename SIG, class TAR, class BASE =bind_arg::Dummy>
  class AcceptArgumentBindingRet
    : public bind_arg::AcceptBind<TAR,BASE, RET
                                          , typename bind_arg::_Type<SIG>::Args>
    { };
  
  
  template< class TAR
          , class RET  =TAR&
          , class BASE =bind_arg::Dummy
          >
  class AcceptAnyBinding
    : public bind_arg::AcceptAnyBind<TAR,BASE,RET>
    { };
  
  
  
  
  
  
}} // namespace steam::control
#endif