source: Sophya/trunk/SophyaLib/BaseTools/ppftpointerio.h@ 2661

// This may look like C code, but it is really -*- C++ -*-
//  Classe pour faciliter entree-sortie PPF pour des pointeurs
//       R. Ansari -  Mars 2005

#ifndef PPFTPOINTERIO_H_SEEN
#define PPFTPOINTERIO_H_SEEN

#include "ppersist.h"

//----------------------------------------------------------------------
namespace SOPHYA {

/*!
  \class SOPHYA::PPF_TPointer_IO
  \ingroup BaseTools
  A template utility class with static methods to ease handling of array 
  I/O in PPF streams (POutPersist and PInPersist). It is not intented for
  direct use in user programs, but for writing PPF persistence handler 
  classes (PPersist). 
  The C++ I/O operators POutPersist& << and PInPersist& >> should be defined for
  new types and classes.
*/

template <class T>
class PPF_TPointer_IO {
public:
  //! Writes the array pointed to by \b arr (size \b n) to POutPersist stream \b os
  static void Write(POutPersist & os,  T  const * arr, size_t n)
  {
    for(size_t k=0; k<n; k++) os << arr[k];
  }
  //! Reads from the PInPersist \b is into array pointed to by \b arr (size \b n)
  static void Read(PInPersist & is, T * arr, size_t n)
  {
    for(size_t k=0; k<n; k++) is >> arr[k];
  }
};
// Specific implementation using table I/O in PPFBinaryIOStreams 
void PPF_TPointer_IO<char>::Write(POutPersist & os, char const * arr, size_t n)
  { os.PutBytes(arr,n); }
void PPF_TPointer_IO<char>::Read(PInPersist & is, char * arr, size_t n)
  { is.GetBytes(arr,n); }

void PPF_TPointer_IO< int_1 >::Write(POutPersist & os, int_1 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< int_1 >::Read(PInPersist & is, int_1 * arr, size_t n)
  { is.Get(arr,n); }
void PPF_TPointer_IO< uint_1 >::Write(POutPersist & os, uint_1 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< uint_1 >::Read(PInPersist & is, uint_1 * arr, size_t n)
  { is.Get(arr,n); }

void PPF_TPointer_IO< int_2 >::Write(POutPersist & os, int_2 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< int_2 >::Read(PInPersist & is, int_2 * arr, size_t n)
  { is.Get(arr,n); }
void PPF_TPointer_IO< uint_2 >::Write(POutPersist & os, uint_2 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< uint_2 >::Read(PInPersist & is, uint_2 * arr, size_t n)
  { is.Get(arr,n); }

void PPF_TPointer_IO< int_4 >::Write(POutPersist & os, int_4 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< int_4 >::Read(PInPersist & is, int_4 * arr, size_t n)
  { is.Get(arr,n); }
void PPF_TPointer_IO< uint_4 >::Write(POutPersist & os, uint_4 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< uint_4 >::Read(PInPersist & is, uint_4 * arr, size_t n)
  { is.Get(arr,n); }

void PPF_TPointer_IO< int_8 >::Write(POutPersist & os,  int_8 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< int_8 >::Read(PInPersist & is, int_8 * arr, size_t n)
  { is.Get(arr,n); }
void PPF_TPointer_IO< uint_8 >::Write(POutPersist & os,  uint_8 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< uint_8 >::Read(PInPersist & is, uint_8 * arr, size_t n)
  { is.Get(arr,n); }


void PPF_TPointer_IO< r_4 >::Write(POutPersist & os, r_4 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< r_4 >::Read(PInPersist & is, r_4 * arr, size_t n)
  { is.Get(arr,n); }

void PPF_TPointer_IO< r_8 >::Write(POutPersist & os,  r_8 const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< r_8 >::Read(PInPersist & is, r_8 * arr, size_t n)
  { is.Get(arr,n); }

void PPF_TPointer_IO< complex<r_4> >::Write(POutPersist & os, complex<r_4> const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< complex<r_4> >::Read(PInPersist & is, complex<r_4> * arr, size_t n)
  { is.Get(arr,n); }

void PPF_TPointer_IO< complex<r_8> >::Write(POutPersist & os, complex<r_8> const * arr, size_t n)
  { os.Put(arr,n); }
void PPF_TPointer_IO< complex<r_8> >::Read(PInPersist & is, complex<r_8> * arr, size_t n)
  { is.Get(arr,n); }


}  // namespace SOPHYA

#endif   /* PPFTPOINTERIO_H_SEEN */