#ifndef Serialize_H
#define Serialize_H

#include <boost/type_traits.hpp>
#include <iostream>
#include <iterator>
#include <vector>
#include <complex>

template<typename T, bool ispod>
struct Saver {
  static void DoSave (const T& t, std::ostream& os);
};

template<typename T>
struct Saver<T, true> {
  static void DoSave (const T& t, std::ostream& os) {
    os.write ((const char*)(void*)(&t), sizeof (t));
  }
};

template<typename T>
struct Saver<T, false> {
  static void DoSave (const T& t, std::ostream& os) {
    T::DoSave (t, os);
  }
};

template<typename T>
void Save (const T& t, std::ostream& os) {
  Saver<T, ::boost::is_pod<T>::value>::DoSave (t, os);
}

template<typename T>
void Save (const std::vector<T>& v, std::ostream& os) {
  Save (v.size(), os);
  for (typename std::vector<T>::const_iterator it = v.begin(); it != v.end(); it++)
    Save (*it, os);
}

template<typename T>
void Save (const std::complex<T>& z, std::ostream& os) {
  Saver<const std::complex<T>, true>::DoSave (z, os);
}

template<typename T, bool ispod>
struct Loader {
  static void DoLoad (T& t, std::istream& os);
};

template<typename T>
struct Loader<T, true> {
  static void DoLoad (T& t, std::istream& os) {
    os.read ((char*)(void*)(&t), sizeof (t));
  }
};

template<typename T>
struct Loader<T, false> {
  static void DoLoad (T& t, std::istream& os) {
    T::DoLoad (t, os);
  }
};

template<typename T>
void Load (T& t, std::istream& os) {
  Loader<T, ::boost::is_pod<T>::value>::DoLoad (t, os);
}

template<typename T>
void Load (std::vector<T>& v, std::istream& os) {
  size_t size;
  Load (size, os);
  v.resize (size);
  for (size_t i = 0; i < size; i++)
    Load (v[i], os);
}

template<typename T>
void Load (std::complex<T>& z, std::istream& os) {
  Loader<std::complex<T>, true>::DoLoad (z, os);
}


#endif