#include <boost/config/warning_disable.hpp>

#include <boost/optional.hpp>

#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/spirit/include/phoenix_core.hpp>

#include <boost/fusion/include/nview.hpp>

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>

#include <boost/detail/lightweight_test.hpp>

#include <iostream>
#include <string>

namespace phoenix = boost::phoenix;
namespace fusion = boost::fusion;

struct rlc_reorder
{
    struct rlc { };
    struct lcr { };

    typedef fusion::vector<
        boost::optional<double>,    // 0 - R
        boost::optional<double>,    // 1 - L
        boost::optional<double>     // 2 - C
        >                               vector_type;

#if WANT_TO_HAVE
    template <typename T, typename ID>
    struct result { typedef vector_type type; };

    template <typename T, typename ID>
    vector_type operator()( const vector_type& v,
                            typename boost::enable_if<boost::is_same<ID, rlc> >::type* id = 0 ) const
    {
        return fusion::as_nview<0, 1, 2>( v );
    }

    template <typename T, typename ID>
    vector_type operator()( const vector_type& v,
                            typename boost::enable_if<boost::is_same<ID, lcr> >::type* id = 0 ) const
    {
        return fusion::as_nview<2, 0, 1>( v );
    }
#else
    template <typename T>
    struct result { typedef vector_type type; };

    vector_type operator()( const vector_type& v ) const
    {
        return fusion::as_nview<2, 0, 1>( v );
    }
#endif
};

const phoenix::function<rlc_reorder> reorder = rlc_reorder();



int main(int argc, char * argv[])
{
    using boost::optional;
    using fusion::at_c;
    using phoenix::arg_names::arg1;
    using phoenix::arg_names::arg2;

    typedef fusion::vector<
        optional<double>,
        optional<double>,
        optional<double>
    > rlc_type;

    {
        rlc_type rlc;
        at_c<0>( rlc ) = 1; // R
        at_c<1>( rlc ) = 2; // L
        at_c<2>( rlc ) = 3; // C

        BOOST_TEST( at_c<0>( rlc ) &&  at_c<1>( rlc ) && at_c<2>( rlc ) );
        BOOST_TEST( *at_c<0>( rlc ) == 1 );
        BOOST_TEST( *at_c<1>( rlc ) == 2 );
        BOOST_TEST( *at_c<2>( rlc ) == 3 );
    }
    {
        rlc_type lcr;
        at_c<0>( lcr ) = 2; // L
        at_c<1>( lcr ) = 3; // C
        at_c<2>( lcr ) = 1; // R

        rlc_type rlc;

#if WANT_TO_HAVE
        rlc = reorder( arg1, arg2 ) (rlc, rlc_reorder::lcr() );
#else
        rlc = reorder( arg1 )( rlc );
#endif

        BOOST_TEST( at_c<0>( rlc ) &&  at_c<1>( rlc ) && at_c<2>( rlc ) );
        BOOST_TEST( *at_c<0>( rlc ) == 1 );
        BOOST_TEST( *at_c<1>( rlc ) == 2 );
        BOOST_TEST( *at_c<2>( rlc ) == 3 );
    }

    return boost::report_errors();
}