simgear/hla/HLABasicDataElement.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 "HLABasicDataElement.hxx"
  19
  20 #include "HLADataElementVisitor.hxx"
  21 #include "HLADataTypeVisitor.hxx"
  22
  23 namespace simgear {
  24
  25 HLABasicDataElement::HLABasicDataElement(const HLABasicDataType* dataType) :
  26     _dataType(dataType)
  27 {
  28 }
  29
  30 HLABasicDataElement::~HLABasicDataElement()
  31 {
  32 }
  33
  34 void
  35 HLABasicDataElement::accept(HLADataElementVisitor& visitor)
  36 {
  37     visitor.apply(*this);
  38 }
  39
  40 void
  41 HLABasicDataElement::accept(HLAConstDataElementVisitor& visitor) const
  42 {
  43     visitor.apply(*this);
  44 }
  45
  46 const HLABasicDataType*
  47 HLABasicDataElement::getDataType() const
  48 {
  49     return _dataType.get();
  50 }
  51
  52 bool
  53 HLABasicDataElement::setDataType(const HLADataType* dataType)
  54 {
  55     const HLABasicDataType* scalarDataType = dynamic_cast<const HLABasicDataType*>(dataType);
  56     if (!scalarDataType) {
  57         SG_LOG(SG_NETWORK, SG_WARN, "HLABasicDataType: unable to set data type!");
  58         return false;
  59     }
  60     setDataType(scalarDataType);
  61     return true;
  62 }
  63
  64 void
  65 HLABasicDataElement::setDataType(const HLABasicDataType* dataType)
  66 {
  67     _dataType = dataType;
  68 }
  69
  70 #define IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(type, ctype)                                       \
  71 HLAAbstract##type##DataElement::HLAAbstract##type##DataElement(const HLABasicDataType* dataType) :\
  72     HLABasicDataElement(dataType)                                                                 \
  73 {                                                                                                 \
  74 }                                                                                                 \
  75                                                                                                   \
  76 HLAAbstract##type##DataElement::~HLAAbstract##type##DataElement()                                 \
  77 {                                                                                                 \
  78 }                                                                                                 \
  79                                                                                                   \
  80 bool                                                                                              \
  81 HLAAbstract##type##DataElement::encode(HLAEncodeStream& stream) const                             \
  82 {                                                                                                 \
  83     if (!_dataType.valid())                                                                       \
  84         return false;                                                                             \
  85     HLATemplateEncodeVisitor<ctype> visitor(stream, getValue());                                  \
  86     _dataType->accept(visitor);                                                                   \
  87     return true;                                                                                  \
  88 }                                                                                                 \
  89                                                                                                   \
  90 bool                                                                                              \
  91 HLAAbstract##type##DataElement::decode(HLADecodeStream& stream)                                   \
  92 {                                                                                                 \
  93     if (!_dataType.valid())                                                                       \
  94         return false;                                                                             \
  95     HLATemplateDecodeVisitor<ctype> visitor(stream);                                              \
  96     _dataType->accept(visitor);                                                                   \
  97     setValue(visitor.getValue());                                                                 \
  98     return true;                                                                                  \
  99 }                                                                                                 \
 100                                                                                                   \
 101 HLA##type##DataElement::HLA##type##DataElement(const HLABasicDataType* dataType) :                \
 102     HLAAbstract##type##DataElement(dataType),                                                     \
 103     _value(0)                                                                                     \
 104 {                                                                                                 \
 105 }                                                                                                 \
 106                                                                                                   \
 107 HLA##type##DataElement::HLA##type##DataElement(const HLABasicDataType* dataType,                  \
 108                                                const ctype& value) :                              \
 109     HLAAbstract##type##DataElement(dataType),                                                     \
 110     _value(value)                                                                                 \
 111 {                                                                                                 \
 112 }                                                                                                 \
 113                                                                                                   \
 114 HLA##type##DataElement::~HLA##type##DataElement()                                                 \
 115 {                                                                                                 \
 116 }                                                                                                 \
 117                                                                                                   \
 118 ctype                                                                                             \
 119 HLA##type##DataElement::getValue() const                                                          \
 120 {                                                                                                 \
 121     return _value;                                                                                \
 122 }                                                                                                 \
 123                                                                                                   \
 124 void                                                                                              \
 125 HLA##type##DataElement::setValue(ctype value)                                                     \
 126 {                                                                                                 \
 127     _value = value;                                                                               \
 128 }
 129
 130 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Char, char);
 131 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(WChar, wchar_t);
 132 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(SChar, signed char);
 133 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(UChar, unsigned char);
 134 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Short, short);
 135 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(UShort, unsigned short);
 136 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Int, int);
 137 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(UInt, unsigned int);
 138 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Long, long);
 139 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(ULong, unsigned long);
 140 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Float, float);
 141 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Double, double);
 142
 143 #undef IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT
 144
 145 }