#include <iostream>
#include <cstdlib>
#include <cstring>   //for memmove
#include <vector>
#include <iterator>
#include <algorithm>
#include "introspect.h"
#include "date.h"
using namespace std;

//The is_memmovable member of class __copy_traits is a typedef for __true or __false.
struct __either {};
struct __true : public __either {};
struct __false: public __either {};

/*
struct __copy_traits takes a data type T and tells us if a variable of that type
can be copied with memmove.  If so, the is_memmovable member of __copy_traits<T>
will be a typedef for __true; otherwise it will be a typedef for __false.
*/

template <class T>
struct __copy_traits {
	typedef __false is_memmovable;
};

template <class T>
struct __copy_traits<T *> {         //partial specialization
	typedef __true is_memmovable;
};

template <class T>
struct __copy_traits<const T *> {   //same as above, but with const
	typedef __true is_memmovable;
};

template <> struct __copy_traits<bool       > {typedef __true is_memmovable;};
template <> struct __copy_traits<char       > {typedef __true is_memmovable;};
//etc.
template <> struct __copy_traits<double     > {typedef __true is_memmovable;};
template <> struct __copy_traits<long double> {typedef __true is_memmovable;};

template <> struct __copy_traits<date> {typedef __true is_memmovable;};
//Etc.: define a specialization for each type T that can be copied with memmove.

template <class INPUT, class OUTPUT>
OUTPUT __my_copy(INPUT first, INPUT last, OUTPUT result, __either)
{
	cout << "can't use memmove\n";

	for (; first != last; ++first, ++result) {
		*result = *first;
	}

	return result;
}

template <class T>
T *__my_copy(T *first, T *last, T* result, __true)
{
	cout << "memmove with read/write source\n";

	memmove(result, first, (last - first) * sizeof (T));
	return result + (last - first);
}

template <class T>   //same as above, but with const's
T *__my_copy(const T *first, const T *last, T* result, __true)
{
	cout << "memmove with read-only source\n";

	memmove(result, first, (last - first) * sizeof (T));
	return result + (last - first);
}

template <class INPUT, class OUTPUT>
inline OUTPUT my_copy(INPUT first, INPUT last, OUTPUT result)
{
	typedef typename iterator_traits<INPUT>::value_type value_type;
	typedef typename __copy_traits<value_type>::is_memmovable is_memmovable;

	return __my_copy(first, last, result, is_memmovable());
}

int main()
{
	const date source1[] = {
		date(date::july,       4, 1776),
		date(date::october,   29, 1929),
		date(date::december,   7, 1941)
	};
	const size_t n1 = sizeof source1 / sizeof source1[0];
	vector<date> v(source1, source1 + n1);
	my_copy(v.begin(), v.end(), ostream_iterator<date>(cout, "\n"));
	cout << "\n";

	const size_t n2 = 3;
	const introspect source2[n2];
	introspect dest2[n2];
	my_copy(source2, source2 + n2, dest2);
	copy(dest2, dest2 + n2, ostream_iterator<introspect>(cout, "\n"));
	cout << "\n";

	const size_t n3 = n1;
	date dest3[n3];
	my_copy(source1, source1 + n3, dest3);
	copy(dest3, dest3 + n3, ostream_iterator<date>(cout, "\n"));
	cout << "\n";

	date source4[] = {
		date(date::july,      20, 1969),
		date(date::september, 11, 2001),
		date()
	};
	const size_t n4 = sizeof source4 / sizeof source4[0];
	date dest4[n4];
	my_copy(source4, source4 + n4, dest4);
	copy(dest4, dest4 + n4, ostream_iterator<date>(cout, "\n"));

	return EXIT_SUCCESS;
}