VR-Forces 4.2 Class Documentation
rwToXml.h
Go to the documentation of this file.
1 /*******************************************************************************
2 ** Copyright (c) 2013 MAK Technologies, Inc.
3 ** All rights reserved.
4 *******************************************************************************/
5 
6 #pragma once
7 
8 #include "vrfutil/rwInt.h"
9 #include "vrfutil/rwReal.h"
10 #include "vrfutil/rwString.h"
11 #include "vrfutil/rwVector.h"
12 #include "vrfutil/rwBoolean.h"
13 #include "vrfutil/intRsrc.h"
14 #include "vrfutil/realRsrc.h"
15 #include "vrfutil/munRsrc.h"
16 #include "vrfutil/rsrcMgr.h"
17 #include "vrfutil/formTblEntry.h"
18 #include "vrfutil/rwVariableBindings.h"
19 #include "vrfutil/readerWriterFactory.h"
20 #include "vrfutil/rwTypes.h"
21 #include "vrfutil/rsrcTypes.h"
22 #include "vrfobjparam/tgtPriList.h"
23 #include "vrfobjparam/tgtPriEntry.h"
24 #include "vrfobjparam/compSystemDescriptorList.h"
25 #include "vrfobjparam/vrfobjparamDefines.h"
26 #include "vrfobjparam/vrfXmlTypes.h"
27 #include "vrfobjparam/vrfXmlUtils.h"
28 #include "mtl/env.h"
29 #include "mtl/envXMLWriter.h"
30 #include "vrfobjparam/vrfObjParams.h"
31 #include "vrfobjparam/vrfParamDb.h"
32 #include "vrfobjparam/mtlParamDbEntry.h"
33 #include "vrfobjparam/dfltParamFact.h"
34 
35 #include "vrfutil/rwRegData.h"
36 #include "extMtl/extFileInputStream.h"
37 #include "extMtl/extDtcRead.h"
38 #include "vrfutil/kinTools.h"
39 #include "vrfobjparam/slotExclusion.h"
40 
41 #include <boost/function.hpp>
42 
43 class DT_DLL_vrfobjparam DtRwToXml
44 {
45 public:
46 
50 
51  static void DtBasicTypeToEnvValue(DtEnvironmentSP, const DtReaderWriter* rwObject, DtEnvValueSP envValue)
52  {
53  envValue->setValue(DtXmlUtils::removeQuotes(rwObject->prettyPrint()));
54  }
55 
56  static void DtRwVectorToEnvValue(DtEnvironmentSP env, const DtReaderWriter* rwObject, DtEnvValueSP envValue)
57  {
58  const DtRwVector* rwVector = static_cast<const DtRwVector*>(rwObject);
59  DtXmlUtils::WriteVector(env, envValue, rwVector, DtXmlUtils::WriteAsBodyPosition(rwObject));
60  }
61 
62  static void DtRwOffsetVectorToEnvValue(DtEnvironmentSP env, const DtReaderWriter* rwObject, DtEnvValueSP envValue)
63  {
64  const DtRwOffsetVector* rwVector = static_cast<const DtRwOffsetVector*>(rwObject);
65  env->addAttribute(vrfXml::BodyForward, rwVector->x(), envValue);
66  env->addAttribute(vrfXml::BodyRight, rwVector->y(), envValue);
67  env->addAttribute(vrfXml::BodyDown, rwVector->z(), envValue);
68  }
69 
70  static void DtRwBoundingVolumeToEnvValue(DtEnvironmentSP env,
71  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
72  {
73  const DtRwBoundingVolume* rwBVol = static_cast<const DtRwBoundingVolume*>(rwObject);
74 
75  if (!rwBVol->isOffset())
76  {
77  env->addAttribute(vrfXml::OffsetType, vrfXml::OffsetTypeCenter, envValue);
78  }
79  else if (rwBVol->latticeOffset().x() == 0.0
80  && rwBVol->latticeOffset().y() == 0.0
81  && DtALMOST(rwBVol->latticeOffset().z(), -rwBVol->halfHeight(), 0.001))
82  {
83  env->addAttribute(vrfXml::OffsetType, vrfXml::OffsetTypeGroundCenter, envValue);
84  }
85  else
86  {
87  env->addAttribute(vrfXml::OffsetType, vrfXml::OffsetTypeCustom, envValue);
88  DtEnvValueSP offset = env->addObject(vrfXml::Offset, envValue);
89 
90  env->addAttribute(vrfXml::BodyForward, DtString(rwBVol->latticeOffset().x()), offset);
91  env->addAttribute(vrfXml::BodyRight, DtString(rwBVol->latticeOffset().y()), offset);
92  env->addAttribute(vrfXml::BodyDown, DtString(rwBVol->latticeOffset().z()), offset);
93  }
94 
95  DtEnvValueSP dimensions = env->addObject(vrfXml::Dimensions, envValue);
96  env->addAttribute(vrfXml::Length, DtString(rwBVol->length()), dimensions);
97  env->addAttribute(vrfXml::Width, DtString(rwBVol->width()), dimensions);
98  env->addAttribute(vrfXml::Height, DtString(rwBVol->height()), dimensions);
99  }
100 
101  static void DtRwNLengthStringVectorToEnvValue(DtEnvironmentSP env,
102  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
103  {
104  const DtRwNLengthStringVector* strings = static_cast<const DtRwNLengthStringVector*>(rwObject);
105  envValue->setValue(DtXmlUtils::NLengthStringListToString(*strings));
106  }
107 
108  static void DtRwListToEnvValue(DtEnvironmentSP env,
109  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
110  {
111  const DtRwList* rwList = static_cast<const DtRwList*>(rwObject);
112  DtListItem* item = rwList->first();
113  for ( ; item; item = item->next())
114  {
115  DtReaderWriter* rwChildObject = static_cast<DtReaderWriter*>(item->data());
116  DtString xmlType = vrfXml::RwTypeToXmlType(rwChildObject);
117  DtEnvValueSP childObject = env->addObject(xmlType.c_str(), envValue);
118  getConverter().convert(env, rwChildObject, childObject);
119  }
120  }
121 
122  static void DtSoilFactorsToEnvValue(DtEnvironmentSP env,
123  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
124  {
125  const DtSoilFactors* factors = static_cast<const DtSoilFactors*>(rwObject);
126  env->addAttribute(vrfXml::SoilType, factors->name().c_str(), envValue);
127  env->addAttribute(vrfXml::AccelerationFactor, factors->accelerationFactor().prettyPrint(), envValue);
128  env->addAttribute(vrfXml::StoppingFactor, factors->stoppingFactor().prettyPrint(), envValue);
129  env->addAttribute(vrfXml::MaxSpeedFactor, factors->maxSpeedFactor().prettyPrint(), envValue);
130  }
131 
132  static void DtEmbarkationSlotToEnvValue(DtEnvironmentSP env,
133  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
134  {
135  const DtEmbarkationSlotEntry* embSlot = static_cast<const DtEmbarkationSlotEntry*>(rwObject);
136  env->addAttribute(vrfXml::EmbarkableObject, embSlot->object().string(), envValue);
137  env->addAttribute(vrfXml::Capacity, embSlot->numberOfEntities(), envValue);
138  env->addAttribute(vrfXml::JumpToLocation, embSlot->jumpToLocation() ? "True" : "False", envValue);
139  env->addAttribute(vrfXml::TurnToHeading, embSlot->turnToHeading() ? "True" : "False", envValue);
140 
141  char app[16];
142  sprintf(app, "%#8X", embSlot->appearance().appearance());
143  env->addAttribute(vrfXml::EmbarkedAppearance, app, envValue);
144 
145  DtString xmlType = vrfXml::RwTypeToXmlType(rwObject);
146  DtEnvValueSP embarkedPosition = env->addObject(vrfXml::EmbarkedPosition, envValue);
147  DtRwVector vector(embSlot->position());
148  getConverter().convert(env, &vector, embarkedPosition);
149 
150  //write orientation as a heading only if possible
151  if (embSlot->orientation().theta() == 0.0 && embSlot->orientation().phi() == 0.0)
152  {
153  DtEnvValueSP embHeading = env->addObject(vrfXml::EmbarkedHeading, envValue);
154  embHeading->setValue(DtRad2Deg(embSlot->orientation().psi()));
155  }
156  else
157  {
158  DtEnvValueSP embOrientation = env->addObject(vrfXml::EmbarkedOrientation, envValue);
159  env->addAttribute(vrfXml::Yaw, embSlot->orientation().psi(), envValue);
160  env->addAttribute(vrfXml::Pitch, embSlot->orientation().theta(), envValue);
161  env->addAttribute(vrfXml::Roll, embSlot->orientation().phi(), envValue);
162  }
163  }
164 
165  static void DtLoadPointToEnvValue(DtEnvironmentSP env,
166  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
167  {
168  const DtLoadPoint* loadPoint = static_cast<const DtLoadPoint*>(rwObject);
169  DtString supportedSlots = DtXmlUtils::NLengthIntListToString(loadPoint->supportedSlots());
170  env->addAttribute(vrfXml::SupportedSlots, supportedSlots, envValue);
171 
172  DtListItem* item = loadPoint->points().first();
173  for ( ; item; item = item->next())
174  {
175  DtEnvValueSP point = env->addObject(vrfXml::Vector, envValue);
176  getConverter().convert(env, static_cast<DtRwVector*>(item->data()), point);
177  }
178  }
179 
180  static void DtRwTaitBryanToEnvValue(DtEnvironmentSP env,
181  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
182  {
183  const DtRwTaitBryan* taitBryan = static_cast<const DtRwTaitBryan*>(rwObject);
184  env->addAttribute(vrfXml::Yaw, taitBryan->psi(), envValue);
185  env->addAttribute(vrfXml::Pitch, taitBryan->theta(), envValue);
186  env->addAttribute(vrfXml::Roll, taitBryan->phi(), envValue);
187  }
188 
189  static void DtRwSubObjectToEnvValue(DtEnvironmentSP env,
190  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
191  {
192  const DtVrfSubObjectParameterEntry* subObject =
193  static_cast<const DtVrfSubObjectParameterEntry*>(rwObject);
194  env->addAttribute(vrfXml::ObjectType, subObject->objectType().string(), envValue);
195  env->addAttribute(vrfXml::HeadingOffset, subObject->headingOffset(), envValue);
196  env->addAttribute(vrfXml::VectorX, subObject->positionOffset().x(), envValue);
197  env->addAttribute(vrfXml::VectorY, subObject->positionOffset().y(), envValue);
198  env->addAttribute(vrfXml::VectorZ, subObject->positionOffset().z(), envValue);
199  }
200 
201  static void DtFormationTableToEnvValue(DtEnvironmentSP env,
202  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
203  {
204  const DtFormationTable* formations = static_cast<const DtFormationTable*>(rwObject);
205  env->addAttribute(vrfXml::AutoLayoutForGui, formations->autoLayoutForGui(), envValue);
206  DtRwListToEnvValue(env, rwObject, envValue);
207  }
208 
209  static void DtFormationEntryToEnvValue(DtEnvironmentSP env,
210  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
211  {
212  const DtFormationTableEntry* formation = static_cast<const DtFormationTableEntry*>(rwObject);
213  env->addAttribute(vrfXml::FormationName, formation->formationName(), envValue);
214  DtString formationFileName = DtXmlUtils::MtlBindingCharToXml(
215  formation->formationFile().unsubstitutedFilename());
216  env->addAttribute(vrfXml::FormationFile, formationFileName, envValue);
217  }
218 
219  static void DtEntityTypeToEnvValue(DtEnvironmentSP env,
220  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
221  {
222  const DtRwEntityType* entityType = static_cast<const DtRwEntityType*>(rwObject);
223  envValue->setValue(entityType->string());
224  }
225 
226  static void DtBoundingGeoemtryTypeToEnvValue(DtEnvironmentSP env,
227  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
228  {
229  const DtRwBoundingGeometryType* bgType = static_cast<const DtRwBoundingGeometryType*>(rwObject);
230  if (bgType->value() == DtSimBoundingGeometry::BoundingTypeArea)
231  envValue->setValue(vrfXml::BoundingGeometryArea);
232  else if (bgType->value() == DtSimBoundingGeometry::BoundingTypeVolume)
233  envValue->setValue(vrfXml::BoundingGeometryVolume);
234  else if (bgType->value() == DtSimBoundingGeometry::BoundingTypeUndefined)
235  envValue->setValue(vrfXml::BoundingGeometryUndefined);
236  else
237  DtWarn << "Unknown bounding geometry type " << bgType->value() << std::endl;
238  }
239 
240  static void DtSlotExclusionToEnvValue(DtEnvironmentSP env,
241  const DtReaderWriter* rwObject, DtEnvValueSP envValue)
242  {
243  const DtSlotExclusion* exclusions = static_cast<const DtSlotExclusion*>(rwObject);
244 
245  DtString ifSlotsReserved = DtXmlUtils::NLengthIntListToString(exclusions->ifSlotsReserved());
246  env->addAttribute(vrfXml::IfSlotsReserved, ifSlotsReserved, envValue);
247 
248  DtString excludeTheseSlots = DtXmlUtils::NLengthIntListToString(exclusions->excludeTheseSlots());
249  env->addAttribute(vrfXml::ExcludeTheseSlots, excludeTheseSlots, envValue);
250  }
251 
255 
256  typedef boost::function<void (DtEnvironmentSP, const DtReaderWriter*, const DtEnvValueSP)> ConversionFunction;
257 
258  //Handles assignment from DtReaderWriter objects to DtEnvValueSP objects
259  class DT_DLL_vrfobjparam Converter
260  {
261  public:
262  Converter()
263  : myXmlConverters()
264  {
265  registerConverter(DtRwIntType, &DtBasicTypeToEnvValue);
266  registerConverter(DtRwRealType, &DtBasicTypeToEnvValue);
267  registerConverter(DtRwStringType, &DtBasicTypeToEnvValue);
268  registerConverter(DtRwBooleanType, &DtBasicTypeToEnvValue);
269  registerConverter(DtRwVectorType, &DtRwVectorToEnvValue);
270  registerConverter(DtRwOffsetVectorType, &DtRwOffsetVectorToEnvValue);
271  registerConverter(DtRwBoundingVolumeType, &DtRwBoundingVolumeToEnvValue);
272  registerConverter(DtRwNLengthStringVectorType, &DtRwNLengthStringVectorToEnvValue);
273  registerConverter(DtSoilListType, &DtRwListToEnvValue);
274  registerConverter(DtSoilFactorsType, &DtSoilFactorsToEnvValue);
275  registerConverter(DtRwTemplatedListPtr<DtEmbarkationSlotEntry>::ListReaderWriterType(), &DtRwListToEnvValue);
276  registerConverter(DtEmbarkationSlotEntryType, &DtEmbarkationSlotToEnvValue);
277  registerConverter(DtRwTemplatedListPtr<DtLoadPoint>::ListReaderWriterType(), &DtRwListToEnvValue);
278  registerConverter(DtLoadPointType, &DtLoadPointToEnvValue);
279  registerConverter(DtRwTaitBryanType, &DtRwTaitBryanToEnvValue);
280  registerConverter(DtVrfSubObjectParameterListType, &DtRwListToEnvValue);
281  registerConverter(DtVrfSubObjectParameterEntryType, &DtRwSubObjectToEnvValue);
282  registerConverter(DtFormationTableType, &DtFormationTableToEnvValue);
283  registerConverter(DtFormationEntryType, &DtFormationEntryToEnvValue);
284  registerConverter(DtRwEntityTypeType, &DtEntityTypeToEnvValue);
285  registerConverter(DtRwBoundingGeometryTypeType, &DtBoundingGeoemtryTypeToEnvValue);
286  registerConverter(DtRwTemplatedListPtr<DtSlotExclusion>::ListReaderWriterType(), &DtRwListToEnvValue);
287  registerConverter(DtSlotExclusionType, &DtSlotExclusionToEnvValue);
288  }
289 
290  void convert(DtEnvironmentSP env, const DtReaderWriter* rwObject, DtEnvValueSP envValue)
291  {
292  if (!rwObject)
293  {
294  DtWarn << "DtXmlRWFactory::convert null rw object" << std::endl;
295  return;
296  }
297  if (!envValue.get())
298  {
299  DtWarn << "DtXmlRWFactory::convert null env value" << std::endl;
300  return;
301  }
302 
303  if (myXmlConverters.find(rwObject->readerWriterType()) != myXmlConverters.end())
304  {
305  myXmlConverters[rwObject->readerWriterType()](env, rwObject, envValue);
306  }
307  else
308  {
309  DtWarn << "DtXmlRWFactory: No Converter for type " << rwObject->readerWriterType() << std::endl;
310  }
311  }
312 
313  void registerConverter(const DtString& type, ConversionFunction conversionFunction)
314  {
315  myXmlConverters[type] = conversionFunction;
316  }
317 
318  protected:
319  std::map<DtString, ConversionFunction> myXmlConverters;
320  };
321 
322  static Converter& getConverter();
323 
324  static void Convert(DtEnvironmentSP env, const DtReaderWriter* rwObject, DtEnvValueSP envValue);
325 };
Document ID: Generated on Sun Nov 24 19:49:21 EST 2013 from SVN revision 133924
Copyright © 2005-2013 VT MÄK. All Rights Reserved (www.mak.com)