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