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