simgear/hla/HLABasicDataType.cxx

   1 // Copyright (C) 2009 - 2012  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 "HLABasicDataType.hxx"
  19
  20 #include "HLADataType.hxx"
  21 #include "HLADataTypeVisitor.hxx"
  22
  23 namespace simgear {
  24
  25 HLABasicDataType::HLABasicDataType(const std::string& name) :
  26     HLADataType(name)
  27 {
  28 }
  29
  30 HLABasicDataType::~HLABasicDataType()
  31 {
  32 }
  33
  34 void
  35 HLABasicDataType::accept(HLADataTypeVisitor& visitor) const
  36 {
  37     visitor.apply(*this);
  38 }
  39
  40 const HLABasicDataType*
  41 HLABasicDataType::toBasicDataType() const
  42 {
  43     return this;
  44 }
  45
  46 //////////////////////////////////////////////////////////////////////////////
  47
  48 HLAInt8DataType::HLAInt8DataType(const std::string& name) :
  49     HLABasicDataType(name)
  50 {
  51     setAlignment(sizeof(int8_t));
  52 }
  53
  54 HLAInt8DataType::~HLAInt8DataType()
  55 {
  56 }
  57
  58 void
  59 HLAInt8DataType::accept(HLADataTypeVisitor& visitor) const
  60 {
  61     visitor.apply(*this);
  62 }
  63
  64 //////////////////////////////////////////////////////////////////////////////
  65
  66 HLAUInt8DataType::HLAUInt8DataType(const std::string& name) :
  67     HLABasicDataType(name)
  68 {
  69     setAlignment(sizeof(uint8_t));
  70 }
  71
  72 HLAUInt8DataType::~HLAUInt8DataType()
  73 {
  74 }
  75
  76 void
  77 HLAUInt8DataType::accept(HLADataTypeVisitor& visitor) const
  78 {
  79     visitor.apply(*this);
  80 }
  81
  82 //////////////////////////////////////////////////////////////////////////////
  83
  84 #define BASIC_DATATYPE_IMPLEMENTATION(type, name)                       \
  85 HLA##name##DataType::HLA##name##DataType(const std::string& name) :     \
  86     HLABasicDataType(name)                                              \
  87 {                                                                       \
  88     setAlignment(sizeof(type));                                         \
  89 }                                                                       \
  90                                                                         \
  91 HLA##name##DataType::~HLA##name##DataType()                             \
  92 {                                                                       \
  93 }                                                                       \
  94                                                                         \
  95 void                                                                    \
  96 HLA##name##DataType::accept(HLADataTypeVisitor& visitor) const          \
  97 {                                                                       \
  98     visitor.apply(*this);                                               \
  99 }                                                                       \
 100                                                                         \
 101                                                                         \
 102                                                                         \
 103 HLA##name##LEDataType::HLA##name##LEDataType(const std::string& name) : \
 104     HLA##name##DataType(name)                                           \
 105 {                                                                       \
 106 }                                                                       \
 107                                                                         \
 108 HLA##name##LEDataType::~HLA##name##LEDataType()                         \
 109 {                                                                       \
 110 }                                                                       \
 111                                                                         \
 112 bool                                                                    \
 113 HLA##name##LEDataType::decode(HLADecodeStream& stream,                  \
 114                               type& value) const                        \
 115 {                                                                       \
 116     if (!stream.alignOffsetForSize(getAlignment()))                     \
 117         return false;                                                   \
 118     return stream.decode##name##LE(value);                              \
 119 }                                                                       \
 120                                                                         \
 121 bool                                                                    \
 122 HLA##name##LEDataType::encode(HLAEncodeStream& stream,                  \
 123                               const type& value) const                  \
 124 {                                                                       \
 125     if (!stream.alignOffsetForSize(getAlignment()))                     \
 126         return false;                                                   \
 127     return stream.encode##name##LE(value);                              \
 128 }                                                                       \
 129                                                                         \
 130                                                                         \
 131                                                                         \
 132 HLA##name##BEDataType::HLA##name##BEDataType(const std::string& name) : \
 133     HLA##name##DataType(name)                                           \
 134 {                                                                       \
 135 }                                                                       \
 136                                                                         \
 137 HLA##name##BEDataType::~HLA##name##BEDataType()                         \
 138 {                                                                       \
 139 }                                                                       \
 140                                                                         \
 141 bool                                                                    \
 142 HLA##name##BEDataType::decode(HLADecodeStream& stream,                  \
 143                               type& value) const                        \
 144 {                                                                       \
 145     if (!stream.alignOffsetForSize(getAlignment()))                     \
 146         return false;                                                   \
 147     return stream.decode##name##BE(value);                              \
 148 }                                                                       \
 149                                                                         \
 150 bool                                                                    \
 151 HLA##name##BEDataType::encode(HLAEncodeStream& stream,                  \
 152                               const type& value) const                  \
 153 {                                                                       \
 154     if (!stream.alignOffsetForSize(getAlignment()))                     \
 155         return false;                                                   \
 156     return stream.encode##name##BE(value);                              \
 157 }
 158
 159 BASIC_DATATYPE_IMPLEMENTATION(int16_t, Int16)
 160 BASIC_DATATYPE_IMPLEMENTATION(uint16_t, UInt16)
 161 BASIC_DATATYPE_IMPLEMENTATION(int32_t, Int32)
 162 BASIC_DATATYPE_IMPLEMENTATION(uint32_t, UInt32)
 163 BASIC_DATATYPE_IMPLEMENTATION(int64_t, Int64)
 164 BASIC_DATATYPE_IMPLEMENTATION(uint64_t, UInt64)
 165 BASIC_DATATYPE_IMPLEMENTATION(float, Float32)
 166 BASIC_DATATYPE_IMPLEMENTATION(double, Float64)
 167
 168 #undef BASIC_DATATYPE_IMPLEMENTATION
 169
 170 } // namespace simgear