simgear/hla/HLAArrayDataElement.cxx

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