Teuchos_SerializationTraits.hpp

// @HEADER
// ***********************************************************************
// 
//                    Teuchos: Common Tools Package
//                 Copyright (2004) 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.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef TEUCHOS_SERIALIZATION_TRAITS_HPP
#define TEUCHOS_SERIALIZATION_TRAITS_HPP

#include "Teuchos_ConfigDefs.hpp"

namespace Teuchos {

template<typename T>
struct UndefinedSerializationTraits {
  static inline T notDefined() {return(T::this_type_is_missing_a_specialization());};
};

template <typename Ordinal, typename T>
class SerializationTraits {
public:
  


  static const bool supportsDirectSerialization = false;




  static Ordinal fromCountToDirectBytes(const Ordinal count) { UndefinedSerializationTraits<T>::notDefined(); return 0; }

  static char* convertToCharPtr( T* ptr ) { UndefinedSerializationTraits<T>::notDefined(); return 0; }

  static const char* convertToCharPtr( const T* ptr ) { UndefinedSerializationTraits<T>::notDefined(); return 0; }

  static Ordinal fromDirectBytesToCount(const Ordinal bytes) { UndefinedSerializationTraits<T>::notDefined(); return 0; }

  static T* convertFromCharPtr( char* ptr ) { UndefinedSerializationTraits<T>::notDefined(); return 0; }

  static const T* convertFromCharPtr( const char* ptr ) { UndefinedSerializationTraits<T>::notDefined(); return 0; }




  static Ordinal fromCountToIndirectBytes(const Ordinal count) { UndefinedSerializationTraits<T>::notDefined(); return 0; }

  static void serialize(
    const Ordinal count, const T buffer[], const Ordinal bytes, char charBuffer[]
    )
    { UndefinedSerializationTraits<T>::notDefined(); }

  static Ordinal fromIndirectBytesToCount(const Ordinal bytes) { UndefinedSerializationTraits<T>::notDefined(); return 0; }

  static void deserialize(
    const Ordinal bytes, const char charBuffer[], const Ordinal count, T buffer[]
    )
    { UndefinedSerializationTraits<T>::notDefined(); }
  

};

template <typename Ordinal, typename T>
class DirectSerializationTraits {
public:
  static const bool supportsDirectSerialization = true;
  // Direct serialization
  static Ordinal fromCountToDirectBytes(const Ordinal count)
    { return sizeof(T)*count; }
  static char* convertToCharPtr( T* ptr )
    { return reinterpret_cast<char*>(ptr); }
  static const char* convertToCharPtr( const T* ptr )
    { return reinterpret_cast<const char*>(ptr); }
  static Ordinal fromDirectBytesToCount(const Ordinal count)
    { return count/sizeof(T); }
  static T* convertFromCharPtr( char* ptr )
    { return reinterpret_cast<T*>(ptr); }
  static const T* convertFromCharPtr( const char* ptr )
    { return reinterpret_cast<const T*>(ptr); }
  // Indirect serialization
  static Ordinal fromCountToIndirectBytes(const Ordinal count)
    { return fromCountToDirectBytes(count); }
  static void serialize(
    const Ordinal count, const T buffer[], const Ordinal bytes, char charBuffer[]
    )
    {
#ifdef TEUCHOS_DEBUG
      TEST_FOR_EXCEPT(bytes!=fromCountToIndirectBytes(count));
#endif
      const char *_buffer = convertToCharPtr(buffer);
      std::copy(_buffer,_buffer+bytes,charBuffer);
    }
  static Ordinal fromIndirectBytesToCount(const Ordinal bytes) 
    { return fromDirectBytesToCount(bytes); }
  static void deserialize(
    const Ordinal bytes, const char charBuffer[], const Ordinal count, T buffer[]
    )
    {
#ifdef TEUCHOS_DEBUG
      TEST_FOR_EXCEPT(count!=fromIndirectBytesToCount(bytes));
#endif
      char *_buffer = convertToCharPtr(buffer);
      std::copy(charBuffer,charBuffer+bytes,_buffer);
    }
};

template<typename Ordinal>
class SerializationTraits<Ordinal,char>
  : public DirectSerializationTraits<Ordinal,char>
{};

template<typename Ordinal>
class SerializationTraits<Ordinal,int>
  : public DirectSerializationTraits<Ordinal,int>
{};

template<typename Ordinal>
class SerializationTraits<Ordinal,float>
  : public DirectSerializationTraits<Ordinal,float>
{};

template<typename Ordinal>
class SerializationTraits<Ordinal,double>
  : public DirectSerializationTraits<Ordinal,double>
{};

#if defined(HAVE_COMPLEX) && defined(HAVE_TEUCHOS_COMPLEX)

template<typename Ordinal>
class SerializationTraits<Ordinal,std::complex<float> >
  : public DirectSerializationTraits<Ordinal,std::complex<float> >
{};

template<typename Ordinal>
class SerializationTraits<Ordinal,std::complex<double> >
  : public DirectSerializationTraits<Ordinal,std::complex<double> >
{};

#endif // defined(HAVE_COMPLEX) && defined(HAVE_TEUCHOS_COMPLEX)

} // namespace Teuchos

#endif // TEUCHOS_SERIALIZATION_TRAITS_HPP

---