bufferSerialize.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2006 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include "readerWriter/readerWriterDefines.h"
#include <vlutil/vlString.h>
#include <vlutil/vlMachineTypes.h>
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
#include <vlutil/vlFilename.h>
#include <vrfExtProtocol/objectType.h>
#include <vector>
#include <set>
#include <list>
#include <string>
#include "readerWriter/rwBoolean.h"
#include "readerWriter/rwInt.h"
#include "readerWriter/rwIntSized.h"
#include "readerWriter/rwReal.h"
#include "readerWriter/rwRealSized.h"
#include "readerWriter/rwVariableBindings.h"
#include "readerWriter/rwReal.h"
#include "readerWriter/rwStringAttributeList.h"
#include "readerWriter/rwStringAttribute.h"

#include <vlpi/entityIdentifier.h>
#include <vlpi/appearance.h>
#include <vlutil/vlInetAddr.h>

#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>

namespace DtBufferSerialize
{

   DT_DLL_readerWriter char *encode(const DtFilename& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtString& val, char *buffer);
   DT_DLL_readerWriter char *encode(const std::string& val, char *buffer);
   DT_DLL_readerWriter char *encode(const char *val, unsigned nSize, char *buffer);
   DT_DLL_readerWriter char *encode(const int& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtInt16& val, char *buffer);
#ifndef DT_HAVE_64BIT_LONGS
   DT_DLL_readerWriter char *encode(const DtInt32& val, char *buffer);
#endif   
   DT_DLL_readerWriter char *encode(const DtU8& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtU16& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtU32& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtU64& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtFloat32& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtFloat64& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtVector& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtTaitBryan& val, char *buffer);
   DT_DLL_readerWriter char *encode(const bool& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtObjectType& val, char *buffer);
   DT_DLL_readerWriter char *encode(const std::vector<char>& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtRwBoolean& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtEntityType& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtEntityIdentifier& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtSimulationAddress& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtAppearance& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtForceType& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtInetAddr& val, char *buffer);
   DT_DLL_readerWriter char *encode(const DtRwInt& val, char* buffer);
   DT_DLL_readerWriter char *encode(const DtRwVariableBindings& val, char* buffer);
   DT_DLL_readerWriter char *encode(const DtRwStringAttribute& v, char* buffer);
   DT_DLL_readerWriter char *encode(const DtRwStringAttributeList& val, char* buffer);

   template <typename T>
   char* encode(const std::vector<T>& val, char* buffer);
   template <typename T>
   char* encode(const std::set<T>& val, char* buffer);
   template <typename T>
   char* encode(const std::list<T>& val, char* buffer);
   template <typename T1, typename T2>
   char* encode(const std::map<T1, T2>& val, char* buffer);
   template <typename T1, typename T2>
   char* encode(const boost::unordered_map<T1, T2>& val, char* buffer);
   template <typename T1>
   char* encode(const boost::unordered_set<T1>& val, char* buffer);
   template <typename T1, typename T2>
   char* encode(const std::pair<T1, T2>& val, char* buffer);

   //specialized version of decode for std::vector<bool> due to problems with c++
   //standard on how vector<bool> is defined
   DT_DLL_readerWriter char *encode(const std::vector<bool>& val, char *buffer);



   DT_DLL_readerWriter const char *decode(DtString& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(std::string& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtFilename& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(int& val, const char *buffer);
   DT_DLL_readerWriter const char *decode(DtInt16& val, const char *buffer);
#ifndef DT_HAVE_64BIT_LONGS
   DT_DLL_readerWriter const char *decode(DtInt32& val, const char *buffer);
#endif
   DT_DLL_readerWriter const char *decode(DtU8& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtU16& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtU32& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtU64& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtFloat32& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtFloat64& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtVector& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtTaitBryan& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(bool &val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtObjectType &val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(std::vector<char>& val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtRwBoolean &val, const char *buffer) ;
   DT_DLL_readerWriter const char *decode(DtEntityType& val, const char *buffer);
   DT_DLL_readerWriter const char *decode(DtEntityIdentifier& val, const char *buffer);
   DT_DLL_readerWriter const char *decode(DtSimulationAddress& val, const char *buffer);
   DT_DLL_readerWriter const char *decode(DtAppearance& val, const char *buffer);
   DT_DLL_readerWriter const char *decode(DtForceType& val, const char *buffer);
   DT_DLL_readerWriter const char *decode(DtInetAddr& val, const char *buffer);
   DT_DLL_readerWriter const char *decode(DtRwInt& val, const char *buffer);
   DT_DLL_readerWriter const char *decode(DtRwStringAttributeList& v, const char* buffer);
   DT_DLL_readerWriter const char *decode(DtRwStringAttribute& v, const char* buffer);
   DT_DLL_readerWriter const char *decode(DtRwVariableBindings& val, const char *buffer);

   template <typename T>
   const char *decode(std::vector<T>& val, const char *buffer);
   template <typename T>
   const char *decode(std::set<T>& val, const char *buffer);
   template <typename T>
   const char *decode(std::list<T>& val, const char *buffer);
   template <typename T1, typename T2>
   const char *decode(std::map<T1, T2>& val, const char *buffer);
   template <typename T1, typename T2>
   const char *decode(boost::unordered_map<T1, T2>& val, const char *buffer);
   template <typename T1>
   const char *decode(boost::unordered_set<T1>& val, const char *buffer);
   template <typename T1, typename T2>
   const char *decode(std::pair<T1, T2>& val, const char *buffer);

   //specialized version of decode for std::vector<bool> due to problems with c++
   //standard on how vector<bool> is defined
   DT_DLL_readerWriter const char *decode(std::vector<bool>& val, const char *buffer);


   DT_DLL_readerWriter int getSize(const DtString& val) ;
   DT_DLL_readerWriter int getSize(const std::string& val);
   DT_DLL_readerWriter int getSize(const DtFilename& val) ;
   DT_DLL_readerWriter int getSize(const DtVector& v) ;
   DT_DLL_readerWriter int getSize(const int& v);
   DT_DLL_readerWriter int getSize(const DtInt16& v);
#ifndef DT_HAVE_64BIT_LONGS
   DT_DLL_readerWriter int getSize(const DtInt32& v);
#endif
   DT_DLL_readerWriter int getSize(const DtU8& v) ;
   DT_DLL_readerWriter int getSize(const DtU16& v) ;
   DT_DLL_readerWriter int getSize(const DtU32& v) ;
   DT_DLL_readerWriter int getSize(const DtU64& v) ;
   DT_DLL_readerWriter int getSize(const DtFloat32& v) ;
   DT_DLL_readerWriter int getSize(const DtFloat64& v) ;
   DT_DLL_readerWriter int getSize(const bool&v) ;
   DT_DLL_readerWriter int getSize(const DtObjectType& v) ;
   DT_DLL_readerWriter int getSize(const DtTaitBryan& v) ;
   DT_DLL_readerWriter int getSize(const std::vector<char>& v) ;
   DT_DLL_readerWriter int getSize(const DtRwBoolean& v) ;
   DT_DLL_readerWriter int getSize(const DtEntityType& v);
   DT_DLL_readerWriter int getSize(const DtEntityIdentifier& v);
   DT_DLL_readerWriter int getSize(const DtSimulationAddress& v);
   DT_DLL_readerWriter int getSize(const DtAppearance& v);
   DT_DLL_readerWriter int getSize(const DtForceType& v);
   DT_DLL_readerWriter int getSize(const DtInetAddr& v);
   DT_DLL_readerWriter int getSize(const DtRwInt& v);
   DT_DLL_readerWriter int getSize(const DtRwVariableBindings& v);
   DT_DLL_readerWriter int getSize(const DtRwStringAttributeList& v);
   DT_DLL_readerWriter int getSize(const DtRwStringAttribute& v);

   template <typename T>
   int getSize(const std::vector<T>& v) ;
   template <typename T>
   int getSize(const std::list<T>& v) ;
   template <typename T1, typename T2>
   int getSize(const std::map<T1, T2>& v) ;
   template <typename T1, typename T2>
   int getSize(const boost::unordered_map<T1, T2>& v) ;
   template <typename T1>
   int getSize(const boost::unordered_set<T1>& v) ;
   template <typename T1, typename T2>
   int getSize(const std::pair<T1, T2>& v) ;
   template <typename T>
   int getSize(const std::set<T>& v) ;

   //specialized version of decode for std::vector<bool> due to problems with c++
   //standard on how vector<bool> is defined
   DT_DLL_readerWriter int getSize(const std::vector<bool>& v);
}

#define bufferSerialize_INL_
#include "readerWriter/bufferSerialize.inl"
#undef bufferSerialize_INL_