-// Copyright (C) 2009 - 2010 Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012 Mathias Froehlich - Mathias.Froehlich@web.de
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
+#ifdef HAVE_CONFIG_H
+# include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
#include "HLAArrayDataElement.hxx"
#include <simgear/debug/logstream.hxx>
+#include "HLADataElementVisitor.hxx"
+
namespace simgear {
HLAAbstractArrayDataElement::HLAAbstractArrayDataElement(const HLAArrayDataType* dataType) :
{
}
+void
+HLAAbstractArrayDataElement::accept(HLADataElementVisitor& visitor)
+{
+ visitor.apply(*this);
+}
+
+void
+HLAAbstractArrayDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+ visitor.apply(*this);
+}
+
bool
HLAAbstractArrayDataElement::decode(HLADecodeStream& stream)
{
HLAArrayDataElement::~HLAArrayDataElement()
{
+ clearStamp();
+}
+
+bool
+HLAArrayDataElement::setDataElement(HLADataElementIndex::const_iterator begin, HLADataElementIndex::const_iterator end, HLADataElement* dataElement)
+{
+ // Must have happened in the parent
+ if (begin == end)
+ return false;
+ unsigned index = *begin;
+ if (++begin != end) {
+ if (getNumElements() <= index && !setNumElements(index + 1))
+ return false;
+ if (!getElement(index) && getElementDataType()) {
+ HLADataElementFactoryVisitor visitor;
+ getElementDataType()->accept(visitor);
+ setElement(index, visitor.getDataElement());
+ }
+ if (!getElement(index))
+ return false;
+ return getElement(index)->setDataElement(begin, end, dataElement);
+ } else {
+ if (!dataElement->setDataType(getElementDataType()))
+ return false;
+ setElement(index, dataElement);
+ return true;
+ }
+}
+
+HLADataElement*
+HLAArrayDataElement::getDataElement(HLADataElementIndex::const_iterator begin, HLADataElementIndex::const_iterator end)
+{
+ if (begin == end)
+ return this;
+ HLADataElement* dataElement = getElement(*begin);
+ if (!dataElement)
+ return 0;
+ return dataElement->getDataElement(++begin, end);
+}
+
+const HLADataElement*
+HLAArrayDataElement::getDataElement(HLADataElementIndex::const_iterator begin, HLADataElementIndex::const_iterator end) const
+{
+ if (begin == end)
+ return this;
+ const HLADataElement* dataElement = getElement(*begin);
+ if (!dataElement)
+ return 0;
+ return dataElement->getDataElement(++begin, end);
+}
+
+bool
+HLAArrayDataElement::setDataType(const HLADataType* dataType)
+{
+ if (!HLAAbstractArrayDataElement::setDataType(dataType))
+ return false;
+ for (unsigned i = 0; i < getNumElements(); ++i) {
+ HLADataElement* dataElement = getElement(i);
+ if (!dataElement)
+ continue;
+ if (!dataElement->setDataType(getElementDataType()))
+ return false;
+ }
+ return true;
}
bool
_elementVector.resize(size);
for (unsigned i = oldSize; i < size; ++i)
_elementVector[i] = newElement(i);
+ setDirty(true);
return true;
}
for (unsigned j = oldSize; j < index; ++j)
_elementVector[j] = newElement(j);
}
+ if (_elementVector[index].valid())
+ _elementVector[index]->clearStamp();
_elementVector[index] = value;
+ if (value)
+ value->attachStamp(*this);
+ setDirty(true);
}
void
return _dataElementFactory.get();
}
+void
+HLAArrayDataElement::_setStamp(Stamp* stamp)
+{
+ HLAAbstractArrayDataElement::_setStamp(stamp);
+ for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
+ if (!i->valid())
+ continue;
+ (*i)->attachStamp(*this);
+ }
+}
+
HLADataElement*
HLAArrayDataElement::newElement(unsigned index)
{
if (!_dataElementFactory.valid())
return 0;
- return _dataElementFactory->createElement(*this, index);
+ HLADataElement* dataElement = _dataElementFactory->createElement(*this, index);
+ if (!dataElement)
+ return 0;
+ dataElement->attachStamp(*this);
+ return dataElement;
}
////////////////////////////////////////////////////////////////////////
HLAVariantArrayDataElement::~HLAVariantArrayDataElement()
{
+ clearStamp();
}
bool
SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type, dataType is not an array data type!");
return false;
}
- const HLAVariantDataType* variantDataType = arrayDataType->getElementDataType()->toVariantDataType();
- if (!variantDataType) {
+ const HLAVariantRecordDataType* variantRecordDataType = arrayDataType->getElementDataType()->toVariantRecordDataType();
+ if (!variantRecordDataType) {
SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type: arrayDataTypes element data type is no a variant data type!");
return false;
}
_elementVector.resize(size);
for (unsigned i = oldSize; i < size; ++i)
_elementVector[i] = newElement();
+ setDirty(true);
return true;
}
bool
HLAVariantArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
{
- HLAVariantDataElement* dataElement = getElement(i);
+ HLAVariantRecordDataElement* dataElement = getElement(i);
if (!dataElement)
return false;
return dataElement->decode(stream);
return dataElement->encode(stream);
}
-const HLAVariantDataElement*
+const HLAVariantRecordDataElement*
HLAVariantArrayDataElement::getElement(unsigned index) const
{
if (_elementVector.size() <= index)
return _elementVector[index].get();
}
-HLAVariantDataElement*
+HLAVariantRecordDataElement*
HLAVariantArrayDataElement::getElement(unsigned index)
{
if (_elementVector.size() <= index)
return _elementVector[index].get();
}
-HLAVariantDataElement*
+HLAVariantRecordDataElement*
HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
{
if (_elementVector.size() <= index)
}
void
-HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantDataElement* value)
+HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantRecordDataElement* value)
{
unsigned oldSize = _elementVector.size();
if (oldSize <= index) {
for (unsigned j = oldSize; j < index; ++j)
_elementVector[j] = newElement();
}
+ if (_elementVector[index].valid())
+ _elementVector[index]->clearStamp();
_elementVector[index] = value;
+ if (value)
+ value->attachStamp(*this);
+ setDirty(true);
}
void
return _alternativeDataElementFactory.get();
}
-HLAVariantDataElement*
+void
+HLAVariantArrayDataElement::_setStamp(Stamp* stamp)
+{
+ HLAAbstractArrayDataElement::_setStamp(stamp);
+ for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
+ if (!i->valid())
+ continue;
+ (*i)->attachStamp(*this);
+ }
+}
+
+HLAVariantRecordDataElement*
HLAVariantArrayDataElement::newElement()
{
const HLAArrayDataType* arrayDataType = getDataType();
const HLADataType* elementDataType = arrayDataType->getElementDataType();
if (!elementDataType)
return 0;
- const HLAVariantDataType* variantDataType = elementDataType->toVariantDataType();
- if (!variantDataType)
+ const HLAVariantRecordDataType* variantRecordDataType = elementDataType->toVariantRecordDataType();
+ if (!variantRecordDataType)
return 0;
- HLAVariantDataElement* variantDataElement = new HLAVariantDataElement(variantDataType);
- variantDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
- return variantDataElement;
+ HLAVariantRecordDataElement* variantRecordDataElement = new HLAVariantRecordDataElement(variantRecordDataType);
+ variantRecordDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
+ variantRecordDataElement->attachStamp(*this);
+ return variantRecordDataElement;
}
}