Re: [boost] [fusion] unpack into constructor?

From: Tobias Schwinger (tschwinger_at_[hidden])
Date: 2007-06-15 18:02:47

Eric Niebler wrote:
> Tobias Schwinger wrote:
>> Eric Niebler wrote:
>>>>> Is the sort of thing you are looking for?
>>>>>
>>>>> fused_ctor<T> fc;
>>>>> T t = fc(sequence);
>>> Yes, that's the thing.
>> OK, but why duplicate the unpacking of the Sequence?
>>
>> All it takes is yet another adapter encapsulating a type's ctor(s) in a 
>> function object to just use fusion::(invoke|fused)_function_object. E.g:
>>
> <snip>
>> Client code (at function scope):
>>
>>     invoke_function_object( ctor<my_class>(), argseq );
> 
> 
> Yes, that's exactly it. Now, put it in Fusion so I don't have to write a 
> function object with N overloads. :-)

OK, and here's some preliminary code.
Headers go to fusion/functional/adapter, the .cpp file is a test.

Thanks to Peter for making me realize things can be easy, occasionally :-).

Regards,
Tobias


/*=============================================================================
    Copyright (c) 2006-2007 Tobias Schwinger
  
    Use modification and distribution are subject to 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).
==============================================================================*/

#if !defined(BOOST_FUSION_FUNCTIONAL_ADAPTER_LIMITS_HPP_INCLUDED)
#   define BOOST_FUSION_FUNCTIONAL_ADAPTER_LIMITS_HPP_INCLUDED

#   include <boost/fusion/sequence/container/vector/limits.hpp>

#   if !defined(BOOST_FUSION_UNFUSED_GENERIC_MAX_ARITY)
#       define BOOST_FUSION_UNFUSED_GENERIC_MAX_ARITY 6
#   elif BOOST_FUSION_UNFUSED_GENERIC_MAX_ARITY > FUSION_MAX_VECTOR_SIZE
#       error "BOOST_FUSION_UNFUSED_GENERIC_MAX_ARITY > FUSION_MAX_VECTOR_SIZE"
#   endif
#   if !defined(BOOST_FUSION_UNFUSED_RVALUE_ARGS_MAX_ARITY)
#       define BOOST_FUSION_UNFUSED_RVALUE_ARGS_MAX_ARITY 6
#   elif BOOST_FUSION_UNFUSED_RVALUE_ARGS_MAX_ARITY > FUSION_MAX_VECTOR_SIZE
#       error "BOOST_FUSION_UNFUSED_RVALUE_ARGS_MAX_ARITY > FUSION_MAX_VECTOR_SIZE"
#   endif
#   if !defined(BOOST_FUSION_UNFUSED_LVALUE_ARGS_MAX_ARITY)
#       define BOOST_FUSION_UNFUSED_LVALUE_ARGS_MAX_ARITY 6
#   elif BOOST_FUSION_UNFUSED_LVALUE_ARGS_MAX_ARITY > FUSION_MAX_VECTOR_SIZE
#       error "BOOST_FUSION_UNFUSED_LVALUE_ARGS_MAX_ARITY > FUSION_MAX_VECTOR_SIZE"
#   endif
#   if !defined(BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY)
#       define BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY 6
#   elif BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY > FUSION_MAX_VECTOR_SIZE
#       error "BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY > FUSION_MAX_VECTOR_SIZE"
#   endif
#   if !defined(BOOST_FUSION_CONSTRUCTOR_MAX_ARITY)
#       define BOOST_FUSION_CONSTRUCTOR_MAX_ARITY 6
#   endif

#endif


/*=============================================================================
    Copyright (c) 2007 Tobias Schwinger
  
    Use modification and distribution are subject to 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).
==============================================================================*/

#if !defined(BOOST_FUSION_FUNCTIONAL_ADAPTER_CONSTRUCTOR_HPP_INCLUDED)
#if !defined(BOOST_PP_IS_ITERATING)

#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>

#include <boost/fusion/functional/adapter/limits.hpp>

namespace boost { namespace fusion
{

    template<typename T>
    class constructor
    {
    public:

        typedef T result_type;

        inline T operator()() const
        {
            return T();
        }

        #define BOOST_PP_FILENAME_1 \
            <boost/fusion/functional/adapter/constructor.hpp> 
        #define BOOST_PP_ITERATION_LIMITS \
            (1, BOOST_FUSION_CONSTRUCTOR_MAX_ARITY)
        #include BOOST_PP_ITERATE()
    };
}}

#define BOOST_FUSION_FUNCTIONAL_ADAPTER_CONSTRUCTOR_HPP_INCLUDED
#else // defined(BOOST_PP_IS_ITERATING)
////////////////////////////////////////////////////////////////////////////////
//
//  Preprocessor vertical repetition code
//
////////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()

        template< BOOST_PP_ENUM_PARAMS(N, typename T) >
        inline T operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& a)) const
        {
            return T(BOOST_PP_ENUM_PARAMS(N, a));
        }        

#undef N
#endif // defined(BOOST_PP_IS_ITERATING)
#endif


/*=============================================================================
    Copyright (c) 2007 Tobias Schwinger
  
    Use modification and distribution are subject to 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).
==============================================================================*/

#include <boost/fusion/functional/adapter/constructor.hpp>
#include <boost/detail/lightweight_test.hpp>

#include <boost/bind.hpp>

namespace fusion = boost::fusion;

class X
{
  int val_sum;
public:
  X() : val_sum(0) { }
  X(int a) : val_sum(a) { }
  X(int a, int b) : val_sum(a + b) { }

  operator int() const { return this->val_sum; }
};

class Y
{
  int const & ref_a;
  Y(); // undefined
public:
  Y(int & a) : ref_a(a) { }
  operator int() const { return this->ref_a; }
};

int main()
{
    int one = 1, two = 2;

    fusion::constructor<X> create_x;
    BOOST_TEST(create_x() == 0);
    BOOST_TEST(create_x(one) == 1);
    BOOST_TEST(create_x(one,two) == 3);

    fusion::constructor<Y> create_y;
    BOOST_TEST(create_y(one) == 1);

    BOOST_TEST(boost::bind(create_x,one,_1)(two) == 3);
    BOOST_TEST(boost::bind(create_x,1,_1)(two) == 3);

    return boost::report_errors();
}