MemoryCounter.h

#ifndef UTIL_MEMORY_COUNTER_H
#define UTIL_MEMORY_COUNTER_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 "serialize.h"
 
#include <util/space/Vector.h>
#include <util/space/IntVector.h>
 
#include <complex>
 
namespace Util
{
 
   class MemoryCounter
   {
 
   public:
 
      static bool is_saving();
 
      static bool is_loading();
 
      MemoryCounter();
 
      ~MemoryCounter();
 
      void clear();
 
      template <typename T>
      MemoryCounter& operator << (T& data);
 
      template <typename T>
      MemoryCounter& operator & (T& data);
 
      template <typename T, size_t N>
      MemoryCounter& operator << (T (& data)[N]);
 
      template <typename T, size_t N>
      MemoryCounter& operator & (T (& data)[N]);
 
      template <typename T> 
      void count(const T& data);
 
      template <typename T> 
      void count(T* array, int n);
 
      size_t size() const;
 
   private:
 
      size_t size_;
 
      int version_;
 
      MemoryCounter (const MemoryCounter& other);
 
      MemoryCounter& operator = (const MemoryCounter& other);
 
   // friends:
 
      friend void serialize<>(MemoryCounter&, std::string&, const unsigned int);
 
   };
 
   template <typename T>
   int memorySize(T& data)
   { 
      MemoryCounter counter;
      counter & data;
      return counter.size();
   }
 
   // Inline methods
 
   inline bool MemoryCounter::is_saving()
   { return true; }
 
   inline bool MemoryCounter::is_loading()
   { return false; }
 
   /*
   * Return capacity in Bytes.
   */
   inline size_t MemoryCounter::size() const
   {  return size_; }
 
   /*
   * Compute size of one object, default implementation.
   */
   template <typename T>
   inline MemoryCounter& MemoryCounter::operator << (T& data)
   {   
      serialize(*this, data, version_); 
      return *this;
   }
 
   /*
   * Compute size of one object, default implementation.
   */
   template <typename T>
   inline MemoryCounter& MemoryCounter::operator & (T& data)
   {  
      serialize(*this, data, version_); 
      return *this;
   }
 
   /*
   * Compute size of a fixed size array via operator <<.
   */
   template <typename T, size_t N>
   inline MemoryCounter& MemoryCounter::operator << (T (& data)[N])
   {   
      for (size_t i = 0; i < N; ++i) {
         serialize(*this, data[i], version_); 
      }
      return *this;
   }
 
   /*
   * Compute size of a fixed size array via operator &.
   */
   template <typename T, size_t N>
   inline MemoryCounter& MemoryCounter::operator & (T (& data)[N])
   {   
      for (size_t i = 0; i < N; ++i) {
         serialize(*this, data[i], version_); 
      }
      return *this;
   }
 
   // Inline method templates
 
   /*
   * Compute size of one object.
   */
   template <typename T>
   inline void MemoryCounter::count(const T& data)
   {  size_ += sizeof(T); }
 
   /*
   * Bitwise pack a C-array of objects of type T.
   */
   template <typename T>
   inline void MemoryCounter::count(T* array, int n)
   {  size_ += n*sizeof(T); }
 
 
   // Explicit specializations of serialize function
 
   // Serialize functions for primitive C++ types
 
   /*
   * Compute size of an bool.
   */
   template <>
   inline void serialize(MemoryCounter& ar, bool& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of a char.
   */
   template <>
   inline void serialize(MemoryCounter& ar, char& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of an unsigned int.
   */
   template <>
   inline void serialize(MemoryCounter& ar, unsigned int& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of an int.
   */
   template <>
   inline void serialize(MemoryCounter& ar, int& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of an unsigned long int.
   */
   template <>
   inline void serialize(MemoryCounter& ar, unsigned long& data,  
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of a long int.
   */
   template <>
   inline void serialize(MemoryCounter& ar, long& data,  
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of a float.
   */
   template <>
   inline void serialize(MemoryCounter& ar, float& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of a double.
   */
   template <>
   inline void serialize(MemoryCounter& ar, double& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
   // Serialize functions for std library types
 
   /*
   * Compute size of a std::complex<float>.
   */
   template <>
   inline void serialize(MemoryCounter& ar, std::complex<float>& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of a std::complex<double>.
   */
   template <>
   inline void serialize(MemoryCounter& ar, std::complex<double>& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of a std::string.
   */
   template <>
   inline void serialize(MemoryCounter& ar, std::string& data, 
                         const unsigned int version)
   {  ar.size_ += sizeof(size_t) + (data.size() + 1)*sizeof(char); }
 
   // Serialize functions for Util namespace types
 
   /*
   * Compute size of a Util::Vector.
   */
   template <>
   inline void serialize(MemoryCounter& ar, Vector& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
   /*
   * Compute size of a Util::IntVector.
   */
   template <>
   inline void serialize(MemoryCounter& ar, IntVector& data, 
                         const unsigned int version)
   {  ar.count(data); }
 
}
#endif