stateComponent.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2022 MAK Technologies, Inc.
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <vrfStateData/vrfStateDataDefines.h>
#include <vrfStateData/stateDataTypes.h>

#include <legionDataStore/writeStateInstance.h>
#include <legionDataStore/readStateInstance.h>

#include <boost/signals2.hpp>

#include <vlutil/vlPrint.h>

#include <limits>



class Coordinate_System;

namespace LOM
{
   class WriteEntityRepository;
   class ReadEntityRepository;
}

namespace Legion
{
   class SimulationDatabase;
}

class DtAppearance;
class DtVrfObjectParameters;

namespace makVrf
{
   class DtStateComponent;
   class DtStateData;
   class DtFrameStateInterface;

   class DT_DLL_vrfStateData DtStateComponent
   {
   public:

      typedef unsigned int StateComponentType;

      enum StateComponentTypeEnum
      {
         Undefined = -1,
         SimulatedObjectStateComponent = 0,
         EntityStateComponent = SimulatedObjectStateComponent,
         EnvironmentalStateComponent = SimulatedObjectStateComponent,
         AggregateStateComponent = SimulatedObjectStateComponent,
         MetocServiceStateComponent = SimulatedObjectStateComponent,
         AerodromeStateComponent = SimulatedObjectStateComponent,
         LocationStateComponent = 1,
         EntityLocationStateComponent = LocationStateComponent,
         EnvironmentalLocationStateComponent = LocationStateComponent,
         StaticLocationStateComponent = LocationStateComponent,
         HumanStateComponent = 2,
         ArticulatedPartStateComponent = 3,
         VrfStateComponent = 4,
         StatePropertiesStateComponent = 5,
         VrfGeometryStateComponent = 6,
         SubordinateManagerStateComponent = 7,
         RangeItemsStateComponent = 8,
         CloudLayerStateComponent = 9,
         TimeAndDateStateComponent = 10,
         WeatherStateComponent = 11,
         LaserDesignatorStateComponent = 12,
         EmitterSystemStateComponent = 13,
         IffStateComponent = 14,
         ActiveSonarStateComponent = 15,
         UnderwaterAcousticsStateComponent = 16,
         SensorFieldOfViewStateComponent = 17,
         RadioTransmitterStateComponent = 18,
         TaskVisualizationStateComponent = 19,
         TacticalSmokeStateComponent = 20,
         DynamicTerrainStateComponent = 21,
         RadioReceiverStateComponent = 22,
         WindCorridorStateComponent = 23,
         AirTurbulenceStateComponent = 24,
         NavAidRadioTransmitterStateComponent = 25,
         AisDataStateComponent = 26,
         AircraftLightingStateComponent = 27,
         LandSurfaceStateComponent = 28,
         WaterSurfaceStateComponent = 29,
         TroposphereStateComponent = 30,
         SubsurfaceStateComponent = 31,
         GroundVehicleLightingStateComponent = 32,
         UserStateComponent = 64
      };

   public:

      DtStateComponent( DtStateData* );

      virtual ~DtStateComponent();

      virtual void advanceFrame();

      virtual void setCoordinateSystem( const Coordinate_System* );

      virtual StateComponentType typeWithCreator() const = 0;
      virtual StateComponentType componentType() const = 0;

      mutable boost::signals2::signal<void(DtStateComponent*)> signal_stateComponentAboutToBeDeleted;
      mutable boost::signals2::signal<void(DtStateComponent*)> signal_componentModified;

      virtual void setStateData( DtStateData* );

      virtual void setPublishingOnLegionNetwork( bool );
      bool publishingOnLegionNetwork() const
      {
         return myPublishingOnLegionNetwork;
      }

      virtual void setIsRemoteComponent( bool b )
      {
         myIsRemoteComponent = b;
      }

      virtual void convertToRemote();

      virtual void convertToLocal();

      bool isRemoteComponent() const
      {
         return myIsRemoteComponent;
      }

      virtual void initializeFromParameters( const DtVrfObjectParameters* );

      virtual void completeSetup();

      virtual void aboutToBeDeleted();

      virtual void setId( UInt64 id );

      virtual UInt64 id() const
      {
         return myId;
      }

      bool advancedFrame() const
      {
         return myAdvancedFrame;
      }

      virtual void firstFrameAdvance();

      UInt64 stateId() const;

      UInt64 legionGlobalId() const;

      const DtStateData* stateData() const
      {
         return myStateData;
      }

      bool cleared() const
      {
         return myCleared;
      }

      DtStateData* stateData()
      {
         return myStateData;
      }

      const Coordinate_System* coordinateSystem() const
      {
         return myCoordinateSystem;
      }

      virtual bool forceAdvance() { return false; };

      virtual bool isDoubleBuffered() const;
      virtual const DtFrameStateInterface* currentFrameState() const { throw DtUnimplementedMethod("const DtFrameStateInterface* currentFrameState() const is not implemented."); };
      virtual DtFrameStateInterface* nextFrameState() { throw DtUnimplementedMethod("DtFrameStateInterface* nextFrameState() is not implemented."); };
      virtual const DtFrameStateInterface* nextFrameState() const { throw DtUnimplementedMethod("const DtFrameStateInterface* nextFrameState() const is not implemented."); };
      virtual Legion::WriteStateInstance writeStateInstance() { throw DtUnimplementedMethod("Legion::WriteStateInstance writeStateInstance() is not implemented."); };
      virtual void addAdditionalStateComponents() {};

      virtual void removeAdditionalStateComponents() {};

      virtual const char* stringType() const = 0;

   protected:

      UInt64 myId;
      DtStateData* myStateData;
      const Coordinate_System* myCoordinateSystem;
      bool myIsRemoteComponent;
      bool myCleared;
      bool myPublishingOnLegionNetwork;
      bool myAdvancedFrame;

   };

   #define DEFINE_STATE_COMPONENT_TYPE(CreatedComponent) \
         static const DtStateComponent::StateComponentType theComponentType = CreatedComponent; \
         static const char* StringType() { return #CreatedComponent; } \
         virtual DtStateComponent::StateComponentType typeWithCreator() const { return TypeWithCreator(); }; \
         virtual DtStateComponent::StateComponentType componentType() const { return ComponentType(); }; \
         virtual const char* stringType() const { return #CreatedComponent; }; \
         static DtStateComponent::StateComponentType TypeWithCreator() { return (DtStateComponent::StateComponentType)((unsigned int)(theComponentCreatorType << 16) | theComponentType); }; \
         static void SetCreatorType(UInt32 type) { theComponentCreatorType = type; }; \
         static DtStateComponent::StateComponentType ComponentType() { return theComponentType; }; \
         static UInt32 CreatorType() { return theComponentCreatorType; }; \
      protected: \
         static UInt32 theComponentCreatorType; \
      public:

   #define DEFINE_STATE_COMPONENT_HELPER(Component) \
      static const char* StringType() { return #Component; } \
      virtual DtStateComponent::StateComponentType typeWithCreator() const { return Component::TypeWithCreator(); }; \
      virtual DtStateComponent::StateComponentType componentType() const { return Component::ComponentType(); }; \
      virtual DtStateComponent::StateComponentType setCreatorType(UInt32 type) const { return SetCreatorType(type); }; \
      virtual const char* stringType() const { return #Component; }; \
      static DtStateComponent::StateComponentType TypeWithCreator() { return Component::TypeWithCreator(); }; \
      static DtStateComponent::StateComponentType ComponentType() { return Component::ComponentType(); }; \
      static UInt32 SetCreatorType(UInt32 type) { Component::SetCreatorType(type); return type; };

   class DT_DLL_vrfStateData DtStateComponentCreatorInterface
   {
   public:
      virtual DtStateComponent* create( DtStateData * ) = 0;
      virtual DtStateComponent::StateComponentType setCreatorType( UInt32 ) const = 0;
      virtual DtStateComponent::StateComponentType componentType() const = 0;
      virtual DtStateComponent::StateComponentType typeWithCreator() const = 0;
      virtual void registerLegionComponent( Legion::SimulationDatabase* ) = 0;
      virtual void addAdditionalTableColumns( Legion::SimulationDatabase* ) = 0;
      virtual bool autoCreateForRemoteObject() const = 0;
   };

   template <typename T_StateComponent, bool T_AutoCreateForRemoteObject = true>
   class DtStateComponentCreator : public DtStateComponentCreatorInterface
   {
   public:
      DEFINE_STATE_COMPONENT_HELPER( T_StateComponent )
         virtual DtStateComponent* create( DtStateData* sd ) { return new T_StateComponent( sd ); };

      virtual void registerLegionComponent( Legion::SimulationDatabase* db )
      {
         T_StateComponent::registerLegionComponent( db );
      }

      virtual void addAdditionalTableColumns( Legion::SimulationDatabase* db )
      {
         T_StateComponent::addAdditionalTableColumns( db );
      }

      virtual bool autoCreateForRemoteObject() const
      {
         return T_AutoCreateForRemoteObject;
      }
   };

   class DT_DLL_vrfStateData DtFrameStateInterface
   {
   private:

      DtFrameStateInterface( const DtFrameStateInterface& orig );
      DtFrameStateInterface& operator = ( const DtFrameStateInterface& rhs );

   public:

      DtFrameStateInterface( const DtStateData* );

      virtual ~DtFrameStateInterface();

      void setIsWritable(bool b) { myIsWritable = b; };
      bool isWritable() const { return myIsWritable; };

      UInt64 stateId() const { return myStateId; };
      UInt64 legionGlobalId() const { return myLegionId; };
      void setLegionGlobalId( UInt64 d ) { myLegionId = d; };
      bool isModified() const { return myIsModified; };
      void clearModified() { myIsModified = false; };
      void markModified() { myIsModified = true; };

      virtual DtStateComponent::StateComponentType type() const { return componentType(); };
      virtual DtStateComponent::StateComponentType componentType() const = 0;

      void setId( UInt64 id ) { myId = id; };
      virtual UInt64 id() const { return myId; };

      virtual void updateStateData( DtStateData* sd );

      virtual Legion::ReadStateInstance readStateInstance() const { throw DtUnimplementedMethod("void readStateInstance() const is not implemented."); };
      virtual Legion::WriteStateInstance writeStateInstance() { throw DtUnimplementedMethod("void writeStateInstance() const is not implemented."); };

      void emitComponentUpdated()
      {
         signal_componentModified( this );
      }

      bool cleared() const
      {
         return myCleared;
      }

      bool advancedFrame() const
      {
         return myAdvancedFrame;
      }

      virtual void frameAdvanced()
      {
         myAdvancedFrame = true;
      }

      virtual void convertToRemote();

      virtual void convertToLocal();
      virtual void aboutToBeDeleted();

      mutable boost::signals2::signal<void (DtFrameStateInterface*)> signal_stateComponentAboutToBeDeleted;
      mutable boost::signals2::signal<void (const DtFrameStateInterface*)> signal_componentModified;

   protected:

      virtual void makeWritable() { throw DtUnimplementedMethod("void makeWritable() const is not implemented."); };

      virtual void makeReadOnly() { throw DtUnimplementedMethod("void makeReadOnly() const is not implemented."); };

   protected:

      bool myIsModified;
      UInt64 myId;
      UInt64 myStateId;
      UInt64 myLegionId;
      bool myIsWritable;
      bool myCleared;
      bool myAdvancedFrame;

   };


   template <typename T_Component>
   class DtDoubleBufferedStateComponent : public DtStateComponent
   {
   public:

      DEFINE_STATE_COMPONENT_HELPER( T_Component )

         DtDoubleBufferedStateComponent( DtStateData* sd )
         : DtStateComponent( sd )
      {
      }

      virtual void setId( UInt64 id )
      {
         DtStateComponent::setId( id );

         if ( nextFrameState() )
         {
            nextFrameState()->setId( id );
         }

         if ( currentFrameState() )
         {
            const_cast<DtFrameStateInterface*>(currentFrameState())->setId( id );
         }
      }

      virtual void setStateData( DtStateData* sd )
      {
         if ( myStateData != sd )
         {
            DtStateComponent::setStateData( sd );

            updateStateData( sd );
         }
      }

      virtual bool isDoubleBuffered() const { return true; };

      virtual bool forceAdvance() { return false; };
      virtual void advanceFrame()
      {
         myAdvancedFrame = true;

         if ( nextFrameState()->isModified() || forceAdvance() )
         {
            nextFrameState()->markModified();
            const_cast<DtFrameStateInterface*>( currentFrameState() )->markModified();
            updateDataStorage();
            nextFrameState()->clearModified();
            signal_componentModified( this );
         }
         else
         {
            nextFrameState()->clearModified();
            const_cast<DtFrameStateInterface*>(currentFrameState())->clearModified();
         }

         nextFrameState()->frameAdvanced();
         const_cast<DtFrameStateInterface*>(currentFrameState())->frameAdvanced();
      }

      static void registerLegionComponent( Legion::SimulationDatabase* ) {};
      static void addAdditionalTableColumns( Legion::SimulationDatabase* ) {};

      virtual void updateDataStorage() = 0;

      virtual void updateStateData(DtStateData*) = 0;

   };

}