Marshal.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/

#ifndef STK_UTIL_UTIL_MARSHAL_HPP
#define STK_UTIL_UTIL_MARSHAL_HPP

#include <stdint.h>

#include <string>
#include <sstream>
#include <vector>
#include <list>
#include <typeinfo>

namespace stk_classic {

struct Marshal
{
  enum {
    TYPE_CHECK_NONE     = 0x00000000,
    TYPE_CHECK_POD      = 0x00000001,
    TYPE_CHECK_LIST     = 0x00000002,
    TYPE_CHECK_VECTOR   = 0x00000004,
    TYPE_CHECK_ALL      = 0xFFFFFFFF
  };
  
  Marshal(unsigned type_check = TYPE_CHECK_NONE);

  explicit Marshal(const std::string &s);

  std::string str() const;

  size_t size() const;

  void write(const char *address, size_t byte_count);
  
  void read(char *address, size_t byte_count);

  operator void * () const;
  
private:
  Marshal(const Marshal &marshal);                      
  Marshal &operator=(const Marshal &);                  

public:
  std::stringstream     stream;                         
  unsigned              m_typeCheck;                    
};


template <typename T>
Marshal &operator<<(Marshal &mout, const T &t);

template <typename T>
Marshal &operator>>(Marshal &min, T &t);

template<>
Marshal &operator<<(Marshal &mout, const std::type_info &t);

template<>
Marshal &operator>>(Marshal &min, const std::type_info &t);

template<>
Marshal &operator<<(Marshal &mout, const signed char &t);
template<>
Marshal &operator<<(Marshal &mout, const unsigned char &t);
template<>
Marshal &operator<<(Marshal &mout, const char &t);
template<>
Marshal &operator<<(Marshal &mout, const short &t);
template<>
Marshal &operator<<(Marshal &mout, const unsigned short &t);
template<>
Marshal &operator<<(Marshal &mout, const int &t);
template<>
Marshal &operator<<(Marshal &mout, const unsigned int &t);
template<>
Marshal &operator<<(Marshal &mout, const long &t);
template<>
Marshal &operator<<(Marshal &mout, const unsigned long &t);
template<>
Marshal &operator<<(Marshal &mout, const long long &t);
template<>
Marshal &operator<<(Marshal &mout, const unsigned long long &t);
template<>
Marshal &operator<<(Marshal &mout, const float &t);
template<>
Marshal &operator<<(Marshal &mout, const double &t);
template<>
Marshal &operator<<(Marshal &mout, const std::string &s);

template<>
Marshal &operator>>(Marshal &min, signed char &t);
template<>
Marshal &operator>>(Marshal &min, unsigned char &t);
template<>
Marshal &operator>>(Marshal &min, char &t);
template<>
Marshal &operator>>(Marshal &min, short &t);
template<>
Marshal &operator>>(Marshal &min, unsigned short &t);
template<>
Marshal &operator>>(Marshal &min, int &t);
template<>
Marshal &operator>>(Marshal &min, unsigned int &t);
template<>
Marshal &operator>>(Marshal &min, long &t);
template<>
Marshal &operator>>(Marshal &min, unsigned long &t);
template<>
Marshal &operator>>(Marshal &min, long long &t);
template<>
Marshal &operator>>(Marshal &min, unsigned long long &t);
template<>
Marshal &operator>>(Marshal &min, float &t);
template<>
Marshal &operator>>(Marshal &min, double &t);
template<>
Marshal &operator>>(Marshal &min, std::string &s);


template <class T>
Marshal &operator<<(Marshal &mout, const std::vector<T> &v)  {
  if (mout.m_typeCheck & Marshal::TYPE_CHECK_VECTOR)
    mout << typeid(v);

  size_t size = v.size();
  mout << size;
  for (typename std::vector<T>::const_iterator it = v.begin(); it != v.end(); ++it)
    mout << (*it);

  return mout;
}

template <class T>
Marshal &operator>>(Marshal &min, std::vector<T> &v)  {
  if (min.m_typeCheck & Marshal::TYPE_CHECK_VECTOR)
    min >> typeid(v);
   
  size_t size = 0;
  min >> size;
  v.reserve(size);
  for (size_t i = 0; i < size; ++i) {
    T t;
    min >> t;
    v.push_back(t);
  }

  return min;
}

template <class T>
Marshal &operator<<(Marshal &mout, const std::list<T> &l)  {
  if (mout.m_typeCheck & Marshal::TYPE_CHECK_LIST)
    mout << typeid(l);

  size_t size = l.size();
  mout << size;
  for (typename std::list<T>::const_iterator it = l.begin(); it != l.end(); ++it)
    mout << (*it);

  return mout;
}

template <class T>
Marshal &operator>>(Marshal &min, std::list<T> &l)  {
  if (min.m_typeCheck & Marshal::TYPE_CHECK_LIST)
    min >> typeid(l);

  size_t size;
  min >> size;
  for (size_t i = 0; i < size; ++i) {
    T t;
    min >> t;
    l.push_back(t);
  }

  return min;
}

template <class T>
Marshal &write(Marshal &mout, const T &t) {
  mout.write((const char *) &t, sizeof(T));

  return mout;
}

template <typename T>
Marshal &read(Marshal &min, T &t) {
  t = T();
  
  min.read((char *) &t, sizeof(T));
  return min;
}

} // namespace stk_classic

#endif // STK_UTIL_UTIL_MARSHAL_HPP