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     setDirty(true);
 115     return true;
 116 }
 117
 118 bool
 119 HLAArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
 120 {
 121     HLADataElement* dataElement = getElement(i);
 122     if (!dataElement)
 123         return false;
 124     return dataElement->decode(stream);
 125 }
 126
 127 unsigned
 128 HLAArrayDataElement::getNumElements() const
 129 {
 130     return _elementVector.size();
 131 }
 132
 133 bool
 134 HLAArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
 135 {
 136     const HLADataElement* dataElement = getElement(i);
 137     if (!dataElement)
 138         return false;
 139     return dataElement->encode(stream);
 140 }
 141
 142 const HLADataElement*
 143 HLAArrayDataElement::getElement(unsigned index) const
 144 {
 145     if (_elementVector.size() <= index)
 146         return 0;
 147     return _elementVector[index].get();
 148 }
 149
 150 HLADataElement*
 151 HLAArrayDataElement::getElement(unsigned index)
 152 {
 153     if (_elementVector.size() <= index)
 154         return 0;
 155     return _elementVector[index].get();
 156 }
 157
 158 HLADataElement*
 159 HLAArrayDataElement::getOrCreateElement(unsigned index)
 160 {
 161     if (_elementVector.size() <= index)
 162         if (!setNumElements(index + 1))
 163             return 0;
 164     return _elementVector[index].get();
 165 }
 166
 167 void
 168 HLAArrayDataElement::setElement(unsigned index, HLADataElement* value)
 169 {
 170     unsigned oldSize = _elementVector.size();
 171     if (oldSize <= index) {
 172         _elementVector.resize(index + 1);
 173         for (unsigned j = oldSize; j < index; ++j)
 174             _elementVector[j] = newElement(j);
 175     }
 176     if (_elementVector[index].valid())
 177         _elementVector[index]->clearStamp();
 178     _elementVector[index] = value;
 179     if (value)
 180         value->attachStamp(*this);
 181     setDirty(true);
 182 }
 183
 184 void
 185 HLAArrayDataElement::setDataElementFactory(HLAArrayDataElement::DataElementFactory* dataElementFactory)
 186 {
 187     _dataElementFactory = dataElementFactory;
 188 }
 189
 190 HLAArrayDataElement::DataElementFactory*
 191 HLAArrayDataElement::getDataElementFactory()
 192 {
 193     return _dataElementFactory.get();
 194 }
 195
 196 void
 197 HLAArrayDataElement::_setStamp(Stamp* stamp)
 198 {
 199     HLAAbstractArrayDataElement::_setStamp(stamp);
 200     for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
 201         if (!i->valid())
 202             continue;
 203         (*i)->attachStamp(*this);
 204     }
 205 }
 206
 207 HLADataElement*
 208 HLAArrayDataElement::newElement(unsigned index)
 209 {
 210     if (!_dataElementFactory.valid())
 211         return 0;
 212     HLADataElement* dataElement = _dataElementFactory->createElement(*this, index);
 213     if (!dataElement)
 214         return 0;
 215     dataElement->attachStamp(*this);
 216     return dataElement;
 217 }
 218
 219 ////////////////////////////////////////////////////////////////////////
 220
 221 HLAVariantArrayDataElement::HLAVariantArrayDataElement() :
 222     HLAAbstractArrayDataElement(0)
 223 {
 224 }
 225
 226 HLAVariantArrayDataElement::~HLAVariantArrayDataElement()
 227 {
 228     clearStamp();
 229 }
 230
 231 bool
 232 HLAVariantArrayDataElement::setDataType(const HLADataType* dataType)
 233 {
 234     const HLAArrayDataType* arrayDataType = dataType->toArrayDataType();
 235     if (!arrayDataType) {
 236         SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type, dataType is not an array data type!");
 237         return false;
 238     }
 239     const HLAVariantRecordDataType* variantRecordDataType = arrayDataType->getElementDataType()->toVariantRecordDataType();
 240     if (!variantRecordDataType) {
 241         SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type: arrayDataTypes element data type is no a variant data type!");
 242         return false;
 243     }
 244     _dataType = arrayDataType;
 245     return true;
 246 }
 247
 248 bool
 249 HLAVariantArrayDataElement::setNumElements(unsigned size)
 250 {
 251     unsigned oldSize = _elementVector.size();
 252     if (size == oldSize)
 253         return true;
 254     _elementVector.resize(size);
 255     for (unsigned i = oldSize; i < size; ++i)
 256         _elementVector[i] = newElement();
 257     setDirty(true);
 258     return true;
 259 }
 260
 261 bool
 262 HLAVariantArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
 263 {
 264     HLAVariantRecordDataElement* dataElement = getElement(i);
 265     if (!dataElement)
 266         return false;
 267     return dataElement->decode(stream);
 268 }
 269
 270 unsigned
 271 HLAVariantArrayDataElement::getNumElements() const
 272 {
 273     return _elementVector.size();
 274 }
 275
 276 bool
 277 HLAVariantArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
 278 {
 279     const HLADataElement* dataElement = getElement(i);
 280     if (!dataElement)
 281         return false;
 282     return dataElement->encode(stream);
 283 }
 284
 285 const HLAVariantRecordDataElement*
 286 HLAVariantArrayDataElement::getElement(unsigned index) const
 287 {
 288     if (_elementVector.size() <= index)
 289         return 0;
 290     return _elementVector[index].get();
 291 }
 292
 293 HLAVariantRecordDataElement*
 294 HLAVariantArrayDataElement::getElement(unsigned index)
 295 {
 296     if (_elementVector.size() <= index)
 297         return 0;
 298     return _elementVector[index].get();
 299 }
 300
 301 HLAVariantRecordDataElement*
 302 HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
 303 {
 304     if (_elementVector.size() <= index)
 305         if (!setNumElements(index + 1))
 306             return 0;
 307     return _elementVector[index].get();
 308 }
 309
 310 void
 311 HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantRecordDataElement* value)
 312 {
 313     unsigned oldSize = _elementVector.size();
 314     if (oldSize <= index) {
 315         _elementVector.resize(index + 1);
 316         for (unsigned j = oldSize; j < index; ++j)
 317             _elementVector[j] = newElement();
 318     }
 319     if (_elementVector[index].valid())
 320         _elementVector[index]->clearStamp();
 321     _elementVector[index] = value;
 322     if (value)
 323         value->attachStamp(*this);
 324     setDirty(true);
 325 }
 326
 327 void
 328 HLAVariantArrayDataElement::setAlternativeDataElementFactory(HLAVariantArrayDataElement::AlternativeDataElementFactory* alternativeDataElementFactory)
 329 {
 330     _alternativeDataElementFactory = alternativeDataElementFactory;
 331 }
 332
 333 HLAVariantArrayDataElement::AlternativeDataElementFactory*
 334 HLAVariantArrayDataElement::getAlternativeDataElementFactory()
 335 {
 336     return _alternativeDataElementFactory.get();
 337 }
 338
 339 void
 340 HLAVariantArrayDataElement::_setStamp(Stamp* stamp)
 341 {
 342     HLAAbstractArrayDataElement::_setStamp(stamp);
 343     for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
 344         if (!i->valid())
 345             continue;
 346         (*i)->attachStamp(*this);
 347     }
 348 }
 349
 350 HLAVariantRecordDataElement*
 351 HLAVariantArrayDataElement::newElement()
 352 {
 353     const HLAArrayDataType* arrayDataType = getDataType();
 354     if (!arrayDataType)
 355         return 0;
 356     const HLADataType* elementDataType = arrayDataType->getElementDataType();
 357     if (!elementDataType)
 358         return 0;
 359     const HLAVariantRecordDataType* variantRecordDataType = elementDataType->toVariantRecordDataType();
 360     if (!variantRecordDataType)
 361         return 0;
 362     HLAVariantRecordDataElement* variantRecordDataElement = new HLAVariantRecordDataElement(variantRecordDataType);
 363     variantRecordDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
 364     variantRecordDataElement->attachStamp(*this);
 365     return variantRecordDataElement;
 366 }
 367
 368 }