#include <vector>
#include <boost/optional.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/transform.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/include/as_vector.hpp>
#include <boost/variant/variant.hpp>
#include <boost/shared_ptr.hpp>

struct deoptionalize_item
{
  typedef deoptionalize_item Self;

  template<typename Sign>
  struct result;   

  template<typename T>  
  struct result<Self( const boost::optional<T>& )>
  {
    typedef const T& type;
  };

  template <typename T>
  const T& operator()( const boost::optional<T>& rhs ) const
  {
    return *rhs;
  }
};


template <typename T, typename dummy=void >
struct range {
  T min;
  T max;
};



///
/// Represents a range of values [min,max] with an increment of incr
/// Helps generate a loop
///    for (min;max;incr) 
/// Dummy is used to normalize range and range_incr with std::vector<>
/// for the purposes of template specialization of spirit rules
///
template <typename T, typename dummy=void >
struct range_incr {
  T min;
  T max;
  T incr;
};


template <typename T, typename dummy=void >
struct make_one_or_many {
  typedef boost::variant<
    std::vector<T>,
    range_incr<T>,
    range<T>,
    T
  > type;
};


template <typename params_seq_maybe_t>
struct deoptionalize {
  typedef 
    typename boost::fusion::result_of::transform<const params_seq_maybe_t, deoptionalize_item>::type 
  type;
};



struct make_1_n_unary_metafct {

  template<typename Sig>
  struct result;  // primary template

  template<typename Self, typename Arg>
  struct result<Self(Arg)> // template spec
  {
    typedef typename make_one_or_many<Arg>::type type;
  };

  template<class Arg>
  typename result<make_1_n_unary_metafct(Arg)>::type
  operator()(Arg);
};



template <typename parameters_t>
struct make_1_n {  
  typedef typename boost::fusion::result_of::transform< parameters_t, make_1_n_unary_metafct >::type seq_t;
  typedef typename boost::fusion::result_of::as_vector<seq_t>::type type;
};


template <typename T>
struct one_or_many_maybe {
  typedef boost::optional< typename make_one_or_many<T>::type > type;
};


struct make_1_n_maybe_unary_metafct {

  template<typename Sig>
  struct result;  // primary template

  template<typename Self, typename Arg>
  struct result<Self(Arg)> // template spec
  {
    typedef typename one_or_many_maybe<Arg>::type type;
  };

  template<class Arg>
  typename result<make_1_n_maybe_unary_metafct(Arg)>::type
  operator()(Arg);
};


///
/// Apply the unary metafunction on the struct
/// This yields vector< optional<variant<...>>, optional<variant<..>>, ... , optional< variant<> > >
/// 
template <typename parameters_t>
struct make_1_n_maybe {  
  typedef typename boost::fusion::result_of::transform< parameters_t, make_1_n_maybe_unary_metafct >::type seq_t;
  typedef typename boost::fusion::result_of::as_vector<seq_t>::type type;
};

namespace my_ns 
{
namespace systems
{

/// base aggregate for all system parameters
struct parameters {
  double skid;     /// fraction [0. : 1.] of loss from trade entry
  
  virtual parameters* clone() const; // the caller takes ownership
  virtual bool compareto(const parameters& rhs) const;
  virtual ~parameters() {}
};
typedef boost::shared_ptr<parameters> parameters_ptr;
typedef boost::shared_ptr<const parameters> parameters_const_ptr;


inline parameters* parameters::clone() const
{
  return new parameters(*this);
}

inline bool parameters::compareto(const parameters& rhs) const
{
  return skid==rhs.skid;
}

/// == operator
inline bool operator==(const parameters& lhs, const parameters& rhs)
{
  return lhs.compareto(rhs);
}

inline bool operator==(parameters& lhs, parameters& rhs)
{
  return lhs.compareto(rhs);
}

inline bool operator==(const parameters& lhs, parameters& rhs)
{
  return lhs.compareto(rhs);
}

inline bool operator==(parameters& lhs, const parameters& rhs)
{
  return lhs.compareto(rhs);
}

}
}

namespace my_ns 
{
namespace systems
{
namespace ns1
{

struct parameters : public systems::parameters {
	

	ns1::parameters* clone() const;
	
};

inline ns1::parameters* ns1::parameters::clone() const
{
  return new ns1::parameters(*this);
}

}
}
}

BOOST_FUSION_ADAPT_STRUCT(
  my_ns::systems::ns1::parameters,
  (double, skid)
)



typedef make_1_n_maybe<my_ns::systems::ns1::parameters>::type parameters_1_n_maybe_t;    
typedef deoptionalize<parameters_1_n_maybe_t>::type parameters_1_n_seq_t;

int main()
{
  const parameters_1_n_maybe_t y;
  const parameters_1_n_seq_t z = boost::fusion::transform(y, deoptionalize_item());
  const boost::fusion::vector1< boost::variant<std::vector<double>,range_incr<double>,range<double>,double>  >& x = z;

  return 0;
}