simgear/hla/HLAVariantRecordDataElement.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 "HLAVariantRecordDataElement.hxx"
  19
  20 #include <simgear/debug/logstream.hxx>
  21
  22 #include "HLADataElementVisitor.hxx"
  23
  24 namespace simgear {
  25
  26 HLAAbstractVariantRecordDataElement::HLAAbstractVariantRecordDataElement(const HLAVariantRecordDataType* dataType) :
  27     _dataType(dataType)
  28 {
  29 }
  30
  31 HLAAbstractVariantRecordDataElement::~HLAAbstractVariantRecordDataElement()
  32 {
  33 }
  34
  35 void
  36 HLAAbstractVariantRecordDataElement::accept(HLADataElementVisitor& visitor)
  37 {
  38     visitor.apply(*this);
  39 }
  40
  41 void
  42 HLAAbstractVariantRecordDataElement::accept(HLAConstDataElementVisitor& visitor) const
  43 {
  44     visitor.apply(*this);
  45 }
  46
  47 bool
  48 HLAAbstractVariantRecordDataElement::decode(HLADecodeStream& stream)
  49 {
  50     if (!_dataType.valid())
  51         return false;
  52     return _dataType->decode(stream, *this);
  53 }
  54
  55 bool
  56 HLAAbstractVariantRecordDataElement::encode(HLAEncodeStream& stream) const
  57 {
  58     if (!_dataType.valid())
  59         return false;
  60     return _dataType->encode(stream, *this);
  61 }
  62
  63 const HLAVariantRecordDataType*
  64 HLAAbstractVariantRecordDataElement::getDataType() const
  65 {
  66     return _dataType.get();
  67 }
  68
  69 bool
  70 HLAAbstractVariantRecordDataElement::setDataType(const HLADataType* dataType)
  71 {
  72     const HLAVariantRecordDataType* variantRecordDataType = dataType->toVariantRecordDataType();
  73     if (!variantRecordDataType) {
  74         SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantRecordDataType: unable to set data type!");
  75         return false;
  76     }
  77     setDataType(variantRecordDataType);
  78     return true;
  79 }
  80
  81 void
  82 HLAAbstractVariantRecordDataElement::setDataType(const HLAVariantRecordDataType* dataType)
  83 {
  84     _dataType = dataType;
  85 }
  86
  87 std::string
  88 HLAAbstractVariantRecordDataElement::getAlternativeName() const
  89 {
  90     if (!_dataType.valid())
  91         return std::string();
  92     return _dataType->getAlternativeName(getAlternativeIndex());
  93 }
  94
  95 const HLADataType*
  96 HLAAbstractVariantRecordDataElement::getAlternativeDataType() const
  97 {
  98     if (!_dataType.valid())
  99         return 0;
 100     return _dataType->getAlternativeDataType(getAlternativeIndex());
 101 }
 102
 103
 104 HLAVariantRecordDataElement::DataElementFactory::~DataElementFactory()
 105 {
 106 }
 107
 108 HLAVariantRecordDataElement::HLAVariantRecordDataElement(const HLAVariantRecordDataType* dataType) :
 109     HLAAbstractVariantRecordDataElement(dataType),
 110     _alternativeIndex(~0u)
 111 {
 112 }
 113
 114 HLAVariantRecordDataElement::~HLAVariantRecordDataElement()
 115 {
 116     clearStamp();
 117 }
 118
 119 bool
 120 HLAVariantRecordDataElement::setAlternativeIndex(unsigned index)
 121 {
 122     if (_alternativeIndex == index)
 123         return true;
 124     SGSharedPtr<HLADataElement> dataElement = newElement(index);
 125     if (!dataElement.valid())
 126         return false;
 127     _dataElement.swap(dataElement);
 128     _alternativeIndex = index;
 129     setDirty(true);
 130     return true;
 131 }
 132
 133 bool
 134 HLAVariantRecordDataElement::decodeAlternative(HLADecodeStream& stream)
 135 {
 136     return _dataElement->decode(stream);
 137 }
 138
 139 unsigned
 140 HLAVariantRecordDataElement::getAlternativeIndex() const
 141 {
 142     return _alternativeIndex;
 143 }
 144
 145 bool
 146 HLAVariantRecordDataElement::encodeAlternative(HLAEncodeStream& stream) const
 147 {
 148     return _dataElement->encode(stream);
 149 }
 150
 151 void
 152 HLAVariantRecordDataElement::setDataElementFactory(HLAVariantRecordDataElement::DataElementFactory* dataElementFactory)
 153 {
 154     _dataElementFactory = dataElementFactory;
 155 }
 156
 157 HLAVariantRecordDataElement::DataElementFactory*
 158 HLAVariantRecordDataElement::getDataElementFactory()
 159 {
 160     return _dataElementFactory;
 161 }
 162
 163 void
 164 HLAVariantRecordDataElement::_setStamp(Stamp* stamp)
 165 {
 166     HLAAbstractVariantRecordDataElement::_setStamp(stamp);
 167     if (!_dataElement.valid())
 168         return;
 169     _dataElement->attachStamp(*this);
 170 }
 171
 172 HLADataElement*
 173 HLAVariantRecordDataElement::newElement(unsigned index)
 174 {
 175     if (!_dataElementFactory.valid())
 176         return 0;
 177     HLADataElement* dataElement = _dataElementFactory->createElement(*this, index);
 178     if (!dataElement)
 179         return 0;
 180     dataElement->attachStamp(*this);
 181     return dataElement;
 182 }
 183
 184 }