#include <iostream>
#include <typeinfo>
#include <boost/timer.hpp>

using namespace std;

template<typename T>
void localcopy( T* lhs, T* lhs_end, T* rhs) {
  register T *plhs=lhs, *prhs=rhs, *plhs_end = lhs_end;
  
  while (plhs != plhs_end) {
    *plhs++ = *prhs++;
  }
}

const int iter_count = 100;
const size_t N = 5000;

template<typename T>
void time_copy( T dummy) {
  T* lhs = new T[N];
  T* rhs = new T[N];
  boost::timer t;
  double result;
  int i;

  dummy = 0;

  cout << "profiling copy for type " << typeid( T).name() << endl;

  t.restart();
  for (i=0;i<iter_count;i++) {
    copy( lhs, lhs+N, rhs);
  }
  result = t.elapsed();

  cout << "stl::copy " << result << endl;

  t.restart();
  for (i=0;i<iter_count;i++) {
    localcopy( lhs, lhs+N, rhs);
  }
  result = t.elapsed();

  cout << "localcopy " << result << endl;

  delete lhs;
  delete rhs;
}

class FooClass { 
public: 
  int foo; 
  double man; 
  char chu; 
  FooClass (int Foo=0, double Man=0, char Chu=0) :
    foo(Foo), man(Man), chu(Chu) {}
} Foo;

//template <class InputIterator, class OutputIterator>
//OutputIterator copy(InputIterator first, InputIterator last,
//                    OutputIterator result);

namespace std {
template <>
FooClass * copy( const FooClass *lhs, const FooClass *lhs_end, FooClass *rhs)
{
  size_t sz = (lhs_end - lhs)*sizeof(FooClass);
  memcpy( rhs, lhs, sz);
  
  return rhs+(lhs_end-lhs);
}
}

template <>
void localcopy( FooClass *lhs, FooClass *lhs_end, FooClass *rhs)
{
  size_t sz = (lhs_end - lhs)*sizeof(FooClass);
  memcpy( rhs, lhs, sz);
}


int main() {
  char c;
  int i;
  long long j;
  double d;
  long double D;

  time_copy( c);

  time_copy( i);

  time_copy( j);

  time_copy( d);

  time_copy( D);

  time_copy( Foo);

  return 0;
}