//#include<functional>
#include "deep_iterator.hpp"
#include "unary_function_iterator.hpp"
#include "nullary_function_iterator.hpp"
#include "coupling_iterator.hpp"
#include "dummy_iterator.hpp"
#include "constant_iterator.hpp"
#include"counted_iterator.hpp"
#include "state_machine_iterator.hpp"
#include "reverse_range.hpp"
#include "symetric_borders_range.hpp"

#include "../c_algorithms.h"

#include <vector>
#include <string>
#include <boost/pending/integer_range.hpp>
#include <boost/min_rand.hpp>
#include <boost/compose.hpp>

#include "append_range.hpp"
#include "my_operators.hpp"

//gcc -o testDeepIter testDeepIter.cxx -I /home/hugueney/Devel/import/lastBoost/ -I. -lstdc++ -O6 -Wall 

template <typename NumType>
class MyNumber {
public:
  MyNumber() {}

  MyNumber( NumType initVal): _v(initVal) {}
  void times2() { _v *= 2;}
  void divides2() {_v /= 2;}
  
  bool operator==( const MyNumber& y) const {return _v == y._v;}

  operator int () const { return _v;}

  NumType _v;

};

template< typename T>
ostream& operator<<( ostream& os, const MyNumber<T>& n){ return os<<n._v;}

using std::cout;
using std::endl;

int main(){

  cout<<"deep iterator demo"<<endl;
  
  typedef long data_type;
  typedef std::vector<data_type> inner_cont;
  typedef std::vector<inner_cont> outer_cont;
  typedef MyNumber<data_type> MN;

  outer_cont ou;

  std::ostream_iterator<data_type> outData(std::cout," ");
  std::ostream_iterator<MN> outMN(std::cout," ");
  std::ostream_iterator<string> outString(std::cout," ");

  data_type index(0);

  for(data_type i = 0; i <3; ++i){
    inner_cont in, in2, in3(2); // in2 is empty
    for(data_type j = 0; j <4; ++j){
      in.push_back(++index);
    }
    ou.push_back(in2);
    ou.push_back(in);
    ou.push_back(in3);
    ou.push_back(in2);
  }
  
  c_copy(make_deep_range(ou), outData);

  cout<<endl<<"unary_function_range: same but each element *2"<<endl;
  c_copy(make_unary_fonction_range(make_deep_range(ou),
				   std::bind1st(std::multiplies<data_type>(),
						2)), outData);

  cout<<endl<<"counted_range, only first 5 elements"<<endl;
  c_copy(make_counted_range(make_deep_range(ou), 5), outData);
  
  cout<<endl<<"nullary_function_iterator and coupling : display 5 random numbers"<<endl;
  boost::integer_range<long> r(0,5);
  c_copy(make_coupling_range(r,
			     make_nullary_function_iterator(boost::min_rand())),outData);

  cout<<endl<<"constant range: display 5 times the same string"<<endl;
  const string str("ToTo");
  c_copy(make_constant_range(str,5), outString);

  cout<<endl<<"state machine iterator : MN object in 5 states"<<endl;
  MN i(2);
  c_copy( make_counted_iterator_range(make_state_machine_iterator(i,
							 std::mem_fun_ref(&MN::times2)),5), outMN);
  
  cout<<endl<<"append ranges"<<endl;

  c_copy(make_append_range(make_state_machine_range( make_pair(0,5)),
			   make_constant_range(2,5)),
	 outData);

  c_copy(make_append_range(boost::integer_range<long int>(0,5), make_constant_range(2,5)), outData);

    cout<<endl<<"reverse ranges"<<endl;;
  c_copy(reverse_range(r), outData);
  cout<<endl;

  // test your compiler & computer ! uncomment if you wish but then
  // be sure to use -O6 to compile faster (!) and stip executable
  //   c_copy(make_append_range(reverse_range(make_deep_range(ou)),make_append_range(make_deep_range(ou),make_append_range(make_deep_range(ou),reverse_range(make_deep_range(ou))))),  outData);
  cout<<"symetric borders"<<endl;
  c_copy(make_symetric_borders_range(make_state_machine_range( make_pair(1,5))
				     ,2), outData);
  cout<<endl;
  return 0;
}