simgear/hla/HLAPropertyDataElement.cxx

   1 // Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Library General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Library General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program; if not, write to the Free Software
  15 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  16 //
  17
  18 #include "HLAPropertyDataElement.hxx"
  19
  20 #include "HLADataTypeVisitor.hxx"
  21
  22 namespace simgear {
  23
  24 class HLAPropertyDataElement::DecodeVisitor : public HLADataTypeDecodeVisitor {
  25 public:
  26     DecodeVisitor(HLADecodeStream& stream, HLAPropertyReference& propertyReference) :
  27         HLADataTypeDecodeVisitor(stream),
  28         _propertyReference(propertyReference)
  29     { }
  30
  31     virtual void apply(const HLAInt8DataType& dataType)
  32     {
  33         int8_t value = 0;
  34         dataType.decode(_stream, value);
  35         _propertyReference.setIntValue(value);
  36     }
  37     virtual void apply(const HLAUInt8DataType& dataType)
  38     {
  39         uint8_t value = 0;
  40         dataType.decode(_stream, value);
  41         _propertyReference.setIntValue(value);
  42     }
  43     virtual void apply(const HLAInt16DataType& dataType)
  44     {
  45         int16_t value = 0;
  46         dataType.decode(_stream, value);
  47         _propertyReference.setIntValue(value);
  48     }
  49     virtual void apply(const HLAUInt16DataType& dataType)
  50     {
  51         uint16_t value = 0;
  52         dataType.decode(_stream, value);
  53         _propertyReference.setIntValue(value);
  54     }
  55     virtual void apply(const HLAInt32DataType& dataType)
  56     {
  57         int32_t value = 0;
  58         dataType.decode(_stream, value);
  59         _propertyReference.setIntValue(value);
  60     }
  61     virtual void apply(const HLAUInt32DataType& dataType)
  62     {
  63         uint32_t value = 0;
  64         dataType.decode(_stream, value);
  65         _propertyReference.setIntValue(value);
  66     }
  67     virtual void apply(const HLAInt64DataType& dataType)
  68     {
  69         int64_t value = 0;
  70         dataType.decode(_stream, value);
  71         _propertyReference.setLongValue(value);
  72     }
  73     virtual void apply(const HLAUInt64DataType& dataType)
  74     {
  75         uint64_t value = 0;
  76         dataType.decode(_stream, value);
  77         _propertyReference.setLongValue(value);
  78     }
  79     virtual void apply(const HLAFloat32DataType& dataType)
  80     {
  81         float value = 0;
  82         dataType.decode(_stream, value);
  83         _propertyReference.setFloatValue(value);
  84     }
  85     virtual void apply(const HLAFloat64DataType& dataType)
  86     {
  87         double value = 0;
  88         dataType.decode(_stream, value);
  89         _propertyReference.setDoubleValue(value);
  90     }
  91
  92     virtual void apply(const HLAFixedArrayDataType& dataType)
  93     {
  94         unsigned numElements = dataType.getNumElements();
  95         std::string value;
  96         value.reserve(numElements);
  97         for (unsigned i = 0; i < numElements; ++i) {
  98             HLATemplateDecodeVisitor<char> visitor(_stream);
  99             dataType.getElementDataType()->accept(visitor);
 100             value.push_back(visitor.getValue());
 101         }
 102         _propertyReference.setStringValue(value);
 103     }
 104     virtual void apply(const HLAVariableArrayDataType& dataType)
 105     {
 106         HLATemplateDecodeVisitor<unsigned> numElementsVisitor(_stream);
 107         dataType.getSizeDataType()->accept(numElementsVisitor);
 108         unsigned numElements = numElementsVisitor.getValue();
 109         std::string value;
 110         value.reserve(numElements);
 111         for (unsigned i = 0; i < numElements; ++i) {
 112             HLATemplateDecodeVisitor<char> visitor(_stream);
 113             dataType.getElementDataType()->accept(visitor);
 114             value.push_back(visitor.getValue());
 115         }
 116         _propertyReference.setStringValue(value);
 117     }
 118
 119 protected:
 120     HLAPropertyReference& _propertyReference;
 121 };
 122
 123 class HLAPropertyDataElement::EncodeVisitor : public HLADataTypeEncodeVisitor {
 124 public:
 125     EncodeVisitor(HLAEncodeStream& stream, const HLAPropertyReference& propertyReference) :
 126         HLADataTypeEncodeVisitor(stream),
 127         _propertyReference(propertyReference)
 128     { }
 129
 130     virtual void apply(const HLAInt8DataType& dataType)
 131     {
 132         dataType.encode(_stream, _propertyReference.getIntValue());
 133     }
 134     virtual void apply(const HLAUInt8DataType& dataType)
 135     {
 136         dataType.encode(_stream, _propertyReference.getIntValue());
 137     }
 138     virtual void apply(const HLAInt16DataType& dataType)
 139     {
 140         dataType.encode(_stream, _propertyReference.getIntValue());
 141     }
 142     virtual void apply(const HLAUInt16DataType& dataType)
 143     {
 144         dataType.encode(_stream, _propertyReference.getIntValue());
 145     }
 146     virtual void apply(const HLAInt32DataType& dataType)
 147     {
 148         dataType.encode(_stream, _propertyReference.getIntValue());
 149     }
 150     virtual void apply(const HLAUInt32DataType& dataType)
 151     {
 152         dataType.encode(_stream, _propertyReference.getIntValue());
 153     }
 154     virtual void apply(const HLAInt64DataType& dataType)
 155     {
 156         dataType.encode(_stream, _propertyReference.getLongValue());
 157     }
 158     virtual void apply(const HLAUInt64DataType& dataType)
 159     {
 160         dataType.encode(_stream, _propertyReference.getLongValue());
 161     }
 162     virtual void apply(const HLAFloat32DataType& dataType)
 163     {
 164         dataType.encode(_stream, _propertyReference.getFloatValue());
 165     }
 166     virtual void apply(const HLAFloat64DataType& dataType)
 167     {
 168         dataType.encode(_stream, _propertyReference.getDoubleValue());
 169     }
 170
 171     virtual void apply(const HLAFixedArrayDataType& dataType)
 172     {
 173         unsigned numElements = dataType.getNumElements();
 174         std::string value = _propertyReference.getStringValue();
 175         for (unsigned i = 0; i < numElements; ++i) {
 176             if (i < value.size()) {
 177                 HLATemplateEncodeVisitor<char> visitor(_stream, value[i]);
 178                 dataType.getElementDataType()->accept(visitor);
 179             } else {
 180                 HLADataTypeEncodeVisitor visitor(_stream);
 181                 dataType.getElementDataType()->accept(visitor);
 182             }
 183         }
 184     }
 185
 186     virtual void apply(const HLAVariableArrayDataType& dataType)
 187     {
 188         std::string value = _propertyReference.getStringValue();
 189         HLATemplateEncodeVisitor<std::string::size_type> numElementsVisitor(_stream, value.size());
 190         dataType.getSizeDataType()->accept(numElementsVisitor);
 191         for (unsigned i = 0; i < value.size(); ++i) {
 192             HLATemplateEncodeVisitor<char> visitor(_stream, value[i]);
 193             dataType.getElementDataType()->accept(visitor);
 194         }
 195     }
 196
 197 protected:
 198     const HLAPropertyReference& _propertyReference;
 199 };
 200
 201 HLAPropertyDataElement::HLAPropertyDataElement(HLAPropertyReference* propertyReference) :
 202     _propertyReference(propertyReference)
 203 {
 204 }
 205
 206 HLAPropertyDataElement::HLAPropertyDataElement(const simgear::HLADataType* dataType, HLAPropertyReference* propertyReference) :
 207     _dataType(dataType),
 208     _propertyReference(propertyReference)
 209 {
 210 }
 211
 212 HLAPropertyDataElement::~HLAPropertyDataElement()
 213 {
 214 }
 215
 216 bool
 217 HLAPropertyDataElement::encode(HLAEncodeStream& stream) const
 218 {
 219     if (!_dataType.valid())
 220         return false;
 221     if (_propertyReference.valid()) {
 222         EncodeVisitor visitor(stream, *_propertyReference);
 223         _dataType->accept(visitor);
 224     } else {
 225         HLADataTypeEncodeVisitor visitor(stream);
 226         _dataType->accept(visitor);
 227     }
 228     return true;
 229 }
 230
 231 bool
 232 HLAPropertyDataElement::decode(HLADecodeStream& stream)
 233 {
 234     if (!_dataType.valid())
 235         return false;
 236     if (_propertyReference.valid()) {
 237         DecodeVisitor visitor(stream, *_propertyReference);
 238         _dataType->accept(visitor);
 239     } else {
 240         HLADataTypeDecodeVisitor visitor(stream);
 241         _dataType->accept(visitor);
 242     }
 243     return true;
 244 }
 245
 246 const HLADataType*
 247 HLAPropertyDataElement::getDataType() const
 248 {
 249     return _dataType.get();
 250 }
 251
 252 bool
 253 HLAPropertyDataElement::setDataType(const HLADataType* dataType)
 254 {
 255     if (dataType->toBasicDataType()) {
 256         _dataType = dataType;
 257         return true;
 258     } else {
 259         const HLAArrayDataType* arrayDataType = dataType->toArrayDataType();
 260         if (arrayDataType && arrayDataType->getElementDataType() &&
 261             arrayDataType->getElementDataType()->toBasicDataType()) {
 262             _dataType = dataType;
 263             return true;
 264         }
 265     }
 266     return false;
 267 }
 268
 269 } // namespace simgear