Teuchos_SerializationTraitsHelpers.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef TEUCHOS_SERIALIZATION_TRAITS_HELPERS_HPP
#define TEUCHOS_SERIALIZATION_TRAITS_HELPERS_HPP

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

namespace Teuchos {

template <typename Ordinal, typename T>
class DefaultSerializer {
public:
  typedef SerializationTraits<Ordinal,T> DefaultSerializerType;

  static DefaultSerializerType getDefaultSerializer() {
    DefaultSerializerType s;
    return s;
  }

  static Teuchos::RCP<DefaultSerializerType> getDefaultSerializerRCP() {
    return Teuchos::rcp (new DefaultSerializerType ());
  }
};

template <typename Ordinal, typename T, typename Serializer,
          bool direct = Serializer::supportsDirectSerialization>
class ValueTypeSerializationBufferImp {};

template <typename Ordinal, typename T, typename Serializer,
          bool direct = Serializer::supportsDirectSerialization>
class ConstValueTypeSerializationBufferImp {};

template <typename Ordinal, typename T, typename Serializer,
          bool direct = Serializer::supportsDirectSerialization>
class ValueTypeDeserializationBufferImp {};

template <typename Ordinal, typename T, typename Serializer,
          bool direct = Serializer::supportsDirectSerialization>
class ConstValueTypeDeserializationBufferImp {};

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

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

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

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

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

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

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

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


template <typename Ordinal, typename T,
          typename Serializer = typename DefaultSerializer<Ordinal,T>::DefaultSerializerType>
class ValueTypeSerializationBuffer :
    public ValueTypeSerializationBufferImp<Ordinal,T,Serializer> {
public:
  typedef ValueTypeSerializationBufferImp<Ordinal,T,Serializer> Base;
  ValueTypeSerializationBuffer(
    const Ordinal count, T buffer[],
    const RCP<const Serializer>& serializer
    ) : Base(count,buffer,serializer) {}
};

template <typename Ordinal, typename T,
          typename Serializer = typename DefaultSerializer<Ordinal,T>::DefaultSerializerType>
class ConstValueTypeSerializationBuffer :
    public ConstValueTypeSerializationBufferImp<Ordinal,T,Serializer> {
public:
  typedef ConstValueTypeSerializationBufferImp<Ordinal,T,Serializer> Base;
  ConstValueTypeSerializationBuffer(
    const Ordinal count, const T buffer[],
    const RCP<const Serializer>& serializer
    ) : Base(count,buffer,serializer) {}
};

template <typename Ordinal, typename T,
          typename Serializer = typename DefaultSerializer<Ordinal,T>::DefaultSerializerType>
class ValueTypeDeserializationBuffer :
    public ValueTypeDeserializationBufferImp<Ordinal,T,Serializer> {
public:
  typedef ValueTypeDeserializationBufferImp<Ordinal,T,Serializer> Base;
  ValueTypeDeserializationBuffer(
    const Ordinal bytes, char charBuffer[],
    const RCP<const Serializer>& serializer
    ) : Base(bytes,charBuffer,serializer) {}
};

template <typename Ordinal, typename T,
          typename Serializer = typename DefaultSerializer<Ordinal,T>::DefaultSerializerType>
class ConstValueTypeDeserializationBuffer :
    public ConstValueTypeDeserializationBufferImp<Ordinal,T,Serializer> {
public:
  typedef ConstValueTypeDeserializationBufferImp<Ordinal,T,Serializer> Base;
  ConstValueTypeDeserializationBuffer(
    const Ordinal bytes, const char charBuffer[],
    const RCP<const Serializer>& serializer
    ) : Base(bytes,charBuffer,serializer) {}
};

template <typename Ordinal, typename T>
class ValueTypeSerializationBuffer<Ordinal,T,typename DefaultSerializer<Ordinal,T>::DefaultSerializerType> :
    public ValueTypeSerializationBufferImp<Ordinal,T,typename DefaultSerializer<Ordinal,T>::DefaultSerializerType> {
public:
  typedef DefaultSerializer<Ordinal,T> DS;  // work around for parsing bug in gcc 4.1-4.2
  typedef typename DS::DefaultSerializerType Serializer;
  typedef ValueTypeSerializationBufferImp<Ordinal,T,Serializer> Base;
  ValueTypeSerializationBuffer(
    const Ordinal count, T buffer[],
    const RCP<const Serializer>& serializer = DS::getDefaultSerializerRCP()
    ) : Base(count,buffer,serializer) {}
};

template <typename Ordinal, typename T>
class ConstValueTypeSerializationBuffer<Ordinal,T,typename DefaultSerializer<Ordinal,T>::DefaultSerializerType> :
    public ConstValueTypeSerializationBufferImp<Ordinal,T,typename DefaultSerializer<Ordinal,T>::DefaultSerializerType> {
public:
  typedef DefaultSerializer<Ordinal,T> DS;  // work around for parsing bug in gcc 4.1-4.2
  typedef typename DS::DefaultSerializerType Serializer;
  typedef ConstValueTypeSerializationBufferImp<Ordinal,T,Serializer> Base;
  ConstValueTypeSerializationBuffer(
    const Ordinal count, const T buffer[],
    const RCP<const Serializer>& serializer = DS::getDefaultSerializerRCP()
    ) : Base(count,buffer,serializer) {}
};

template <typename Ordinal, typename T>
class ValueTypeDeserializationBuffer<Ordinal,T,typename DefaultSerializer<Ordinal,T>::DefaultSerializerType> :
    public ValueTypeDeserializationBufferImp<Ordinal,T,typename DefaultSerializer<Ordinal,T>::DefaultSerializerType> {
public:
  typedef DefaultSerializer<Ordinal,T> DS;  // work around for parsing bug in gcc 4.1-4.2
  typedef typename DS::DefaultSerializerType Serializer;
  typedef ValueTypeDeserializationBufferImp<Ordinal,T,Serializer> Base;
  ValueTypeDeserializationBuffer(
    const Ordinal bytes, char charBuffer[],
    const RCP<const Serializer>& serializer = DS::getDefaultSerializerRCP()
    ) : Base(bytes,charBuffer,serializer) {}
};

template <typename Ordinal, typename T>
class ConstValueTypeDeserializationBuffer<Ordinal,T,typename DefaultSerializer<Ordinal,T>::DefaultSerializerType> :
    public ConstValueTypeDeserializationBufferImp<Ordinal,T,typename DefaultSerializer<Ordinal,T>::DefaultSerializerType> {
public:
  typedef DefaultSerializer<Ordinal,T> DS;  // work around for parsing bug in gcc 4.1-4.2
  typedef typename DS::DefaultSerializerType Serializer;
  typedef ConstValueTypeDeserializationBufferImp<Ordinal,T,Serializer> Base;
  ConstValueTypeDeserializationBuffer(
    const Ordinal bytes, const char charBuffer[],
    const RCP<const Serializer>& serializer = DS::getDefaultSerializerRCP()
    ) : Base(bytes,charBuffer,serializer) {}
};

// /////////////////////////////////////
// Template implementations for direct serialization

//
// ValueTypeSerializationBufferImp
//

template <typename Ordinal, typename T, typename Serializer>
ValueTypeSerializationBufferImp<Ordinal,T,Serializer,true>::
ValueTypeSerializationBufferImp(
  const Ordinal count, T buffer[], const RCP<const Serializer>& serializer
  )
  :count_(count), buffer_(buffer), serializer_(serializer)
{
  bytes_ = serializer_->fromCountToDirectBytes(count_);
  charBuffer_ = serializer_->convertToCharPtr(buffer_);
}

template <typename Ordinal, typename T, typename Serializer>
ValueTypeSerializationBufferImp<Ordinal,T,Serializer,true>::
~ValueTypeSerializationBufferImp()
{
  // There is nothing to do since the type uses direct serialization!
}

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

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


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


//
// ConstValueTypeSerializationBufferImp
//

template <typename Ordinal, typename T, typename Serializer>
ConstValueTypeSerializationBufferImp<Ordinal,T,Serializer,true>::
ConstValueTypeSerializationBufferImp(
  const Ordinal count, const T buffer[], const RCP<const Serializer>& serializer
  )
  :count_(count), buffer_(buffer), serializer_(serializer)
{
  bytes_ = serializer_->fromCountToDirectBytes(count_);
  charBuffer_ = serializer_->convertToCharPtr(buffer_);
}

template <typename Ordinal, typename T, typename Serializer>
ConstValueTypeSerializationBufferImp<Ordinal,T,Serializer,true>::
~ConstValueTypeSerializationBufferImp()
{
  // There is nothing to do since the type uses direct serialization!
}

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

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

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

//
// ValueTypeDeserializationBufferImp
//

template <typename Ordinal, typename T, typename Serializer>
ValueTypeDeserializationBufferImp<Ordinal,T,Serializer,true>::
ValueTypeDeserializationBufferImp(
  const Ordinal bytes, char charBuffer[], const RCP<const Serializer>& serializer
  )
  :bytes_(bytes), charBuffer_(charBuffer), serializer_(serializer)
{
  count_ = serializer_->fromDirectBytesToCount(bytes_);
  buffer_ = serializer_->convertFromCharPtr(charBuffer_);
}

template <typename Ordinal, typename T, typename Serializer>
ValueTypeDeserializationBufferImp<Ordinal,T,Serializer,true>::
~ValueTypeDeserializationBufferImp()
{
  // There is nothing to do since the type uses direct serialization!
}

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

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

//
// ConstValueTypeDeserializationBufferImp
//

template <typename Ordinal, typename T, typename Serializer>
ConstValueTypeDeserializationBufferImp<Ordinal,T,Serializer,true>::
ConstValueTypeDeserializationBufferImp(
  const Ordinal bytes, const char charBuffer[], const RCP<const Serializer>& serializer
  )
  :bytes_(bytes), charBuffer_(charBuffer), serializer_(serializer)
{
  count_ = serializer_->fromDirectBytesToCount(bytes_);
  buffer_ = serializer_->convertFromCharPtr(charBuffer_);
}

template <typename Ordinal, typename T, typename Serializer>
ConstValueTypeDeserializationBufferImp<Ordinal,T,Serializer,true>::
~ConstValueTypeDeserializationBufferImp()
{
  // There is nothing to do since the type uses direct serialization!
}

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

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


// /////////////////////////////////////
// Template implementations for indirect specializations

//
// ValueTypeSerializationBufferImp
//

template <typename Ordinal, typename T, typename Serializer>
ValueTypeSerializationBufferImp<Ordinal,T,Serializer,false>::
ValueTypeSerializationBufferImp(
  const Ordinal count, T buffer[], const RCP<const Serializer>& serializer
  )
  :count_(count), buffer_(buffer), serializer_(serializer)
{
  bytes_ = serializer_->fromCountToIndirectBytes(count_, buffer_);
  charBuffer_.resize(bytes_);
  serializer_->serialize(count_, buffer_, bytes_, &charBuffer_[0]);
}

template <typename Ordinal, typename T, typename Serializer>
ValueTypeSerializationBufferImp<Ordinal,T,Serializer,false>::
~ValueTypeSerializationBufferImp()
{
  serializer_->deserialize(bytes_, &charBuffer_[0], count_, buffer_);
}

template <typename Ordinal, typename T, typename Serializer>
char* ValueTypeSerializationBufferImp<Ordinal,T,Serializer,false>::
getCharBuffer() const
{
  return &charBuffer_[0];
}

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

template <typename Ordinal, typename T, typename Serializer>
const ArrayView<char>
ValueTypeSerializationBufferImp<Ordinal,T,Serializer,false>::
getCharBufferView() const
{
  return charBuffer_.view(0, bytes_);
}


//
// ConstValueTypeSerializationBufferImp
//

template <typename Ordinal, typename T, typename Serializer>
ConstValueTypeSerializationBufferImp<Ordinal,T,Serializer,false>::
ConstValueTypeSerializationBufferImp(
  const Ordinal count, const T buffer[], const RCP<const Serializer>& serializer
  )
  :count_(count), buffer_(buffer), serializer_(serializer)
{
  bytes_ = serializer_->fromCountToIndirectBytes(count_, buffer_);
  charBuffer_.resize(bytes_);
  serializer_->serialize(count_, buffer_, bytes_, &charBuffer_[0]);
}

template <typename Ordinal, typename T, typename Serializer>
ConstValueTypeSerializationBufferImp<Ordinal,T,Serializer,false>::
~ConstValueTypeSerializationBufferImp()
{
}

template <typename Ordinal, typename T, typename Serializer>
const char* ConstValueTypeSerializationBufferImp<Ordinal,T,Serializer,false>::
getCharBuffer() const
{
  return &charBuffer_[0];
}

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

template <typename Ordinal, typename T, typename Serializer>
const ArrayView<const char>
ConstValueTypeSerializationBufferImp<Ordinal,T,Serializer,false>::
getCharBufferView() const
{
  return charBuffer_.view(0, bytes_);
}

//
// ValueTypeDeserializationBufferImp
//

template <typename Ordinal, typename T, typename Serializer>
ValueTypeDeserializationBufferImp<Ordinal,T,Serializer,false>::
ValueTypeDeserializationBufferImp(
  const Ordinal bytes, char charBuffer[], const RCP<const Serializer>& serializer
  )
  :bytes_(bytes), charBuffer_(charBuffer), serializer_(serializer)
{
  count_ = serializer_->fromIndirectBytesToCount(bytes_, charBuffer_);
  buffer_.resize(count_);
  serializer_->deserialize(bytes_, charBuffer_, count_, &buffer_[0]);
}

template <typename Ordinal, typename T, typename Serializer>
ValueTypeDeserializationBufferImp<Ordinal,T,Serializer,false>::
~ValueTypeDeserializationBufferImp()
{
  serializer_->serialize(count_, &buffer_[0], bytes_, charBuffer_);
}

template <typename Ordinal, typename T, typename Serializer>
T* ValueTypeDeserializationBufferImp<Ordinal,T,Serializer,false>::
getBuffer() const
{
  return &buffer_[0];
}

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

//
// ConstValueTypeDeserializationBufferImp
//

template <typename Ordinal, typename T, typename Serializer>
ConstValueTypeDeserializationBufferImp<Ordinal,T,Serializer,false>::
ConstValueTypeDeserializationBufferImp(
  const Ordinal bytes, const char charBuffer[], const RCP<const Serializer>& serializer
  )
  :bytes_(bytes), charBuffer_(charBuffer), serializer_(serializer)
{
  count_ = serializer_->fromIndirectBytesToCount(bytes_, charBuffer_);
  buffer_.resize(count_);
  serializer_->deserialize(bytes_, charBuffer_, count_, &buffer_[0]);
}

template <typename Ordinal, typename T, typename Serializer>
ConstValueTypeDeserializationBufferImp<Ordinal,T,Serializer,false>::
~ConstValueTypeDeserializationBufferImp()
{
}

template <typename Ordinal, typename T, typename Serializer>
const T* ConstValueTypeDeserializationBufferImp<Ordinal,T,Serializer,false>::
getBuffer() const
{
  return &buffer_[0];
}

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

} // namespace Teuchos

#endif // TEUCHOS_SERIALIZATION_TRAITS_HELPERS_HPP