VR-Forces Developer's Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
bufferSerialize.h
Go to the documentation of this file.
1 /*******************************************************************************
2 ** Copyright (c) 2006 MAK Technologies, Inc.
3 ** All rights reserved.
4 *******************************************************************************/
5 
8 
12 
13 #pragma once
14 
15 #include "readerWriter/readerWriterDefines.h"
16 #include <vlutil/vlString.h>
17 #include <vlutil/vlMachineTypes.h>
18 #include <matrix/vlVector.h>
19 #include <matrix/vlTaitBryan.h>
20 #include <vlutil/vlFilename.h>
21 #include <vlpi/entityType.h>
22 #include <vector>
23 #include <set>
24 #include <list>
25 #include <string>
26 #include "readerWriter/rwBoolean.h"
27 #include "readerWriter/rwInt.h"
28 #include "readerWriter/rwIntSized.h"
29 #include "readerWriter/rwReal.h"
30 #include "readerWriter/rwRealSized.h"
31 #include "readerWriter/rwVariableBindings.h"
32 #include "readerWriter/rwReal.h"
33 #include "readerWriter/rwStringAttributeList.h"
34 #include "readerWriter/rwStringAttribute.h"
35 
36 #include <vlpi/entityIdentifier.h>
37 #include <vlpi/appearance.h>
38 #include <vlutil/vlInetAddr.h>
39 
40 #include <boost/unordered_map.hpp>
41 #include <boost/unordered_set.hpp>
42 
48 namespace DtBufferSerialize
49 {
57 
58  DT_DLL_readerWriter char *encode(const DtFilename& val, char *buffer);
59  DT_DLL_readerWriter char *encode(const DtString& val, char *buffer);
60  DT_DLL_readerWriter char *encode(const std::string& val, char *buffer);
61  DT_DLL_readerWriter char *encode(const char *val, unsigned nSize, char *buffer);
62  DT_DLL_readerWriter char *encode(const int& val, char *buffer);
63  DT_DLL_readerWriter char *encode(const DtInt16& val, char *buffer);
64 #ifndef DT_HAVE_64BIT_LONGS
65  DT_DLL_readerWriter char *encode(const DtInt32& val, char *buffer);
66 #endif
67  DT_DLL_readerWriter char *encode(const DtU8& val, char *buffer);
68  DT_DLL_readerWriter char *encode(const DtU16& val, char *buffer);
69  DT_DLL_readerWriter char *encode(const DtU32& val, char *buffer);
70  DT_DLL_readerWriter char *encode(const DtU64& val, char *buffer);
71  DT_DLL_readerWriter char *encode(const DtFloat32& val, char *buffer);
72  DT_DLL_readerWriter char *encode(const DtFloat64& val, char *buffer);
73  DT_DLL_readerWriter char *encode(const DtVector& val, char *buffer);
74  DT_DLL_readerWriter char *encode(const DtTaitBryan& val, char *buffer);
75  DT_DLL_readerWriter char *encode(const bool& val, char *buffer);
76  DT_DLL_readerWriter char *encode(const std::vector<char>& val, char *buffer);
77  DT_DLL_readerWriter char *encode(const DtRwBoolean& val, char *buffer);
78  DT_DLL_readerWriter char *encode(const DtEntityType& val, char *buffer);
79  DT_DLL_readerWriter char *encode(const DtEntityIdentifier& val, char *buffer);
80  DT_DLL_readerWriter char *encode(const DtSimulationAddress& val, char *buffer);
81  DT_DLL_readerWriter char *encode(const DtAppearance& val, char *buffer);
82  DT_DLL_readerWriter char *encode(const DtForceType& val, char *buffer);
83  DT_DLL_readerWriter char *encode(const DtInetAddr& val, char *buffer);
84  DT_DLL_readerWriter char *encode(const DtRwInt& val, char* buffer);
85  DT_DLL_readerWriter char *encode(const DtRwVariableBindings& val, char* buffer);
86  DT_DLL_readerWriter char *encode(const DtRwStringAttribute& v, char* buffer);
87  DT_DLL_readerWriter char *encode(const DtRwStringAttributeList& val, char* buffer);
88 
89  template <typename T>
90  char* encode(const std::vector<T>& val, char* buffer);
91  template <typename T>
92  char* encode(const std::set<T>& val, char* buffer);
93  template <typename T>
94  char* encode(const std::list<T>& val, char* buffer);
95  template <typename T1, typename T2>
96  char* encode(const std::map<T1, T2>& val, char* buffer);
97  template <typename T1, typename T2>
98  char* encode(const boost::unordered_map<T1, T2>& val, char* buffer);
99  template <typename T1>
100  char* encode(const boost::unordered_set<T1>& val, char* buffer);
101  template <typename T1, typename T2>
102  char* encode(const std::pair<T1, T2>& val, char* buffer);
103 
104  //specialized version of decode for std::vector<bool> due to problems with c++
105  //standard on how vector<bool> is defined
106  DT_DLL_readerWriter char *encode(const std::vector<bool>& val, char *buffer);
108 
109 
117 
118  DT_DLL_readerWriter const char *decode(DtString& val, const char *buffer) ;
119  DT_DLL_readerWriter const char *decode(std::string& val, const char *buffer) ;
120  DT_DLL_readerWriter const char *decode(DtFilename& val, const char *buffer) ;
121  DT_DLL_readerWriter const char *decode(int& val, const char *buffer);
122  DT_DLL_readerWriter const char *decode(DtInt16& val, const char *buffer);
123 #ifndef DT_HAVE_64BIT_LONGS
124  DT_DLL_readerWriter const char *decode(DtInt32& val, const char *buffer);
125 #endif
126  DT_DLL_readerWriter const char *decode(DtU8& val, const char *buffer) ;
127  DT_DLL_readerWriter const char *decode(DtU16& val, const char *buffer) ;
128  DT_DLL_readerWriter const char *decode(DtU32& val, const char *buffer) ;
129  DT_DLL_readerWriter const char *decode(DtU64& val, const char *buffer) ;
130  DT_DLL_readerWriter const char *decode(DtFloat32& val, const char *buffer) ;
131  DT_DLL_readerWriter const char *decode(DtFloat64& val, const char *buffer) ;
132  DT_DLL_readerWriter const char *decode(DtVector& val, const char *buffer) ;
133  DT_DLL_readerWriter const char *decode(DtTaitBryan& val, const char *buffer) ;
134  DT_DLL_readerWriter const char *decode(bool &val, const char *buffer) ;
135  DT_DLL_readerWriter const char *decode(std::vector<char>& val, const char *buffer) ;
136  DT_DLL_readerWriter const char *decode(DtRwBoolean &val, const char *buffer) ;
137  DT_DLL_readerWriter const char *decode(DtEntityType& val, const char *buffer);
138  DT_DLL_readerWriter const char *decode(DtEntityIdentifier& val, const char *buffer);
139  DT_DLL_readerWriter const char *decode(DtSimulationAddress& val, const char *buffer);
140  DT_DLL_readerWriter const char *decode(DtAppearance& val, const char *buffer);
141  DT_DLL_readerWriter const char *decode(DtForceType& val, const char *buffer);
142  DT_DLL_readerWriter const char *decode(DtInetAddr& val, const char *buffer);
143  DT_DLL_readerWriter const char *decode(DtRwInt& val, const char *buffer);
144  DT_DLL_readerWriter const char *decode(DtRwStringAttributeList& v, const char* buffer);
145  DT_DLL_readerWriter const char *decode(DtRwStringAttribute& v, const char* buffer);
146  DT_DLL_readerWriter const char *decode(DtRwVariableBindings& val, const char *buffer);
147 
148  template <typename T>
149  const char *decode(std::vector<T>& val, const char *buffer);
150  template <typename T>
151  const char *decode(std::set<T>& val, const char *buffer);
152  template <typename T>
153  const char *decode(std::list<T>& val, const char *buffer);
154  template <typename T1, typename T2>
155  const char *decode(std::map<T1, T2>& val, const char *buffer);
156  template <typename T1, typename T2>
157  const char *decode(boost::unordered_map<T1, T2>& val, const char *buffer);
158  template <typename T1>
159  const char *decode(boost::unordered_set<T1>& val, const char *buffer);
160  template <typename T1, typename T2>
161  const char *decode(std::pair<T1, T2>& val, const char *buffer);
162 
163  //specialized version of decode for std::vector<bool> due to problems with c++
164  //standard on how vector<bool> is defined
165  DT_DLL_readerWriter const char *decode(std::vector<bool>& val, const char *buffer);
166 
170 
171  DT_DLL_readerWriter int getSize(const DtString& val) ;
172  DT_DLL_readerWriter int getSize(const std::string& val);
173  DT_DLL_readerWriter int getSize(const DtFilename& val) ;
174  DT_DLL_readerWriter int getSize(const DtVector& v) ;
175  DT_DLL_readerWriter int getSize(const int& v);
176  DT_DLL_readerWriter int getSize(const DtInt16& v);
177 #ifndef DT_HAVE_64BIT_LONGS
178  DT_DLL_readerWriter int getSize(const DtInt32& v);
179 #endif
180  DT_DLL_readerWriter int getSize(const DtU8& v) ;
181  DT_DLL_readerWriter int getSize(const DtU16& v) ;
182  DT_DLL_readerWriter int getSize(const DtU32& v) ;
183  DT_DLL_readerWriter int getSize(const DtU64& v) ;
184  DT_DLL_readerWriter int getSize(const DtFloat32& v) ;
185  DT_DLL_readerWriter int getSize(const DtFloat64& v) ;
186  DT_DLL_readerWriter int getSize(const bool&v) ;
187  DT_DLL_readerWriter int getSize(const DtTaitBryan& v) ;
188  DT_DLL_readerWriter int getSize(const std::vector<char>& v) ;
189  DT_DLL_readerWriter int getSize(const DtRwBoolean& v) ;
190  DT_DLL_readerWriter int getSize(const DtEntityType& v);
191  DT_DLL_readerWriter int getSize(const DtEntityIdentifier& v);
192  DT_DLL_readerWriter int getSize(const DtSimulationAddress& v);
193  DT_DLL_readerWriter int getSize(const DtAppearance& v);
194  DT_DLL_readerWriter int getSize(const DtForceType& v);
195  DT_DLL_readerWriter int getSize(const DtInetAddr& v);
196  DT_DLL_readerWriter int getSize(const DtRwInt& v);
197  DT_DLL_readerWriter int getSize(const DtRwVariableBindings& v);
198  DT_DLL_readerWriter int getSize(const DtRwStringAttributeList& v);
199  DT_DLL_readerWriter int getSize(const DtRwStringAttribute& v);
200 
201  template <typename T>
202  int getSize(const std::vector<T>& v) ;
203  template <typename T>
204  int getSize(const std::list<T>& v) ;
205  template <typename T1, typename T2>
206  int getSize(const std::map<T1, T2>& v) ;
207  template <typename T1, typename T2>
208  int getSize(const boost::unordered_map<T1, T2>& v) ;
209  template <typename T1>
210  int getSize(const boost::unordered_set<T1>& v) ;
211  template <typename T1, typename T2>
212  int getSize(const std::pair<T1, T2>& v) ;
213  template <typename T>
214  int getSize(const std::set<T>& v) ;
215 
216  //specialized version of decode for std::vector<bool> due to problems with c++
217  //standard on how vector<bool> is defined
218  DT_DLL_readerWriter int getSize(const std::vector<bool>& v);
220 }
221 
222 #define bufferSerialize_INL_
223 #include "readerWriter/bufferSerialize.inl"
224 #undef bufferSerialize_INL_
225 
DtBufferSerialize::getSize
DT_DLL_readerWriter int getSize(const DtString &val)
The number of bytes required to encode the value.
DT_DLL_readerWriter
#define DT_DLL_readerWriter
This file is used to determine how to build Disable inconsistent dll linkage warning Visual Studio 6...
Definition: readerWriterDefines.h:34
rwIntSized.h
Defines ReaderWriter classes for varying sized integers In most cases the DtRwInt class is the prefer...
DtRwVariableBindings
ReaderWriter object that maintains a list of reader-writer variable bindings. It keeps a list of name...
Definition: rwVariableBindings.h:27
vrvControlToolkit::DtFloat32
float DtFloat32
Definition: vrvControlStructTypes.h:35
vrvControlToolkit::DtInt32
int DtInt32
Definition: vrvControlStructTypes.h:31
DtRwInt
Description: Readable, Writable int.
Definition: rwInt.h:25
vrvControlToolkit::DtFloat64
double DtFloat64
Definition: vrvControlStructTypes.h:36
DtBufferSerialize::encode
DT_DLL_readerWriter char * encode(const DtFilename &val, char *buffer)
Serializes the provided value val into buffer. buffer must have at least the number of bytes returned...
vrvControlToolkit::DtInt16
short DtInt16
Definition: vrvControlStructTypes.h:29
rwRealSized.h
Defines ReaderWriter classes for varying sized reals In most cases the DtRwReal class is the preferre...
DtRwStringAttribute
class DtRwStringAttribute:
Definition: rwStringAttribute.h:19
DtRwBoolean
Description: Readable, Writable bool.
Definition: rwBoolean.h:26
DtBufferSerialize::decode
DT_DLL_readerWriter const char * decode(DtString &val, const char *buffer)
Decodes a value from buffer and places the result in val of the type specified by val...
DtRwStringAttributeList
class DtRwStringAttributeList:
Definition: rwStringAttributeList.h:29
Document ID: Generated on Tue Sep 24 19:28:17 EDT 2024 from SVN revision 269799
Copyright © 2005-2024 MAK Technologies. All Rights Reserved (www.mak.com)