//demo a simple recursive variant.
//

#include "boost/variant.hpp"
#include "boost/blank.hpp"

#include <iostream>
#include <sstream>
#include <utility>

template<typename T>
struct list_bounded
  ;

template<typename T>
using list_var=
  boost::variant
  < boost::blank
  , boost::recursive_wrapper< list_bounded< T> >
  >
  ;
  
  
template<typename T>
struct list_bounded
  {
    T head;
    list_var<T> tail;
    
    list_bounded
    ( T a_head
    , list_var<T>const& a_tail
    )
    : head(a_head)
    , tail(a_tail)
    {
        std::cout<<"CTOR_COPY:"<<a_head<<"\n";
    }
    
    list_bounded
    ( T a_head
    , list_var<T>&& a_tail
    )
    : head(a_head)
    , tail(std::forward<list_var<T> >(a_tail))
    {
        std::cout<<"MOVE_COPY:"<<a_head<<"\n";
    }
  };
  
  std::ostream&
operator<<
  ( std::ostream& sout
  , boost::blank
  )
  {
      sout<<"(blank)";
      return sout;
  }  

struct list_printer
    : boost::static_visitor<std::string>
{
    template <typename T>
    std::string operator()(const list_bounded<T>& lst) const
    {
        std::ostringstream ost;

        ost << "( ";

        ost << lst.head <<", ";
        ost << boost::apply_visitor( list_printer(), lst.tail);

        ost << ") ";

        return ost.str();
    }

    template <typename T>
    std::string operator()(const T& operand) const
    {
        std::ostringstream ost;
        ost << operand << ' ';
        return ost.str();
    }
};

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

void test_recursive_variant()
{
    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";
}

int main(int , char* [])
{
    test_recursive_variant();
    return 0;
}