From a07ca86207108af66ca3335e4fcc11935c5ef079 Mon Sep 17 00:00:00 2001 From: Mathias Froehlich Date: Fri, 2 Mar 2012 21:36:08 +0100 Subject: [PATCH] hla: Timestamp support down to the DataElements. --- simgear/hla/HLAArrayDataElement.cxx | 39 ++++++++- simgear/hla/HLAArrayDataElement.hxx | 6 ++ simgear/hla/HLADataElement.cxx | 51 ++++++++++++ simgear/hla/HLADataElement.hxx | 88 ++++++++++++++------- simgear/hla/HLAFixedRecordDataElement.cxx | 16 ++++ simgear/hla/HLAFixedRecordDataElement.hxx | 3 + simgear/hla/HLAObjectInstance.cxx | 8 +- simgear/hla/HLAVariantRecordDataElement.cxx | 16 +++- simgear/hla/HLAVariantRecordDataElement.hxx | 3 + 9 files changed, 198 insertions(+), 32 deletions(-) diff --git a/simgear/hla/HLAArrayDataElement.cxx b/simgear/hla/HLAArrayDataElement.cxx index 3746cbd8..5fcbbd0a 100644 --- a/simgear/hla/HLAArrayDataElement.cxx +++ b/simgear/hla/HLAArrayDataElement.cxx @@ -99,6 +99,7 @@ HLAArrayDataElement::HLAArrayDataElement(const HLAArrayDataType* dataType) : HLAArrayDataElement::~HLAArrayDataElement() { + clearStamp(); } bool @@ -171,7 +172,11 @@ HLAArrayDataElement::setElement(unsigned index, HLADataElement* value) 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); } void @@ -186,12 +191,27 @@ HLAArrayDataElement::getDataElementFactory() 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; } //////////////////////////////////////////////////////////////////////// @@ -203,6 +223,7 @@ HLAVariantArrayDataElement::HLAVariantArrayDataElement() : HLAVariantArrayDataElement::~HLAVariantArrayDataElement() { + clearStamp(); } bool @@ -292,7 +313,11 @@ HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantRecordDataEleme 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); } void @@ -307,6 +332,17 @@ HLAVariantArrayDataElement::getAlternativeDataElementFactory() return _alternativeDataElementFactory.get(); } +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() { @@ -321,6 +357,7 @@ HLAVariantArrayDataElement::newElement() return 0; HLAVariantRecordDataElement* variantRecordDataElement = new HLAVariantRecordDataElement(variantRecordDataType); variantRecordDataElement->setDataElementFactory(_alternativeDataElementFactory.get()); + variantRecordDataElement->attachStamp(*this); return variantRecordDataElement; } diff --git a/simgear/hla/HLAArrayDataElement.hxx b/simgear/hla/HLAArrayDataElement.hxx index 8f510be5..4557d006 100644 --- a/simgear/hla/HLAArrayDataElement.hxx +++ b/simgear/hla/HLAArrayDataElement.hxx @@ -78,6 +78,9 @@ public: void setDataElementFactory(DataElementFactory* dataElementFactory); DataElementFactory* getDataElementFactory(); +protected: + virtual void _setStamp(Stamp* stamp); + private: HLADataElement* newElement(unsigned index); @@ -112,6 +115,9 @@ public: void setAlternativeDataElementFactory(AlternativeDataElementFactory* alternativeDataElementFactory); AlternativeDataElementFactory* getAlternativeDataElementFactory(); +protected: + virtual void _setStamp(Stamp* stamp); + private: HLAVariantRecordDataElement* newElement(); diff --git a/simgear/hla/HLADataElement.cxx b/simgear/hla/HLADataElement.cxx index b7da8884..0794f152 100644 --- a/simgear/hla/HLADataElement.cxx +++ b/simgear/hla/HLADataElement.cxx @@ -131,6 +131,51 @@ HLADataElement::~HLADataElement() { } +void +HLADataElement::setTimeStamp(const SGTimeStamp& timeStamp) +{ + if (!_stamp.valid()) + return; + _stamp->setTimeStamp(timeStamp); +} + +void +HLADataElement::setTimeStampValid(bool timeStampValid) +{ + if (!_stamp.valid()) + return; + _stamp->setTimeStampValid(timeStampValid); +} + +double +HLADataElement::getTimeDifference(const SGTimeStamp& timeStamp) const +{ + if (!_stamp.valid()) + return 0; + if (!_stamp->getTimeStampValid()) + return 0; + return (timeStamp - _stamp->getTimeStamp()).toSecs(); +} + +void +HLADataElement::createStamp() +{ + _setStamp(new Stamp); + setDirty(true); +} + +void +HLADataElement::attachStamp(HLADataElement& dataElement) +{ + _setStamp(dataElement._getStamp()); +} + +void +HLADataElement::clearStamp() +{ + _setStamp(0); +} + void HLADataElement::accept(HLADataElementVisitor& visitor) { @@ -198,4 +243,10 @@ HLADataElement::toStringPathPair(const std::string& s) return StringPathPair(attribute, path); } +void +HLADataElement::_setStamp(HLADataElement::Stamp* stamp) +{ + _stamp = stamp; +} + } diff --git a/simgear/hla/HLADataElement.hxx b/simgear/hla/HLADataElement.hxx index 35613d06..0cb14e61 100644 --- a/simgear/hla/HLADataElement.hxx +++ b/simgear/hla/HLADataElement.hxx @@ -46,34 +46,30 @@ public: virtual const HLADataType* getDataType() const = 0; virtual bool setDataType(const HLADataType* dataType) = 0; - // Container for the timestamp the originating attribute was last updated for - // class TimeStamp : public SGReferenced { - // public: - // const SGTimeStamp& getTimeStamp() const - // { return _timeStamp; } - // void setTimeStamp(const SGTimeStamp& timeStamp) - // { _timeStamp = timeStamp; } - // private: - // SGTimeStamp _timeStamp; - // }; - - // const TimeStamp* getTimeStamp() const - // { return _timeStamp.get(); } - // void setTimeStamp(const TimeStamp* timeStamp) - // { _timeStamp = timeStamp; } - - // struct ChangeCount : public SGReferenced { - // ChangeCount() : _value(0) {} - // unsigned _value; - // }; - // SGSharedPtr _changeCount; - // unsigned getChangeCount() const - // { - // // If we don't have return allways the same - // if (!_changeCount.valid()) - // return 0; - // return _changeCount->_value; - // } + /// Returns the time stamp if this data element. + /// Do not access this getter if the getTimeStampValid() method returns false. + const SGTimeStamp& getTimeStamp() const + { return _stamp->getTimeStamp(); } + void setTimeStamp(const SGTimeStamp& timeStamp); + + bool getTimeStampValid() const + { if (!_stamp.valid()) return false; return _stamp->getTimeStampValid(); } + void setTimeStampValid(bool timeStampValid); + + /// Convenience function that gives the time difference in seconds to a given timestamp + /// This function returns 0 if the timestamp is not valid. + double getTimeDifference(const SGTimeStamp& timeStamp) const; + + /// Dirty tracking of the attribute/parameter that this data element belongs to + bool getDirty() const + { if (!_stamp.valid()) return true; return _stamp->getDirty(); } + void setDirty(bool dirty) + { if (!_stamp.valid()) return; _stamp->setDirty(dirty); } + + /// Stamp handling + void createStamp(); + void attachStamp(HLADataElement& dataElement); + void clearStamp(); /// HLADataElements could be identified by path /// These paths are composed of structure field names and array indices in the @@ -163,8 +159,42 @@ public: static Path toPath(const std::string& s) { return toStringPathPair(s).second; } +protected: + // Container for the timestamp the originating attribute was last updated for + class Stamp : public SGReferenced { + public: + Stamp() : _timeStampValid(false), _dirty(true) + { } + + const SGTimeStamp& getTimeStamp() const + { return _timeStamp; } + void setTimeStamp(const SGTimeStamp& timeStamp) + { _timeStamp = timeStamp; } + + bool getTimeStampValid() const + { return _timeStampValid; } + void setTimeStampValid(bool timeStampValid) + { _timeStampValid = timeStampValid; } + + bool getDirty() const + { return _dirty; } + void setDirty(bool dirty) + { _dirty = dirty; } + + private: + SGTimeStamp _timeStamp; + bool _timeStampValid; + bool _dirty; + }; + + /// get the stamp + Stamp* _getStamp() const + { return _stamp.get(); } + /// Set the stamp + virtual void _setStamp(Stamp* stamp); + private: - // SGSharedPtr _timeStamp; + SGSharedPtr _stamp; }; class HLADataElementProvider { diff --git a/simgear/hla/HLAFixedRecordDataElement.cxx b/simgear/hla/HLAFixedRecordDataElement.cxx index c4c0c8b2..d04c2732 100644 --- a/simgear/hla/HLAFixedRecordDataElement.cxx +++ b/simgear/hla/HLAFixedRecordDataElement.cxx @@ -120,6 +120,7 @@ HLAFixedRecordDataElement::HLAFixedRecordDataElement(const HLAFixedRecordDataTyp HLAFixedRecordDataElement::~HLAFixedRecordDataElement() { + clearStamp(); } bool @@ -181,7 +182,11 @@ HLAFixedRecordDataElement::setField(unsigned index, HLADataElement* value) { if (getNumFields() <= index) return; + if (_fieldVector[index].valid()) + _fieldVector[index]->clearStamp(); _fieldVector[index] = value; + if (value) + value->attachStamp(*this); } void @@ -190,4 +195,15 @@ HLAFixedRecordDataElement::setField(const std::string& name, HLADataElement* val setField(getFieldNumber(name), value); } +void +HLAFixedRecordDataElement::_setStamp(Stamp* stamp) +{ + HLAAbstractFixedRecordDataElement::_setStamp(stamp); + for (FieldVector::iterator i = _fieldVector.begin(); i != _fieldVector.end(); ++i) { + if (!i->valid()) + continue; + (*i)->attachStamp(*this); + } +} + } diff --git a/simgear/hla/HLAFixedRecordDataElement.hxx b/simgear/hla/HLAFixedRecordDataElement.hxx index ca8ed997..7a471e8d 100644 --- a/simgear/hla/HLAFixedRecordDataElement.hxx +++ b/simgear/hla/HLAFixedRecordDataElement.hxx @@ -70,6 +70,9 @@ public: void setField(unsigned index, HLADataElement* value); void setField(const std::string& name, HLADataElement* value); +protected: + virtual void _setStamp(Stamp* stamp); + private: typedef std::vector > FieldVector; FieldVector _fieldVector; diff --git a/simgear/hla/HLAObjectInstance.cxx b/simgear/hla/HLAObjectInstance.cxx index 390b70db..f54ca8bb 100644 --- a/simgear/hla/HLAObjectInstance.cxx +++ b/simgear/hla/HLAObjectInstance.cxx @@ -116,7 +116,11 @@ HLAObjectInstance::setAttributeDataElement(unsigned index, const SGSharedPtrclearStamp(); _attributeVector[index]._dataElement = dataElement; + if (_attributeVector[index]._dataElement.valid()) + _attributeVector[index]._dataElement->createStamp(); if (getAttributeOwned(index)) encodeAttributeValue(index); } @@ -533,6 +537,7 @@ HLAObjectInstance::reflectAttributeValue(unsigned index, const RTIData& tag) HLADataElement* dataElement = getAttributeDataElement(index); if (!dataElement) return; + dataElement->setTimeStampValid(false); _rtiObjectInstance->decodeAttributeData(index, *dataElement); } @@ -542,7 +547,8 @@ HLAObjectInstance::reflectAttributeValue(unsigned index, const SGTimeStamp& time HLADataElement* dataElement = getAttributeDataElement(index); if (!dataElement) return; - // dataElement->setTimeStamp(timeStamp); + dataElement->setTimeStamp(timeStamp); + dataElement->setTimeStampValid(true); _rtiObjectInstance->decodeAttributeData(index, *dataElement); } diff --git a/simgear/hla/HLAVariantRecordDataElement.cxx b/simgear/hla/HLAVariantRecordDataElement.cxx index db8f1be0..e3ef35a1 100644 --- a/simgear/hla/HLAVariantRecordDataElement.cxx +++ b/simgear/hla/HLAVariantRecordDataElement.cxx @@ -113,6 +113,7 @@ HLAVariantRecordDataElement::HLAVariantRecordDataElement(const HLAVariantRecordD HLAVariantRecordDataElement::~HLAVariantRecordDataElement() { + clearStamp(); } bool @@ -158,12 +159,25 @@ HLAVariantRecordDataElement::getDataElementFactory() return _dataElementFactory; } +void +HLAVariantRecordDataElement::_setStamp(Stamp* stamp) +{ + HLAAbstractVariantRecordDataElement::_setStamp(stamp); + if (!_dataElement.valid()) + return; + _dataElement->attachStamp(*this); +} + HLADataElement* HLAVariantRecordDataElement::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; } } diff --git a/simgear/hla/HLAVariantRecordDataElement.hxx b/simgear/hla/HLAVariantRecordDataElement.hxx index 0f4f364f..cc76efbb 100644 --- a/simgear/hla/HLAVariantRecordDataElement.hxx +++ b/simgear/hla/HLAVariantRecordDataElement.hxx @@ -71,6 +71,9 @@ public: void setDataElementFactory(DataElementFactory* dataElementFactory); DataElementFactory* getDataElementFactory(); +protected: + virtual void _setStamp(Stamp* stamp); + private: HLADataElement* newElement(unsigned index); -- 2.39.5