FGFS-4.1/simgear
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

hla: Timestamp support down to the DataElements.

Browse Source
This commit is contained in:
Mathias Froehlich 2012-03-02 21:36:08 +01:00
parent e4e3760b3d
commit a07ca86207
9 changed files with 196 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
simgear/hla/HLAArrayDataElement.cxx
View File

@ -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;
}

6
simgear/hla/HLAArrayDataElement.hxx
View File

@ -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();

51
simgear/hla/HLADataElement.cxx
View File

@ -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;
}
}

84
simgear/hla/HLADataElement.hxx
View File

@ -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;
// };
/// 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);
// const TimeStamp* getTimeStamp() const
// { return _timeStamp.get(); }
// void setTimeStamp(const TimeStamp* timeStamp)
// { _timeStamp = timeStamp; }
bool getTimeStampValid() const
{ if (!_stamp.valid()) return false; return _stamp->getTimeStampValid(); }
void setTimeStampValid(bool timeStampValid);
// struct ChangeCount : public SGReferenced {
// ChangeCount() : _value(0) {}
// unsigned _value;
// };
// SGSharedPtr<ChangeCount> _changeCount;
// unsigned getChangeCount() const
// {
// // If we don't have return allways the same
// if (!_changeCount.valid())
// return 0;
// return _changeCount->_value;
// }
/// 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<const TimeStamp> _timeStamp;
SGSharedPtr<Stamp> _stamp;
};
class HLADataElementProvider {

16
simgear/hla/HLAFixedRecordDataElement.cxx
View File

@ -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);
}
}
}

3
simgear/hla/HLAFixedRecordDataElement.hxx
View File

@ -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<SGSharedPtr<HLADataElement> > FieldVector;
FieldVector _fieldVector;

8
simgear/hla/HLAObjectInstance.cxx
View File

@ -116,7 +116,11 @@ HLAObjectInstance::setAttributeDataElement(unsigned index, const SGSharedPtr<HLA
if (numAttributes <= index)
return;
_attributeVector.resize(numAttributes);
if (_attributeVector[index]._dataElement.valid())
_attributeVector[index]._dataElement->clearStamp();
_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);
}

16
simgear/hla/HLAVariantRecordDataElement.cxx
View File

@ -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;
}
}

3
simgear/hla/HLAVariantRecordDataElement.hxx
View File

@ -71,6 +71,9 @@ public:
void setDataElementFactory(DataElementFactory* dataElementFactory);
DataElementFactory* getDataElementFactory();
protected:
virtual void _setStamp(Stamp* stamp);
private:
HLADataElement* newElement(unsigned index);