simgear/hla/HLAArrayDataElement.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 "HLAArrayDataElement.hxx"
  19
  20 #include <simgear/debug/logstream.hxx>
  21
  22 #include "HLADataElementVisitor.hxx"
  23
  24 namespace simgear {
  25
  26 HLAAbstractArrayDataElement::HLAAbstractArrayDataElement(const HLAArrayDataType* dataType) :
  27     _dataType(dataType)
  28 {
  29 }
  30
  31 HLAAbstractArrayDataElement::~HLAAbstractArrayDataElement()
  32 {
  33 }
  34
  35 void
  36 HLAAbstractArrayDataElement::accept(HLADataElementVisitor& visitor)
  37 {
  38     visitor.apply(*this);
  39 }
  40
  41 void
  42 HLAAbstractArrayDataElement::accept(HLAConstDataElementVisitor& visitor) const
  43 {
  44     visitor.apply(*this);
  45 }
  46
  47 bool
  48 HLAAbstractArrayDataElement::decode(HLADecodeStream& stream)
  49 {
  50     if (!_dataType.valid())
  51         return false;
  52     return _dataType->decode(stream, *this);
  53 }
  54
  55 bool
  56 HLAAbstractArrayDataElement::encode(HLAEncodeStream& stream) const
  57 {
  58     if (!_dataType.valid())
  59         return false;
  60     return _dataType->encode(stream, *this);
  61 }
  62
  63 const HLAArrayDataType*
  64 HLAAbstractArrayDataElement::getDataType() const
  65 {
  66     return _dataType.get();
  67 }
  68
  69 bool
  70 HLAAbstractArrayDataElement::setDataType(const HLADataType* dataType)
  71 {
  72     const HLAArrayDataType* arrayDataType = dynamic_cast<const HLAArrayDataType*>(dataType);
  73     if (!arrayDataType) {
  74         SG_LOG(SG_NETWORK, SG_WARN, "HLAArrayDataType: unable to set data type!");
  75         return false;
  76     }
  77     _dataType = arrayDataType;
  78     return true;
  79 }
  80
  81 const HLADataType*
  82 HLAAbstractArrayDataElement::getElementDataType() const
  83 {
  84     if (!_dataType.valid())
  85         return 0;
  86     return _dataType->getElementDataType();
  87 }
  88
  89 ////////////////////////////////////////////////////////////////////////
  90
  91 HLAArrayDataElement::DataElementFactory::~DataElementFactory()
  92 {
  93 }
  94
  95 HLAArrayDataElement::HLAArrayDataElement(const HLAArrayDataType* dataType) :
  96     HLAAbstractArrayDataElement(dataType)
  97 {
  98 }
  99
 100 HLAArrayDataElement::~HLAArrayDataElement()
 101 {
 102     clearStamp();
 103 }
 104
 105 bool
 106 HLAArrayDataElement::setNumElements(unsigned size)
 107 {
 108     unsigned oldSize = _elementVector.size();
 109     if (size == oldSize)
 110         return true;
 111     _elementVector.resize(size);
 112     for (unsigned i = oldSize; i < size; ++i)
 113         _elementVector[i] = newElement(i);
 114     return true;
 115 }
 116
 117 bool
 118 HLAArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
 119 {
 120     HLADataElement* dataElement = getElement(i);
 121     if (!dataElement)
 122         return false;
 123     return dataElement->decode(stream);
 124 }
 125
 126 unsigned
 127 HLAArrayDataElement::getNumElements() const
 128 {
 129     return _elementVector.size();
 130 }
 131
 132 bool
 133 HLAArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
 134 {
 135     const HLADataElement* dataElement = getElement(i);
 136     if (!dataElement)
 137         return false;
 138     return dataElement->encode(stream);
 139 }
 140
 141 const HLADataElement*
 142 HLAArrayDataElement::getElement(unsigned index) const
 143 {
 144     if (_elementVector.size() <= index)
 145         return 0;
 146     return _elementVector[index].get();
 147 }
 148
 149 HLADataElement*
 150 HLAArrayDataElement::getElement(unsigned index)
 151 {
 152     if (_elementVector.size() <= index)
 153         return 0;
 154     return _elementVector[index].get();
 155 }
 156
 157 HLADataElement*
 158 HLAArrayDataElement::getOrCreateElement(unsigned index)
 159 {
 160     if (_elementVector.size() <= index)
 161         if (!setNumElements(index + 1))
 162             return 0;
 163     return _elementVector[index].get();
 164 }
 165
 166 void
 167 HLAArrayDataElement::setElement(unsigned index, HLADataElement* value)
 168 {
 169     unsigned oldSize = _elementVector.size();
 170     if (oldSize <= index) {
 171         _elementVector.resize(index + 1);
 172         for (unsigned j = oldSize; j < index; ++j)
 173             _elementVector[j] = newElement(j);
 174     }
 175     if (_elementVector[index].valid())
 176         _elementVector[index]->clearStamp();
 177     _elementVector[index] = value;
 178     if (value)
 179         value->attachStamp(*this);
 180 }
 181
 182 void
 183 HLAArrayDataElement::setDataElementFactory(HLAArrayDataElement::DataElementFactory* dataElementFactory)
 184 {
 185     _dataElementFactory = dataElementFactory;
 186 }
 187
 188 HLAArrayDataElement::DataElementFactory*
 189 HLAArrayDataElement::getDataElementFactory()
 190 {
 191     return _dataElementFactory.get();
 192 }
 193
 194 void
 195 HLAArrayDataElement::_setStamp(Stamp* stamp)
 196 {
 197     HLAAbstractArrayDataElement::_setStamp(stamp);
 198     for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
 199         if (!i->valid())
 200             continue;
 201         (*i)->attachStamp(*this);
 202     }
 203 }
 204
 205 HLADataElement*
 206 HLAArrayDataElement::newElement(unsigned index)
 207 {
 208     if (!_dataElementFactory.valid())
 209         return 0;
 210     HLADataElement* dataElement = _dataElementFactory->createElement(*this, index);
 211     if (!dataElement)
 212         return 0;
 213     dataElement->attachStamp(*this);
 214     return dataElement;
 215 }
 216
 217 ////////////////////////////////////////////////////////////////////////
 218
 219 HLAVariantArrayDataElement::HLAVariantArrayDataElement() :
 220     HLAAbstractArrayDataElement(0)
 221 {
 222 }
 223
 224 HLAVariantArrayDataElement::~HLAVariantArrayDataElement()
 225 {
 226     clearStamp();
 227 }
 228
 229 bool
 230 HLAVariantArrayDataElement::setDataType(const HLADataType* dataType)
 231 {
 232     const HLAArrayDataType* arrayDataType = dataType->toArrayDataType();
 233     if (!arrayDataType) {
 234         SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type, dataType is not an array data type!");
 235         return false;
 236     }
 237     const HLAVariantRecordDataType* variantRecordDataType = arrayDataType->getElementDataType()->toVariantRecordDataType();
 238     if (!variantRecordDataType) {
 239         SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type: arrayDataTypes element data type is no a variant data type!");
 240         return false;
 241     }
 242     _dataType = arrayDataType;
 243     return true;
 244 }
 245
 246 bool
 247 HLAVariantArrayDataElement::setNumElements(unsigned size)
 248 {
 249     unsigned oldSize = _elementVector.size();
 250     if (size == oldSize)
 251         return true;
 252     _elementVector.resize(size);
 253     for (unsigned i = oldSize; i < size; ++i)
 254         _elementVector[i] = newElement();
 255     return true;
 256 }
 257
 258 bool
 259 HLAVariantArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
 260 {
 261     HLAVariantRecordDataElement* dataElement = getElement(i);
 262     if (!dataElement)
 263         return false;
 264     return dataElement->decode(stream);
 265 }
 266
 267 unsigned
 268 HLAVariantArrayDataElement::getNumElements() const
 269 {
 270     return _elementVector.size();
 271 }
 272
 273 bool
 274 HLAVariantArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
 275 {
 276     const HLADataElement* dataElement = getElement(i);
 277     if (!dataElement)
 278         return false;
 279     return dataElement->encode(stream);
 280 }
 281
 282 const HLAVariantRecordDataElement*
 283 HLAVariantArrayDataElement::getElement(unsigned index) const
 284 {
 285     if (_elementVector.size() <= index)
 286         return 0;
 287     return _elementVector[index].get();
 288 }
 289
 290 HLAVariantRecordDataElement*
 291 HLAVariantArrayDataElement::getElement(unsigned index)
 292 {
 293     if (_elementVector.size() <= index)
 294         return 0;
 295     return _elementVector[index].get();
 296 }
 297
 298 HLAVariantRecordDataElement*
 299 HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
 300 {
 301     if (_elementVector.size() <= index)
 302         if (!setNumElements(index + 1))
 303             return 0;
 304     return _elementVector[index].get();
 305 }
 306
 307 void
 308 HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantRecordDataElement* value)
 309 {
 310     unsigned oldSize = _elementVector.size();
 311     if (oldSize <= index) {
 312         _elementVector.resize(index + 1);
 313         for (unsigned j = oldSize; j < index; ++j)
 314             _elementVector[j] = newElement();
 315     }
 316     if (_elementVector[index].valid())
 317         _elementVector[index]->clearStamp();
 318     _elementVector[index] = value;
 319     if (value)
 320         value->attachStamp(*this);
 321 }
 322
 323 void
 324 HLAVariantArrayDataElement::setAlternativeDataElementFactory(HLAVariantArrayDataElement::AlternativeDataElementFactory* alternativeDataElementFactory)
 325 {
 326     _alternativeDataElementFactory = alternativeDataElementFactory;
 327 }
 328
 329 HLAVariantArrayDataElement::AlternativeDataElementFactory*
 330 HLAVariantArrayDataElement::getAlternativeDataElementFactory()
 331 {
 332     return _alternativeDataElementFactory.get();
 333 }
 334
 335 void
 336 HLAVariantArrayDataElement::_setStamp(Stamp* stamp)
 337 {
 338     HLAAbstractArrayDataElement::_setStamp(stamp);
 339     for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
 340         if (!i->valid())
 341             continue;
 342         (*i)->attachStamp(*this);
 343     }
 344 }
 345
 346 HLAVariantRecordDataElement*
 347 HLAVariantArrayDataElement::newElement()
 348 {
 349     const HLAArrayDataType* arrayDataType = getDataType();
 350     if (!arrayDataType)
 351         return 0;
 352     const HLADataType* elementDataType = arrayDataType->getElementDataType();
 353     if (!elementDataType)
 354         return 0;
 355     const HLAVariantRecordDataType* variantRecordDataType = elementDataType->toVariantRecordDataType();
 356     if (!variantRecordDataType)
 357         return 0;
 358     HLAVariantRecordDataElement* variantRecordDataElement = new HLAVariantRecordDataElement(variantRecordDataType);
 359     variantRecordDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
 360     variantRecordDataElement->attachStamp(*this);
 361     return variantRecordDataElement;
 362 }
 363
 364 }