Teuchos_SerializationTraitsHelpers.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_HELPERS_HPP
#define TEUCHOS_SERIALIZATION_TRAITS_HELPERS_HPP

#include "Teuchos_SerializationTraits.hpp"
#include "Teuchos_ArrayView.hpp"

namespace Teuchos {

template <typename Ordinal, typename T>
class ValueTypeSerializationBuffer {
public:
  ValueTypeSerializationBuffer(
    const Ordinal count, T buffer[] 
    );
  ~ValueTypeSerializationBuffer();
  char* getCharBuffer() const;
  Ordinal getBytes() const;
  const ArrayView<char> getCharBufferView() const;
private:
  Ordinal    count_;
  T          *buffer_;
  Ordinal    bytes_;
  char       *charBuffer_;
  // Not defined and not to be called
  ValueTypeSerializationBuffer();
  ValueTypeSerializationBuffer(const ValueTypeSerializationBuffer&);
  ValueTypeSerializationBuffer& operator=(const ValueTypeSerializationBuffer&);
};

template <typename Ordinal, typename T>
class ConstValueTypeSerializationBuffer {
public:
  ConstValueTypeSerializationBuffer(
    const Ordinal count, const T buffer[]
    );
  ~ConstValueTypeSerializationBuffer();
  const char* getCharBuffer() const;
  Ordinal getBytes() const;
  const ArrayView<const char> getCharBufferView() const;
private:
  Ordinal    count_;
  const T    *buffer_;
  Ordinal    bytes_;
  const char *charBuffer_;
  // Not defined and not to be called
  ConstValueTypeSerializationBuffer();
  ConstValueTypeSerializationBuffer(const ConstValueTypeSerializationBuffer&);
  ConstValueTypeSerializationBuffer& operator=(const ConstValueTypeSerializationBuffer&);
};

template <typename Ordinal, typename T>
class ValueTypeDeserializationBuffer {
public:
  ValueTypeDeserializationBuffer(
    const Ordinal bytes, char charBuffer[] 
    );
  ~ValueTypeDeserializationBuffer();
  T* getBuffer() const;
  Ordinal getCount() const;
private:
  Ordinal    bytes_;
  char       *charBuffer_;
  Ordinal    count_;
  T          *buffer_;
  // Not defined and not to be called
  ValueTypeDeserializationBuffer();
  ValueTypeDeserializationBuffer(const ValueTypeDeserializationBuffer&);
  ValueTypeDeserializationBuffer& operator=(const ValueTypeDeserializationBuffer&);
};

template <typename Ordinal, typename T>
class ConstValueTypeDeserializationBuffer {
public:
  ConstValueTypeDeserializationBuffer(
    const Ordinal bytes, const char charBuffer[]
    );
  ~ConstValueTypeDeserializationBuffer();
  const T* getBuffer() const;
  Ordinal getCount() const;
private:
  Ordinal    bytes_;
  const char *charBuffer_;
  Ordinal    count_;
  const T    *buffer_;
  // Not defined and not to be called
  ConstValueTypeDeserializationBuffer();
  ConstValueTypeDeserializationBuffer(const ConstValueTypeDeserializationBuffer&);
  ConstValueTypeDeserializationBuffer& operator=(const ConstValueTypeDeserializationBuffer&);
};

// /////////////////////////////////////
// Template implementations

//
// ValueTypeSerializationBuffer
//
// ToDo: Update this implementation to handle objects with indirect
// serialization when needed!
//

template <typename Ordinal, typename T>
ValueTypeSerializationBuffer<Ordinal,T>::ValueTypeSerializationBuffer(
  const Ordinal count, T buffer[]
  )
  :count_(count), buffer_(buffer)
{
  typedef SerializationTraits<Ordinal,T> SerT;
  bytes_ = SerT::fromCountToDirectBytes(count_);
  charBuffer_ = SerT::convertToCharPtr(buffer_);
  // ToDo: Handle indirect serailization!
}

template <typename Ordinal, typename T>
ValueTypeSerializationBuffer<Ordinal,T>::~ValueTypeSerializationBuffer()
{
  // There is nothing to do since the type uses direct serialization!
  // ToDo: Handle indirect serailization!
}

template <typename Ordinal, typename T>
char* ValueTypeSerializationBuffer<Ordinal,T>::getCharBuffer() const
{
  return charBuffer_;
}

template <typename Ordinal, typename T>
Ordinal ValueTypeSerializationBuffer<Ordinal,T>::getBytes() const
{
  return bytes_;
}


template <typename Ordinal, typename T>
const ArrayView<char>
ValueTypeSerializationBuffer<Ordinal,T>::getCharBufferView() const
{
  return arrayView(charBuffer_, bytes_);
}


//
// ConstValueTypeSerializationBuffer
//
// ToDo: Update this implementation to handle objects with indirect
// serialization when needed!
//

template <typename Ordinal, typename T>
ConstValueTypeSerializationBuffer<Ordinal,T>::ConstValueTypeSerializationBuffer(
  const Ordinal count, const T buffer[]
  )
  :count_(count), buffer_(buffer)
{
  typedef SerializationTraits<Ordinal,T> SerT;
  bytes_ = SerT::fromCountToDirectBytes(count_);
  charBuffer_ = SerT::convertToCharPtr(buffer_);
  // ToDo: Handle indirect serailization!
}

template <typename Ordinal, typename T>
ConstValueTypeSerializationBuffer<Ordinal,T>::~ConstValueTypeSerializationBuffer()
{
  // There is nothing to do since the type uses direct serialization!
  // ToDo: Handle indirect serailization!
}

template <typename Ordinal, typename T>
const char* ConstValueTypeSerializationBuffer<Ordinal,T>::getCharBuffer() const
{
  return charBuffer_;
}

template <typename Ordinal, typename T>
Ordinal ConstValueTypeSerializationBuffer<Ordinal,T>::getBytes() const
{
  return bytes_;
}

template <typename Ordinal, typename T>
const ArrayView<const char>
ConstValueTypeSerializationBuffer<Ordinal,T>::getCharBufferView() const
{
  return arrayView(charBuffer_, bytes_);
}

//
// ValueTypeDeserializationBuffer
//
// ToDo: Update this implementation to handle objects with indirect
// serialization when needed!
//

template <typename Ordinal, typename T>
ValueTypeDeserializationBuffer<Ordinal,T>::ValueTypeDeserializationBuffer(
  const Ordinal bytes, char charBuffer[]
  )
  :bytes_(bytes), charBuffer_(charBuffer)
{
  typedef SerializationTraits<Ordinal,T> SerT;
  count_ = SerT::fromDirectBytesToCount(bytes_);
  buffer_ = SerT::convertFromCharPtr(charBuffer_);
  // ToDo: Handle indirect serailization!
}

template <typename Ordinal, typename T>
ValueTypeDeserializationBuffer<Ordinal,T>::~ValueTypeDeserializationBuffer()
{
  // There is nothing to do since the type uses direct serialization!
  // ToDo: Handle indirect serailization!
}

template <typename Ordinal, typename T>
T* ValueTypeDeserializationBuffer<Ordinal,T>::getBuffer() const
{
  return buffer_;
}

template <typename Ordinal, typename T>
Ordinal ValueTypeDeserializationBuffer<Ordinal,T>::getCount() const
{
  return count_;
}

//
// ConstValueTypeDeserializationBuffer
//
// ToDo: Update this implementation to handle objects with indirect
// serialization when needed!
//

template <typename Ordinal, typename T>
ConstValueTypeDeserializationBuffer<Ordinal,T>::ConstValueTypeDeserializationBuffer(
  const Ordinal bytes, const char charBuffer[]
  )
  :bytes_(bytes), charBuffer_(charBuffer)
{
  typedef SerializationTraits<Ordinal,T> SerT;
  count_ = SerT::fromDirectBytesToCount(bytes_);
  buffer_ = SerT::convertFromCharPtr(charBuffer_);
  // ToDo: Handle indirect serailization!
}

template <typename Ordinal, typename T>
ConstValueTypeDeserializationBuffer<Ordinal,T>::~ConstValueTypeDeserializationBuffer()
{
  // There is nothing to do since the type uses direct serialization!
  // ToDo: Handle indirect serailization!
}

template <typename Ordinal, typename T>
const T* ConstValueTypeDeserializationBuffer<Ordinal,T>::getBuffer() const
{
  return buffer_;
}

template <typename Ordinal, typename T>
Ordinal ConstValueTypeDeserializationBuffer<Ordinal,T>::getCount() const
{
  return count_;
}

} // namespace Teuchos

#endif // TEUCHOS_SERIALIZATION_TRAITS_HELPERS_HPP