baseEntityStateRepository.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 1992-2025 MAK Technologies, Inc
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include "stateRepository.h"
#include <vlpi/trigonometricSmoother.h>
#include <vlpi/thresholder.h>
#include <vlpi/entityType.h>
#include <vlutil/vlTime.h>
#include <matrix/vlDcm.h>

class DT_DLL_VL DtApproximator;
class DT_DLL_VL DtDeadReckoner;

#if DtHLA
class DT_DLL_VL DtHlaObjectManager;
#else
class DT_DLL_VL DtDisObjectManager;
#endif


class DT_DLL_VL DtBaseEntityStateRepository : public DtStateRepository
{
public:

   DtBaseEntityStateRepository();

   virtual ~DtBaseEntityStateRepository();

   DtBaseEntityStateRepository(const DtBaseEntityStateRepository& orig);

   DtBaseEntityStateRepository& operator=(
      const DtBaseEntityStateRepository& orig);

   virtual DtStateRepository* clone(bool copy = false) const; 

   void setTimeStampType(DtTimeStampType type);
   DtTimeStampType timeStampType() const;


   
   virtual void setAll(
      const DtVector& loc,
      const DtVector32& vel,
      const DtTaitBryan& ori,
      const DtVector32& acc,
      const DtVector32& rotVel,
      DtTime t);

   virtual void setAll(
      const DtVector& loc,
      const DtVector32& vel,
      const DtTaitBryan& ori,
      const DtVector32& acc,
      const DtVector32& rotVel);

   virtual void setLocation(const DtVector & location, DtTime aTime);
   virtual void setLocation(const DtVector & location);


   virtual const DtVector &location(DtTime aTime) const;
   virtual const DtVector &location() const;


   virtual const DtVector & lastSetLocation() const;

   virtual void setVelocity(const DtVector32 & Velocity, DtTime aTime);
   virtual void setVelocity(const DtVector32 & Velocity);
   virtual const DtVector32 & velocity(DtTime aTime) const;
   virtual const DtVector32 & velocity() const;


   virtual const DtVector32 & lastSetVelocity() const;

   virtual void setAcceleration(const DtVector32 & Acceleration, DtTime aTime);
   virtual void setAcceleration(const DtVector32 & Acceleration);
   virtual const DtVector32 & acceleration(DtTime aTime) const;
   virtual const DtVector32 & acceleration() const;

   virtual const DtVector32 & lastSetAcceleration() const;

   virtual void setOrientation(const DtTaitBryan& orient, DtTime aTime);
   virtual void setOrientation(const DtTaitBryan& orient);

   virtual const DtTaitBryan& orientation(DtTime aTime) const;
   virtual const DtTaitBryan& orientation() const;

   virtual const DtTaitBryan& lastSetOrientation() const;

   virtual void setRotationalVelocity(const DtVector32 & BodyRates, DtTime aTime);
   virtual void setRotationalVelocity(const DtVector32 & BodyRates);
   virtual const DtVector32 & rotationalVelocity(DtTime aTime) const;
   virtual const DtVector32 & rotationalVelocity() const;

   virtual const DtVector32 & lastSetRotationalVelocity() const;
   
   virtual void setFrozen(bool on);
   virtual bool frozen() const;

   virtual void setAlgorithm(DtDeadReckonTypes alg);

   virtual DtDeadReckonTypes algorithm() const;

   static void setDefaultDeadReckoner(DtDeadReckoner* val);

   static void setDefaultSmoother(DtSmoother* val);

   static void setDefaultRelativeDeadReckoner(DtDeadReckoner* val);

   static void setDefaultRelativeSmoother(DtSmoother* val);





   virtual void setRelativeLocation(const DtVector & location, DtTime aTime);
   virtual void setRelativeLocation(const DtVector & location);
   virtual const DtVector & relativeLocation(DtTime aTime) const;
   virtual const DtVector & relativeLocation() const;

   virtual const DtVector & lastSetRelativeLocation() const;

   virtual void setRelativeVelocity(const DtVector32 & Velocity, DtTime aTime);
   virtual void setRelativeVelocity(const DtVector32 & Velocity);
   virtual const DtVector32 & relativeVelocity(DtTime aTime) const;
   virtual const DtVector32 & relativeVelocity() const;

   virtual const DtVector32 & lastSetRelativeVelocity() const;

   virtual void setRelativeAcceleration(const DtVector32 & Acceleration, 
      DtTime aTime);
   virtual void setRelativeAcceleration(const DtVector32 & Acceleration);
   virtual const DtVector32 & relativeAcceleration(DtTime aTime) const;
   virtual const DtVector32 & relativeAcceleration() const;

   virtual const DtVector32 & lastSetRelativeAcceleration() const;

   virtual void setRelativeOrientation(const DtTaitBryan& orient, 
      DtTime aTime);
   virtual void setRelativeOrientation(const DtTaitBryan& orient);
   virtual const DtTaitBryan& relativeOrientation(DtTime aTime) const;
   virtual const DtTaitBryan& relativeOrientation() const;

   virtual const DtTaitBryan& lastSetRelativeOrientation() const;

   virtual void setRelativeRotationalVelocity(const DtVector32 & BodyRates, 
      DtTime aTime);
   virtual void setRelativeRotationalVelocity(const DtVector32 & BodyRates);
   virtual const DtVector32 & relativeRotationalVelocity(DtTime aTime) const;
   virtual const DtVector32 & relativeRotationalVelocity() const;
   
   virtual const DtVector32 & lastSetRelativeRotationalVelocity() const;
   
   virtual void setRelativeFrozen(bool onOff);
   virtual bool relativeFrozen() const;

   virtual void setRelativeAlgorithm(DtDeadReckonTypes alg);
   virtual DtDeadReckonTypes relativeAlgorithm() const;

   


   virtual const DtGlobalObjectDesignator& hostGlobalId() const;

   virtual void setHostGlobalId( const DtGlobalObjectDesignator& id );

   virtual void clearHostGlobalId();

   virtual const DtNature& nature() const;
   virtual void setNature( const DtNature newVal );

   virtual const DtPosition& partPosition() const;
   virtual void setPartPosition( const DtPosition newVal );

   virtual const DtStationName& stationName() const;
   virtual void setStationName( const DtStationName newVal );

   virtual const DtU16& stationNumber() const;
   virtual void setStationNumber( const DtU16 newVal );

   virtual const DtVector & relativePosition() const;
   virtual void setRelativePosition( const DtVector & newVal );

   virtual const DtFloat32& range() const;
   virtual void setRange( const DtFloat32 newVal );

   virtual const DtFloat32& bearing() const;
   virtual void setBearing( const DtFloat32 newVal );
   




#if DtHLA
   virtual void setHlaObjectManager( DtHlaObjectManager* mgr );
#else
   virtual void setDisObjectManager( DtDisObjectManager* mgr );
#endif

   virtual void setAmAsSeenByRemote( bool val );
   
   virtual const DtDcm & bodyToGeoc(DtTime aTime) const;
   virtual const DtDcm & bodyToGeoc() const;

   virtual const DtDcm & relativeBodyToHost(DtTime aTime) const;
   virtual const DtDcm & relativeBodyToHost() const;

   virtual void setEntityId(const DtEntityIdentifier& id);
   virtual const DtEntityIdentifier& entityId() const;

   virtual void setEntityType(const DtEntityType& type);
   virtual const DtEntityType& entityType() const;

#if DtHLA 
   virtual void setFederateId(const DtFederateId& id);
   virtual const DtFederateId& federateId() const;
#endif

   virtual void setApproximator(DtApproximator* approx);
   virtual DtApproximator* approximator() const;

   virtual void setRelativeApproximator(DtApproximator* approx);
   virtual DtApproximator* relativeApproximator() const;


   virtual void useDeadReckoner(DtDeadReckoner* dr);

   virtual void useRelativeDeadReckoner(DtDeadReckoner* dr);

   virtual void useDeadReckoner(bool yesNo = true);
   virtual void useRelativeDeadReckoner(bool yesNo = true);

   virtual DtDeadReckoner* usingDeadReckoner();
   virtual DtDeadReckoner* usingRelativeDeadReckoner();

   virtual void useSmoother(DtSmoother* sm);

   virtual void useRelativeSmoother(DtSmoother* sm);

   virtual void useSmoother(bool yesNo = true);
   virtual void useRelativeSmoother(bool yesNo = true);

   virtual DtSmoother* usingSmoother();
   virtual DtSmoother* usingRelativeSmoother();

   virtual DtThresholder* thresholder();

   virtual const DtThresholder& thresholder() const;

   virtual DtClock* clock() const;
   virtual void setClock(DtClock* clock);

   virtual void printData() const;

   void printDataToStream(std::ostream &str) const;

   friend class DtBaseEntityDecoder;
   virtual void setTimeForSets( DtTime time );
   virtual DtTime timeForSets() const;

   void computeSpatialFromRelativeSpatial();

protected:

   DtBaseEntityStateRepository* self() const;

public:

   DtBaseEntityStateRepository* hostEsr() const;

protected:

   DtClock* myClock;

   DtApproximator* myApproximator;
   DtApproximator* myRelativeApproximator;

   DtDeadReckoner* myDeadReckoner;
   DtDeadReckoner* myRelativeDeadReckoner;

   DtSmoother*     mySmoother;
   DtSmoother*     myRelativeSmoother;

   static DtDeadReckoner* theDfltDeadReckoner;
   static DtSmoother*     theDfltSmoother;
   static DtDeadReckoner* theDfltRelativeDeadReckoner;
   static DtSmoother*     theDfltRelativeSmoother;

   DtVector                  myLocation;
   DtVector32                myVelocity;
   DtVector32                myAcceleration;
   DtTaitBryan               myOrientation;
   DtVector32                myRotationalVelocity;
   DtDeadReckonTypes         myAlgorithm;
   bool                 myFrozen;

   DtVector                  myRelativeLocation;
   DtVector32                myRelativeVelocity;
   DtVector32                myRelativeAcceleration;
   DtTaitBryan               myRelativeOrientation;
   DtVector32                myRelativeRotationalVelocity;
   DtDeadReckonTypes         myRelativeAlgorithm;
   bool                 myRelativeFrozen;

   DtGlobalObjectDesignator  myHostGlobalId;
   bool                      myHostGlobalIdSetFlag;
   DtNature                  myNature;
   DtPosition                myPartPosition;
   DtStationName             myStationName;
   DtU16                     myStationNumber;
   DtVector                  myRelativePosition;
   DtFloat32                 myRange;
   DtFloat32                 myBearing;

#if DtHLA
   DtHlaObjectManager*       myObjectManager;
#else
   DtDisObjectManager*       myObjectManager;
#endif

   bool myAmAsSeenByRemote;

   DtVector                  myLastSetLocation;
   DtVector32                myLastSetVelocity;
   DtVector32                myLastSetAcceleration;
   DtTaitBryan               myLastSetOrientation;
   DtVector32                myLastSetRotationalVelocity;

   DtVector                  myLastSetRelativeLocation;
   DtVector32                myLastSetRelativeVelocity;
   DtVector32                myLastSetRelativeAcceleration;
   DtTaitBryan               myLastSetRelativeOrientation;
   DtVector32                myLastSetRelativeRotationalVelocity;

   DtDcm myBodyToGeoc;
   bool myBodyToGeocDirty;
   DtDcm myRelativeBodyToHost;
   bool myRelativeBodyToHostDirty;
   DtTimeStampType myTimeStampType;

   DtEntityIdentifier myEntityId;
#if DtHLA 
   mutable DtFederateId myFederateId;
#endif
   DtEntityType myEntityType;
   DtThresholder myThresholder;

protected:
   DtTime myTimeForSets;
};

inline DtThresholder* DtBaseEntityStateRepository::thresholder()
{
   return &myThresholder;
}

inline const DtThresholder& DtBaseEntityStateRepository::thresholder() const
{
   return myThresholder;
}

inline void DtBaseEntityStateRepository::setTimeStampType(
   DtTimeStampType type)
{
   myTimeStampType = type;
}

inline DtTimeStampType DtBaseEntityStateRepository::timeStampType() const
{
   return myTimeStampType;
}

inline const DtEntityType& DtBaseEntityStateRepository::entityType() const
{
   return myEntityType;
}

inline void DtBaseEntityStateRepository::setEntityType(
   const DtEntityType& type)
{
   myEntityType = type;
}

inline const DtEntityIdentifier& 
   DtBaseEntityStateRepository::entityId() const
{
   return myEntityId;
}

inline void DtBaseEntityStateRepository::setEntityId(
   const DtEntityIdentifier& id)
{
   myEntityId = id;
}

#if DtHLA
inline const DtFederateId& DtBaseEntityStateRepository::federateId() const
{
   myFederateId.setSiteId(myEntityId.site());
   myFederateId.setApplicationId(myEntityId.host());
   return myFederateId;
}

inline void DtBaseEntityStateRepository::setFederateId(
   const DtFederateId& id)
{
   myEntityId.setSite(id.siteId());
   myEntityId.setHost(id.applicationId());
}
#endif


inline const DtVector32 & DtBaseEntityStateRepository::lastSetRotationalVelocity(
   ) const
{
   return myLastSetRotationalVelocity;
}

inline const DtTaitBryan& DtBaseEntityStateRepository::lastSetOrientation(
   ) const
{
   return myLastSetOrientation;
}

inline const DtVector32 & DtBaseEntityStateRepository::lastSetAcceleration(
   ) const
{
   return myLastSetAcceleration;
}

inline const DtVector32 & DtBaseEntityStateRepository::lastSetVelocity() const
{
   return myLastSetVelocity;
}

inline const DtVector & DtBaseEntityStateRepository::lastSetLocation() const
{
   return myLastSetLocation;
}


inline const DtVector32 & 
DtBaseEntityStateRepository::lastSetRelativeRotationalVelocity() const
{
   return myLastSetRelativeRotationalVelocity;
}

inline const DtTaitBryan& 
DtBaseEntityStateRepository::lastSetRelativeOrientation() const
{
   return myLastSetRelativeOrientation;
}

inline const DtVector32 & 
DtBaseEntityStateRepository::lastSetRelativeAcceleration() const
{
   return myLastSetRelativeAcceleration;
}

inline const DtVector32 & 
DtBaseEntityStateRepository::lastSetRelativeVelocity() const
{
   return myLastSetRelativeVelocity;
}

inline const DtVector & 
DtBaseEntityStateRepository::lastSetRelativeLocation() const
{
   return myLastSetRelativeLocation;
}

inline void DtBaseEntityStateRepository::setAmAsSeenByRemote( bool val )
{
   myAmAsSeenByRemote = val;
}