MemoryIArchive.h

#ifndef UTIL_MEMORY_I_ARCHIVE_H
#define UTIL_MEMORY_I_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 MemoryOArchive;

   class MemoryIArchive 
   {
 
   public:

      static bool is_saving();

      static bool is_loading();

      MemoryIArchive();

      ~MemoryIArchive();

      void allocate(size_t capacity);

      MemoryIArchive& operator = (MemoryOArchive& other);

      void reset();

      void clear();

      void release();

      template <typename T>
      MemoryIArchive& operator >> (T& data);

      template <typename T>
      MemoryIArchive& operator & (T& data);

      template <typename T, size_t N>
      MemoryIArchive& operator >> (T (& data)[N]);

      template <typename T, size_t N>
      MemoryIArchive& operator & (T (& data)[N]);
 
      // Pack functions and function templates

      template <typename T>
      void unpack(T& data);
   
      template <typename T>
      void unpack(T* array, int n);

      template <typename T> 
      void unpack(T* array, int m, int n, int np);
 
      #ifdef UTIL_MPI
      void recv(MPI::Intracomm& comm, int source);
      #endif

      Byte* begin() const;

      Byte* cursor() const;

      Byte* end() const;

      size_t capacity() const;

      bool isAllocated() const;
 
   private:

      Byte* buffer_;

      Byte* begin_;

      Byte* cursor_;

      Byte* end_;

      Byte* endAllocated_;

      MemoryOArchive* oArchivePtr_;

      size_t capacity_;

      unsigned int version_;

      bool ownsData_;
 
   };
 
   // Inline static methods
 
   inline bool MemoryIArchive::is_saving()
   { return false; }
 
   inline bool MemoryIArchive::is_loading()
   { return true; }
 
   // Inline non-static methods
 
   /*
   * Return pointer to beginning of block.
   */
   inline Byte* MemoryIArchive::begin() const
   {  return begin_; }
 
   /*
   * Return pointer to cursor position.
   */
   inline Byte* MemoryIArchive::cursor() const
   {  return cursor_; }
 
   /*
   * Return end of packed block (one Byte past the last).
   */
   inline Byte* MemoryIArchive::end() const
   {  return end_; }
 
   /*
   * Return capacity in Bytes.
   */
   inline size_t MemoryIArchive::capacity() const
   {  return capacity_; }
 
   /*
   * Has a memory block been allocated?
   */
   inline bool MemoryIArchive::isAllocated() const
   {  return (bool) begin_; }
 
   // Template methods
 
   /*
   * Load one T object from this MemoryIArchive.
   */
   template <typename T>
   inline MemoryIArchive& MemoryIArchive::operator >> (T& data)
   {   
      serialize(*this, data, version_); 
      return *this;
   }
 
   /*
   * Load one T object from a MemoryIArchive.
   */
   template <typename T>
   inline MemoryIArchive& MemoryIArchive::operator & (T& data)
   {  
      serialize(*this, data, version_); 
      return *this;
   }
 
   /*
   * Load a fixed size array of objects via operator >>.
   */
   template <typename T, size_t N>
   inline MemoryIArchive& MemoryIArchive::operator >> (T (&data)[N])
   {
      for (size_t i=0; i < N; ++i) {   
         serialize(*this, data[i], version_); 
      }
      return *this;
   }
 
   /*
   * Load a fixed size array of objects via operator &.
   */
   template <typename T, size_t N>
   inline MemoryIArchive& MemoryIArchive::operator & (T (&data)[N])
   {
      for (size_t i=0; i < N; ++i) {
         serialize(*this, data[i], version_); 
      }
      return *this;
   }
 
   /*
   * Load one T object from this MemoryIArchive.
   */
   template <typename T>
   void MemoryIArchive::unpack(T& data)
   {
      if (cursor_ + sizeof(data) > end_) {
         UTIL_THROW("Attempted read past end of packed block");
      }
      T* ptr = (T *)cursor_;
      data = *ptr;
      ++ptr;
      cursor_ = (Byte *)ptr;
   }
 
   /*
   * Load a C-array of objects of type T.
   */
   template <typename T>
   void MemoryIArchive::unpack(T* array, int n)
   {
      if (cursor_ + n*sizeof(T) > end_) {
         UTIL_THROW("Attempted read past end of data");
      }
      T* ptr = (T *)cursor_;
      for (int i=0; i < n; ++i) {
         array[i] = *ptr;
         ++ptr;
      }
      cursor_ = (Byte *)ptr;
   }
 
   /*
   * Bitwise pack a 2D C-array of objects of type T.
   */
   template <typename T>
   void MemoryIArchive::unpack(T* array, int m, int n, int np)
   {
      if (cursor_ + m*n*sizeof(T) > end_) {
         UTIL_THROW("Attempted read past end of data");
      }
      int i, j;
      T* ptr = (T *)cursor_;
      for (i = 0; i < m; ++i) {
         for (j = 0; j < n; ++j) {
            array[i*np + j] = *ptr;
            ++ptr;
         }
      }
      cursor_ = (Byte *)ptr;
   }
 
   // Explicit specializations of serialize function
 
   /*
   * Load a char from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, char& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load a bool from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, bool& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load an unsigned int from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, unsigned int& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load an int from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, int& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load an unsigned long int from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, unsigned long& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load a long int from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, long& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load a float from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, float& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load a double from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, double& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load a std::vector from a MemoryIArchive.
   */
   template <typename T>
   void serialize(MemoryIArchive& ar, std::vector<T>& data, 
                  const unsigned int version)
   {
      T element;
      std::size_t size;
      ar.unpack(size);
      data.reserve(size);
      data.clear();
      for (size_t i = 0; i < size; ++i) {
         ar & element;
         data.push_back(element);
      }
   }
 
   // Explicit serialize methods for std library types.
 
   /*
   * Load a std::complex<float> from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, std::complex<float>& data,        
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load a std::complex<double> from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, std::complex<double>& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load a std::string from MemoryIArchive.
   */
   template <>
   void serialize(MemoryIArchive& ar, std::string& data, 
                         const unsigned int version);
 
   // Explicit serialize methods for Util namespace types.
 
   /*
   * Load a Util::Vector from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, Vector& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
   /*
   * Load a Util::IntVector from a MemoryIArchive.
   */
   template <>
   inline void serialize(MemoryIArchive& ar, IntVector& data, 
                         const unsigned int version)
   {  ar.unpack(data); }
 
}
#endif