//demo a simple recursive variant using fusion sequence container.
//

#include "boost/variant.hpp"
#include "boost/blank.hpp"
#include "boost/fusion/container/vector.hpp"
#include "boost/fusion/include/at_c.hpp"

#include <iostream>
#include <utility>

template<typename T>
struct list_var
  ;
template<typename T>
struct list_bounded
  : boost::fusion::vector
    < T
    , boost::recursive_wrapper<list_var<T> >
    >
  {
        typedef
      boost::fusion::vector
      < T
      , boost::recursive_wrapper<list_var<T> >
      >
    super_t
      ;
        static 
      constexpr char const*
    class_name="list_bounded"
      ;
      
    list_bounded
    ( T a_head
    , list_var<T>const& a_tail
    )
    : super_t
      ( a_head
      , a_tail
      )
    {
      std::cout<<class_name<<"::CTOR_COPY:"<<a_head<<"\n";
    }
    
    list_bounded
    ( T a_head
    , list_var<T>&& a_tail
    )
    : super_t
      ( a_head
      , std::forward<list_var<T> >(a_tail)
      )
    {
        std::cout<<class_name<<"::CTOR_MOVE:"<<a_head<<"\n";
    }
  };
template<typename T>
struct list_var
: boost::variant
  < boost::blank
  , list_bounded<T>
  >
  {
        typedef
      boost::variant
      < boost::blank
      , list_bounded<T>
      >
    super_t
      ;
    list_var()
      {}
      template<typename U>
    list_var(U const&&u)
      : super_t(std::move(u))
      {}
  };
struct list_printer
    : boost::static_visitor<void>
{

    std::ostream& ost;
    list_printer(std::ostream& a_out):ost(a_out)
    {}

    void operator()(const boost::blank&) const
    {
        ost << "(blank) ";
    }
    
    template <typename T>
    void operator()(const list_bounded<T>& lst) const
    {
        ost << "( ";
        ost << boost::fusion::at_c<0>(lst) <<", ";
        const boost::recursive_wrapper<list_var<T> >&rw=boost::fusion::at_c<1>(lst);
        const list_var<T>*ptr=rw.get_pointer();
        if(ptr)
        {
            boost::apply_visitor( *this, *ptr);
        }
        else
        {
            ost<<"static_cast<list_var<T>const*>()";
        }
        ost << ") ";
    }
};

  template< typename T>
  std::ostream&
operator<<
  ( std::ostream& sout
  , list_var<T>const& a_list
  )
  {
      list_printer prtr(sout);
      boost::apply_visitor( prtr, a_list);
      return sout;
  }  

int main()
{
    typedef list_var<int> list_int_t;
    list_int_t list_empty;
    std::cout << __LINE__<<":list_empty constructed which="<<list_empty.which()<<"\n";
    std::cout << __LINE__<<":list_empty constructed print="<<list_empty<<"\n";
    list_int_t list_1(list_bounded<int>( 1, list_empty));
    std::cout << __LINE__<<":list_empty copied which="<<list_empty.which()<<"\n";
    std::cout << __LINE__<<":list_empty copied print="<<list_empty<<"\n";
    std::cout << __LINE__<<":list_1 constructed which="<<list_1.which()<<"\n";
    std::cout << __LINE__<<":list_1 constructed print="<<list_1<<"\n";
    list_int_t list_1_2(list_bounded<int>( 2, std::move(list_1)));
    std::cout << __LINE__<<":list_1 moved which="<<list_1.which()<<"\n";
    std::cout << __LINE__<<":list_1 moved print="<<list_1<<"\n";
    std::cout << __LINE__<<":list_1_2 constructed which="<<list_1_2.which()<<"\n";
    std::cout << __LINE__<<":list_1_2 constructed print="<<list_1_2<<"\n";
    return 0;
}