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