radioTransmitterStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/vrfStateDataDefines.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include "vrfStateData/stateComponent.h"
#include "vrfutil/rwUUID.h"
#include <legionStandardOM/sets/readRadioTransmitterRepository.hpp>
#include <legionStandardOM/sets/writeRadioTransmitterRepository.hpp>
#include <matrix/vlVector.h>
#include <vlpi/entityType.h>

namespace makVrf
{
   struct DT_DLL_vrfStateData DtRadioTransmitterStateComponentData
   {
      enum RadioInputSource
      {
         RadioInputOther,
         Pilot,
         CoPilot,
         FirstOfficer,
         Driver,
         Loader,
         Gunner,
         Commander,
         DigitalDataDevice,
         Intercom
      };

      DtRadioTransmitterStateComponentData()
      : myAntennaPatternType(0)
      , myPseudoNoiseInUse(false)
      , myTimeHopInUse(false)
      , myModulationParams(0)
      , myModulationParamsSize(0)
      , myRadioId(0)
      {
      }

      DtRadioTransmitterStateComponentData(const DtRadioTransmitterStateComponentData& orig)
      : myWorldAntennaLoc(orig.myWorldAntennaLoc)
      , myRelativeAntennaLoc(orig.myRelativeAntennaLoc)
      , myAntennaPatternType(orig.myAntennaPatternType)
      , myPseudoNoiseInUse(orig.myPseudoNoiseInUse)
      , myTimeHopInUse(orig.myTimeHopInUse)
      , myModulationParams(0)
      , myModulationParamsSize(0)
      , myRadioId(orig.myRadioId)
      {
         if (orig.myModulationParams)
         {
            myModulationParams = (char*)malloc(orig.myModulationParamsSize);
            memcpy(myModulationParams, orig.myModulationParams, orig.myModulationParamsSize);
            myModulationParamsSize = orig.myModulationParamsSize;
         }
      }

      virtual ~DtRadioTransmitterStateComponentData()
      {
         if (myModulationParams)
         {
            free(myModulationParams);
         }
      }

      DtRadioTransmitterStateComponentData& operator=(const DtRadioTransmitterStateComponentData& orig)
      {
         myRelativeAntennaLoc = orig.myRelativeAntennaLoc;
         myWorldAntennaLoc = orig.myWorldAntennaLoc;
         myRadioId = orig.myRadioId;
         myAntennaPatternType = orig.myAntennaPatternType;
         myPseudoNoiseInUse = orig.myPseudoNoiseInUse;
         myTimeHopInUse = orig.myTimeHopInUse;

         if (myModulationParams)
         {
            free(myModulationParams);
            myModulationParams = 0;
            myModulationParamsSize = 0;
         }

         if (orig.myModulationParams)
         {
            myModulationParams = (char*)malloc(orig.myModulationParamsSize);
            memcpy(myModulationParams, orig.myModulationParams, orig.myModulationParamsSize);
            myModulationParamsSize = orig.myModulationParamsSize;
         }

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(DtVector, worldAntennaLoc, WorldAntennaLoc)
      DEFINE_ACCESSOR_MUTATOR(DtVector, relativeAntennaLoc, RelativeAntennaLoc)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, antennaPatternType, AntennaPatternType)
      DEFINE_ACCESSOR_MUTATOR(UInt64, radioId, RadioId)
      DEFINE_ACCESSOR_MUTATOR(bool, pseudoNoiseInUse, PseudoNoiseInUse)
      DEFINE_ACCESSOR_MUTATOR(bool, timeHopInUse, TimeHopInUse)

      const char* modulationParams() const { return myModulationParams; };
      const unsigned char& modulationParamsSize() const { return myModulationParamsSize;  };

      void setModulationParams(const char* p, unsigned char l)
      {
         if (myModulationParams)
         {
            free(myModulationParams);
            myModulationParamsSize = 0;
         }

         if (p && l)
         {
            myModulationParams = (char*)malloc(l);
            memcpy(myModulationParams, p, l);
            myModulationParamsSize = l;
         }
      }

   protected:
      char* myModulationParams;
      unsigned char myModulationParamsSize;

      DtVector myWorldAntennaLoc;
      DtVector myRelativeAntennaLoc;
      unsigned int myAntennaPatternType;

      bool myPseudoNoiseInUse;
      bool myTimeHopInUse;

      UInt64 myRadioId;
   };

   class DT_DLL_vrfStateData DtRadioTransmitterStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::RadioTransmitterStateComponent)

      DtRadioTransmitterStateComponent(DtStateData* storage)
      : DtFrameStateInterface(storage)
      {
      }

      UNDEFINED_RETURNVALUE_ACCESSOR(DtUUID, hostId)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, transmitState, TransmitState)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtRadioEntityType, radioEntityType, RadioEntityType)
      virtual const unsigned long long frequency() const { throw DtUnimplementedMethod("The const frequency() method is unimplemented"); };
      virtual void setFrequency(unsigned long long) { throw DtUnimplementedMethod("The const setFrquency(unsigned long long) method is unimplemented"); };
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(float, power, Power)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtVector, relativeAntennaLoc, RelativeAntennaLoc)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtVector, relativePosition, RelativePosition)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtVector, worldAntennaLoc, WorldAntennaLoc)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, inputSource, InputSource)
      UNDEFINED_RETURNVALUE_ACCESSOR(unsigned long, streamTagUpper)
      UNDEFINED_RETURNVALUE_ACCESSOR(unsigned long, streamTagLower)
      virtual const unsigned long long streamTag() const { throw DtUnimplementedMethod("The const streamTag() method is unimplemented"); };
      virtual void setStreamTag(unsigned long u, unsigned long l) { throw DtUnimplementedMethod("The const setStreamTag() method is unimplemented"); };
      virtual void setStreamTag(unsigned long long) { throw DtUnimplementedMethod("The const setStreamTag(unsigned long long) method is unimplemented"); };
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(unsigned int, antennaPatternType, AntennaPatternType)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(UInt64, radioId, RadioId)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, cryptoKey, CryptoKey)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, cryptoMode, CryptoMode)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, cryptoSystem, CryptoSystem)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, detailedModulationType, DetailedModulationType)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(float, frequencyBandwidth, FrequencyBandwidth)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, frequencyHopInUse, FrequencyHopInUse)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, pseudoNoiseInUse, PseudoNoiseInUse)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, timeHopInUse, TimeHopInUse)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, majorModulationType, MajorModulationType)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, modulationSystemType, ModulationSystemType)
      UNDEFINED_RETURNVALUE_ACCESSOR(char*, modulationParams)
      UNDEFINED_RETURNREF_ACCESSOR(unsigned char, modulationParamsSize)
      virtual void setModulationParams(const char* params, unsigned char length) { throw DtUnimplementedMethod("The const setModulationParams() method is unimplemented"); };
   };

   class DT_DLL_vrfStateData DtRadioTransmitterStateComponentNextFrame : public DtRadioTransmitterStateComponent
   {
   public:
      DtRadioTransmitterStateComponentNextFrame(DtStateData*);

      virtual ~DtRadioTransmitterStateComponentNextFrame();

      const DtRadioTransmitterStateComponentData& frameState() const { return myData; };
      DtRadioTransmitterStateComponentData& frameState() { return myData; };

      const DtUUID hostId() const;

      const unsigned int transmitState() const;
      void setTransmitState(const unsigned int&);

      const unsigned int& antennaPatternType() const;
      void setAntennaPatternType(const unsigned int&);

      const UInt64 radioId() const;
      void setRadioId(const UInt64&);

      const DtRadioEntityType radioEntityType() const;
      void setRadioEntityType(const DtRadioEntityType&);

      const unsigned long long frequency() const;
      void setFrequency(unsigned long long);

      const unsigned long streamTagUpper() const;
      const unsigned long streamTagLower() const;
      const unsigned long long streamTag() const;
      void setStreamTag(unsigned long u, unsigned long l);
      void setStreamTag(unsigned long long tag);

      const float power() const;
      void setPower(const float&);

      const char* modulationParams() const;
      const unsigned char& modulationParamsSize() const;
      void setModulationParams(const char* params, unsigned char length);

      const DtVector& relativeAntennaLoc() const;
      void setRelativeAntennaLoc(const DtVector&);

      const DtVector& worldAntennaLoc() const;
      void setWorldAntennaLoc(const DtVector&);

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

      const unsigned int inputSource() const;
      void setInputSource(const unsigned int&);

      const unsigned int cryptoKey() const;
      void setCryptoKey(const unsigned int&);

      const unsigned int cryptoMode() const;
      void setCryptoMode(const unsigned int&);

      const unsigned int cryptoSystem() const;
      void setCryptoSystem(const unsigned int&);

      const unsigned int majorModulationType() const;
      void setMajorModulationType(const unsigned int&);

      const unsigned int modulationSystemType() const;
      void setModulationSystemType(const unsigned int&);

      const unsigned int detailedModulationType() const;
      void setDetailedModulationType(const unsigned int&);

      const float frequencyBandwidth() const;
      void setFrequencyBandwidth(const float&);

      const bool frequencyHopInUse() const;
      void setFrequencyHopInUse(const bool&);

      const bool& pseudoNoiseInUse() const;
      void setPseudoNoiseInUse(const bool&);

      const bool& timeHopInUse() const;
      void setTimeHopInUse(const bool&);

      virtual void makeWritable();

      virtual void makeReadOnly();

      UInt64 globalId() const;

      Legion::WriteStateInstance writeStateInstance() override;
      virtual void updateStateData(DtStateData*) override;

      void cleanupWriteState();

      void setPublishingOnLegionNetwork(bool b);

   protected:
      bool myPublishingOnLegionNetwork;
      LOM::WriteRadioTransmitterRepository myWriteRadioTransmitterRepository;
      DtStateData* myStateData;
      DtRadioTransmitterStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtRadioTransmitterStateComponentCurrentFrame : public DtRadioTransmitterStateComponent
   {
   public:
      DtRadioTransmitterStateComponentCurrentFrame(DtStateData*);

      const DtRadioTransmitterStateComponentData& frameState() const { return myData; };

      const DtUUID hostId() const;
      const unsigned int transmitState() const;
      const DtRadioEntityType radioEntityType() const;
      const unsigned long long frequency() const;
      const unsigned long long streamTag() const;
      const unsigned long streamTagUpper() const;
      const unsigned long streamTagLower() const;
      const float power() const;
      const DtVector& worldAntennaLoc() const;
      const DtVector& relativeAntennaLoc() const;
      const DtVector relativePosition() const;
      const unsigned int inputSource() const;
      const unsigned int& antennaPatternType() const;
      const UInt64 radioId() const;
      const unsigned int cryptoKey() const;
      const unsigned int cryptoMode() const;
      const unsigned int cryptoSystem() const;
      const unsigned int detailedModulationType() const;
      const float frequencyBandwidth() const;
      const bool frequencyHopInUse() const;
      const bool& pseudoNoiseInUse() const;
      const bool& timeHopInUse() const;
      const unsigned int majorModulationType() const;
      const unsigned int modulationSystemType() const;
      const char* modulationParams() const;
      const unsigned char& modulationParamsSize() const;

      bool readComponentValid() const;
      bool findReadComponent();
      Legion::ReadStateInstance readStateInstance() const override;

      UInt64 globalId() const;
      virtual void updateStateData(DtStateData*) override;

   protected:
      friend class DtRadioTransmitterStateComponentImplementation;
      void advanceFrame(const DtRadioTransmitterStateComponentData& data)
      {
         myData = data;
      }

   protected:
      LOM::ReadRadioTransmitterRepository myReadRadioTransmitterRepository;
      DtStateData* myStateData;
      DtRadioTransmitterStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtRadioTransmitterStateComponentImplementation : public DtDoubleBufferedStateComponent<DtRadioTransmitterStateComponent>
   {
   public:
      DtRadioTransmitterStateComponentImplementation(DtStateData* sd);

      bool isDoubleBuffered() { return true; };
      const DtFrameStateInterface* currentFrameState() const { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const { return &myNextFrameState; };

      void updateDataStorage()
      {
         if (!myFoundComponent)
         {
            myFoundComponent = myCurrentFrameState.findReadComponent();
         }

         if (myNextFrameState.isWritable())
         {
            myCurrentFrameState.advanceFrame(myNextFrameState.frameState());
         }

         myCurrentFrameState.emitComponentUpdated();
      }

      void updateStateData(DtStateData* sd)
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      virtual bool forceAdvance();

      virtual void firstFrameAdvance() override;

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtRadioTransmitterStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

      virtual void completeSetup() override;
      virtual void removeAdditionalStateComponents() override;
      virtual void setPublishingOnLegionNetwork(bool b) override;

   protected:
      DtRadioTransmitterStateComponentCurrentFrame myCurrentFrameState;
      DtRadioTransmitterStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;
   };

   typedef DtStateComponentCreator<DtRadioTransmitterStateComponentImplementation> DtRadioTransmitterStateComponentCreator;
}