MemoryOArchive.h

#ifndef UTIL_MEMORY_O_ARCHIVE_H
#define UTIL_MEMORY_O_ARCHIVE_H
 
/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "Byte.h"
#include "serialize.h"
 
#include <util/space/Vector.h>
#include <util/space/IntVector.h>
 
#include <complex>
#include <string>
#include <vector>
 
namespace Util
{
 
   class MemoryIArchive;
 
   class MemoryOArchive
   {
 
   public:
 
      static bool is_saving();
 
      static bool is_loading();
 
      MemoryOArchive();
 
      virtual ~MemoryOArchive();
 
      virtual void allocate(size_t capacity);
 
      void clear();
 
      template <typename T>
      MemoryOArchive& operator << (T& data);
 
      template <typename T>
      MemoryOArchive& operator & (T& data);
 
      template <typename T, size_t N>
      MemoryOArchive& operator << (T (& data)[N]);
 
      template <typename T, size_t N>
      MemoryOArchive& operator & (T (& data)[N]);
 
      // Pack functions and function templates
 
      template <typename T> 
      void pack(const T& data);
 
      template <typename T> 
      void pack(const T* array, int n);
 
      template <typename T> 
      void pack(const T* array, int m, int n, int np);
 
      #ifdef UTIL_MPI
      void send(MPI::Intracomm& comm, int dest);
 
      void iSend(MPI::Intracomm& comm, MPI::Request& req, int dest);
      #endif
 
      Byte* begin() const;
 
      Byte* cursor() const;
 
      size_t capacity() const;
 
      bool isAllocated() const;
 
   private:
 
      Byte* buffer_;
 
      Byte* begin_;
 
      Byte* cursor_;
 
      Byte* endAllocated_;
 
      size_t capacity_;
 
      unsigned int version_;
 
      bool  isLocked_;
 
      bool ownsData_;
 
      MemoryOArchive (const MemoryOArchive& other);
 
      MemoryOArchive& operator = (const MemoryOArchive& other);
 
   // friends:
 
      friend class MemoryIArchive;
 
   };
 
   // Inline methods
 
   inline bool MemoryOArchive::is_saving()
   { return true; }
 
   inline bool MemoryOArchive::is_loading()
   { return false; }
 
   // Inline non-static methods
 
   /*
   * Has a memory block been allocated?
   */
   inline bool MemoryOArchive::isAllocated() const
   {  return (bool) begin_; }
 
   /*
   * Return capacity in Bytes.
   */
   inline size_t MemoryOArchive::capacity() const
   {  return capacity_; }
 
   /*
   * Return pointer to beginning of block.
   */
   inline Byte* MemoryOArchive::begin() const
   {  return begin_; }
 
   /*
   * Return pointer to cursor position.
   */
   inline Byte* MemoryOArchive::cursor() const
   {  return cursor_; }
 
   /*
   * Save one object of type T to this archive via the << operator.
   */
   template <typename T>
   inline MemoryOArchive& MemoryOArchive::operator << (T& data)
   {   
      serialize(*this, data, version_); 
      return *this;
   }
 
   /*
   * Save one object of type T to this archive via the & operator.
   */
   template <typename T>
   inline MemoryOArchive& MemoryOArchive::operator & (T& data)
   {  
      serialize(*this, data, version_); 
      return *this;
   }
 
   /*
   * Save a fixed size array of objects via operator <<.
   */
   template <typename T, size_t N>
   inline MemoryOArchive& MemoryOArchive::operator << (T (&data)[N])
   {
      for (size_t i = 0; i < N; ++i) {   
         serialize(*this, data[i], version_); 
      }
      return *this;
   }
 
   /*
   * Save a fixed size array of objects via operator &.
   */
   template <typename T, size_t N>
   inline MemoryOArchive& MemoryOArchive::operator & (T (&data)[N])
   {
      for (size_t i = 0; i < N; ++i) {
         serialize(*this, data[i], version_); 
      }
      return *this;
   }
 
   // Method templates
 
   /*
   * Save a single object of type T.
   */
   template <typename T>
   inline void MemoryOArchive::pack(const T& data)
   {
      if (isLocked_) {
         UTIL_THROW("Locked archive");
      }
      if (cursor_ + sizeof(data) > endAllocated_) {
         UTIL_THROW("Attempted write past end of allocated block");
      }
      T* ptr = (T *)cursor_;
      *ptr = data;
      ++ptr;
      cursor_ = (Byte *)ptr;
   }
 
   /*
   * Save a C-array of objects of type T.
   */
   template <typename T>
   inline void MemoryOArchive::pack(const T* array, int n)
   {
      if (isLocked_) {
         UTIL_THROW("Locked archive");
      }
      if (cursor_ + n*sizeof(T) > endAllocated_) {
         UTIL_THROW("Attempted write past end of allocated block");
      }
      T* ptr = (T *)cursor_;
      for (int i=0; i < n; ++i) {
         *ptr = array[i];
         ++ptr;
      }
      cursor_ = (Byte *)ptr;
   }
 
   /*
   * Bitwise pack a 2D C-array of objects of type T.
   */
   template <typename T>
   inline void MemoryOArchive::pack(const T* array, int m, int n, int np)
   {
      if (isLocked_) {
         UTIL_THROW("Locked archive");
      }
      if (cursor_ + m*n*sizeof(T) > endAllocated_) {
         UTIL_THROW("Attempted write past end of allocated block");
      }
      int i, j;
      T* ptr = (T *)cursor_;
      for (i=0; i < m; ++i) {
         for (j=0; j < n; ++j) {
            *ptr = array[i*np + j];
            ++ptr;
         }
      }
      cursor_ = (Byte *)ptr;
   }
 
   // Explicit serialize functions for primitive types
 
   /*
   * Save a bool to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, bool& data, 
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save a char to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, char& data, 
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save an unsigned int to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, unsigned int& data, 
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save an int to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, int& data, 
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save a unsigned long int to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, unsigned long& data,  
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save a long int to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, long& data,  
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save a float to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, float& data, 
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save an double to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, double& data, 
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save a std::vector to a MemoryOArchive.
   */
   template <typename T>
   void serialize(MemoryOArchive& ar, std::vector<T>& data, 
                  const unsigned int version)
   {
      size_t size = data.size();
      ar.pack(size);
      for (size_t i = 0; i < size; ++i) {
         ar & data[i];
      }
   }
 
   // Explicit serialize functions for standard library types
 
   /*
   * Save a std::complex<float> to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, std::complex<float>& data, 
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save a std::complex<double> to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, std::complex<double>& data, 
                         const unsigned int version)
   {  ar.pack(data); }
 
   /*
   * Save a std::string to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, std::string& data, 
                         const unsigned int version)
   {
      size_t size = data.size() + 1; // the +1 is for the NULL
      ar.pack(size);
      const char* temp = data.c_str();
      ar.pack(temp, size);
   }
 
   // Explicit serialize functions for namespace Util
 
   /*
   * Save a Util::Vector to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, Vector& data, 
                         const unsigned int version)
   {  ar.pack(data); } 
 
   /*
   * Save a Util::IntVector to a MemoryOArchive.
   */
   template <>
   inline void serialize(MemoryOArchive& ar, IntVector& data, 
                         const unsigned int version)
   {  ar.pack(data); }
 
}
#endif