simgear/hla/HLAFixedRecordDataElement.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 #ifdef HAVE_CONFIG_H
  19 #  include <simgear_config.h>
  20 #endif
  21
  22 #include <simgear/compiler.h>
  23
  24 #include "HLAFixedRecordDataElement.hxx"
  25
  26 #include <string>
  27 #include <vector>
  28 #include <simgear/debug/logstream.hxx>
  29
  30 #include "HLADataElementVisitor.hxx"
  31 #include "HLADataTypeVisitor.hxx"
  32
  33 namespace simgear {
  34
  35 HLAAbstractFixedRecordDataElement::HLAAbstractFixedRecordDataElement(const HLAFixedRecordDataType* dataType) :
  36     _dataType(dataType)
  37 {
  38 }
  39
  40 HLAAbstractFixedRecordDataElement::~HLAAbstractFixedRecordDataElement()
  41 {
  42 }
  43
  44 void
  45 HLAAbstractFixedRecordDataElement::accept(HLADataElementVisitor& visitor)
  46 {
  47     visitor.apply(*this);
  48 }
  49
  50 void
  51 HLAAbstractFixedRecordDataElement::accept(HLAConstDataElementVisitor& visitor) const
  52 {
  53     visitor.apply(*this);
  54 }
  55
  56 bool
  57 HLAAbstractFixedRecordDataElement::decode(HLADecodeStream& stream)
  58 {
  59     if (!_dataType.valid())
  60         return false;
  61     return _dataType->decode(stream, *this);
  62 }
  63
  64 bool
  65 HLAAbstractFixedRecordDataElement::encode(HLAEncodeStream& stream) const
  66 {
  67     if (!_dataType.valid())
  68         return false;
  69     return _dataType->encode(stream, *this);
  70 }
  71
  72 const HLAFixedRecordDataType*
  73 HLAAbstractFixedRecordDataElement::getDataType() const
  74 {
  75     return _dataType.get();
  76 }
  77
  78 bool
  79 HLAAbstractFixedRecordDataElement::setDataType(const HLADataType* dataType)
  80 {
  81     const HLAFixedRecordDataType* fixedRecordDataType = dataType->toFixedRecordDataType();
  82     if (!fixedRecordDataType) {
  83         SG_LOG(SG_NETWORK, SG_WARN, "HLAFixedRecordDataType: unable to set data type!");
  84         return false;
  85     }
  86     setDataType(fixedRecordDataType);
  87     return true;
  88 }
  89
  90 void
  91 HLAAbstractFixedRecordDataElement::setDataType(const HLAFixedRecordDataType* dataType)
  92 {
  93     _dataType = dataType;
  94 }
  95
  96 unsigned
  97 HLAAbstractFixedRecordDataElement::getNumFields() const
  98 {
  99     if (!_dataType.valid())
 100         return 0;
 101     return _dataType->getNumFields();
 102 }
 103
 104 unsigned
 105 HLAAbstractFixedRecordDataElement::getFieldNumber(const std::string& name) const
 106 {
 107     if (!_dataType.valid())
 108         return ~0u;
 109     return _dataType->getFieldNumber(name);
 110 }
 111
 112 const HLADataType*
 113 HLAAbstractFixedRecordDataElement::getFieldDataType(unsigned i) const
 114 {
 115     if (!_dataType.valid())
 116         return 0;
 117     return _dataType->getFieldDataType(i);
 118 }
 119
 120 const HLADataType*
 121 HLAAbstractFixedRecordDataElement::getFieldDataType(const std::string& name) const
 122 {
 123     if (!_dataType.valid())
 124         return 0;
 125     return getFieldDataType(getFieldNumber(name));
 126 }
 127
 128
 129 HLAFixedRecordDataElement::HLAFixedRecordDataElement(const HLAFixedRecordDataType* dataType) :
 130     HLAAbstractFixedRecordDataElement(dataType)
 131 {
 132     _fieldVector.resize(getNumFields());
 133 }
 134
 135 HLAFixedRecordDataElement::~HLAFixedRecordDataElement()
 136 {
 137     clearStamp();
 138 }
 139
 140 bool
 141 HLAFixedRecordDataElement::setDataType(const HLADataType* dataType)
 142 {
 143     if (!HLAAbstractFixedRecordDataElement::setDataType(dataType))
 144         return false;
 145     _fieldVector.resize(getNumFields());
 146     return true;
 147 }
 148
 149 bool
 150 HLAFixedRecordDataElement::setDataElement(HLADataElementIndex::const_iterator begin, HLADataElementIndex::const_iterator end, HLADataElement* dataElement)
 151 {
 152     // Must have happened in the parent
 153     if (begin == end)
 154         return false;
 155     unsigned index = *begin;
 156     if (++begin != end) {
 157         if (getNumFields() <= index)
 158             return false;
 159         if (!getField(index) && getFieldDataType(index)) {
 160             HLADataElementFactoryVisitor visitor;
 161             getFieldDataType(index)->accept(visitor);
 162             setField(index, visitor.getDataElement());
 163         }
 164         if (!getField(index))
 165             return false;
 166         return getField(index)->setDataElement(begin, end, dataElement);
 167     } else {
 168         if (!dataElement->setDataType(getFieldDataType(index)))
 169             return false;
 170         setField(index, dataElement);
 171         return true;
 172     }
 173 }
 174
 175 HLADataElement*
 176 HLAFixedRecordDataElement::getDataElement(HLADataElementIndex::const_iterator begin, HLADataElementIndex::const_iterator end)
 177 {
 178     if (begin == end)
 179         return this;
 180     HLADataElement* dataElement = getField(*begin);
 181     if (!dataElement)
 182         return 0;
 183     return dataElement->getDataElement(++begin, end);
 184 }
 185
 186 const HLADataElement*
 187 HLAFixedRecordDataElement::getDataElement(HLADataElementIndex::const_iterator begin, HLADataElementIndex::const_iterator end) const
 188 {
 189     if (begin == end)
 190         return this;
 191     const HLADataElement* dataElement = getField(*begin);
 192     if (!dataElement)
 193         return 0;
 194     return dataElement->getDataElement(++begin, end);
 195 }
 196
 197 bool
 198 HLAFixedRecordDataElement::decodeField(HLADecodeStream& stream, unsigned i)
 199 {
 200     HLADataElement* dataElement = getField(i);
 201     if (dataElement) {
 202         return dataElement->decode(stream);
 203     } else {
 204         HLADataTypeDecodeVisitor visitor(stream);
 205         getDataType()->getFieldDataType(i)->accept(visitor);
 206         return true;
 207     }
 208 }
 209
 210 bool
 211 HLAFixedRecordDataElement::encodeField(HLAEncodeStream& stream, unsigned i) const
 212 {
 213     const HLADataElement* dataElement = getField(i);
 214     if (dataElement) {
 215         return dataElement->encode(stream);
 216     } else {
 217         HLADataTypeEncodeVisitor visitor(stream);
 218         getDataType()->getFieldDataType(i)->accept(visitor);
 219         return true;
 220     }
 221 }
 222
 223 HLADataElement*
 224 HLAFixedRecordDataElement::getField(const std::string& name)
 225 {
 226     return getField(getFieldNumber(name));
 227 }
 228
 229 const HLADataElement*
 230 HLAFixedRecordDataElement::getField(const std::string& name) const
 231 {
 232     return getField(getFieldNumber(name));
 233 }
 234
 235 HLADataElement*
 236 HLAFixedRecordDataElement::getField(unsigned i)
 237 {
 238     if (_fieldVector.size() <= i)
 239         return 0;
 240     return _fieldVector[i].get();
 241 }
 242
 243 const HLADataElement*
 244 HLAFixedRecordDataElement::getField(unsigned i) const
 245 {
 246     if (_fieldVector.size() <= i)
 247         return 0;
 248     return _fieldVector[i].get();
 249 }
 250
 251 void
 252 HLAFixedRecordDataElement::setField(unsigned index, HLADataElement* value)
 253 {
 254     if (getNumFields() <= index)
 255         return;
 256     if (_fieldVector[index].valid())
 257         _fieldVector[index]->clearStamp();
 258     _fieldVector[index] = value;
 259     if (value)
 260         value->attachStamp(*this);
 261     setDirty(true);
 262 }
 263
 264 void
 265 HLAFixedRecordDataElement::setField(const std::string& name, HLADataElement* value)
 266 {
 267     setField(getFieldNumber(name), value);
 268 }
 269
 270 void
 271 HLAFixedRecordDataElement::_setStamp(Stamp* stamp)
 272 {
 273     HLAAbstractFixedRecordDataElement::_setStamp(stamp);
 274     for (FieldVector::iterator i = _fieldVector.begin(); i != _fieldVector.end(); ++i) {
 275         if (!i->valid())
 276             continue;
 277         (*i)->attachStamp(*this);
 278     }
 279 }
 280
 281 }