rwRadioState.h

Go to the documentation of this file.

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

#pragma once

#include <makRadio/export.h>
#include <makRadio/radioStateTypes.h>

#include <readerWriter/rwString.h>
#include <readerWriter/rwInt.h>
#include <readerWriter/rwReal.h>
#include <readerWriter/rwBoolean.h>
#include <vrfutil/rwTemplatedList.h>

#include <vlpi/entityType.h>
#include <vlpi/entityIdentifier.h>
#include <matrix/vlVector.h>
#include <boost/signals2.hpp>
#include <vector>
#include <string>

namespace makRadio
{
   class DtRadio;

   class DT_DLL_MAKRADIO DtRwRadioChannel : public DtReaderWriter
   {
   public:
      DtRwRadioChannel(const DtString& name = "channel", DtReaderWriterRegistry* parentRegistry = 0);
      DtRwRadioChannel(const DtRwRadioChannel&);
      virtual ~DtRwRadioChannel();

      DtRwRadioChannel& operator=(const DtRwRadioChannel&);

      virtual const char* readerWriterType() const;

      static const char* theXmlType();

      virtual const char* xmlType() const
      {
         return theXmlType();
      }

      virtual void setChannelName(const std::string& channelName);
      virtual std::string channelName() const;

      virtual void setFrequencyMHz(const double& frequencyMHz);
      virtual void setFrequencyHz(const double& frequencyHz);
      virtual const double frequencyMHz() const;
      virtual const double frequencyHz() const;

   protected:
      DtRwString myChannelName;
      DtRwReal myFrequency;
   };

   class DT_DLL_MAKRADIO DtRwModulationType : public DtReaderWriter
   {
   public:
      DtRwModulationType(const DtString& name = "modulationType", DtReaderWriterRegistry* parentRegistry = 0);
      DtRwModulationType(const DtRwModulationType&);
      virtual ~DtRwModulationType();

      DtRwModulationType& operator=(const DtRwModulationType&);
      bool operator==(const DtRwModulationType& rhs) const;
      bool operator!=(const DtRwModulationType& rhs) const;

      virtual const char* readerWriterType() const;

      static const char* theXmlType();

      virtual const char* xmlType() const
      {
         return theXmlType();
      }

      DtRwInt myMajor;
      DtRwInt myDetail;
      DtRwInt mySystem;
   };

   class DT_DLL_MAKRADIO DtRwRadioState : public DtReaderWriter
   {
   public:
      DtRwRadioState(const DtString& name = "radio", DtReaderWriterRegistry* parentRegistry = 0);
      DtRwRadioState(const DtRwRadioState& state);
      virtual ~DtRwRadioState();

      DtRwRadioState& operator=(const DtRwRadioState& orig);

      virtual void setRadio(DtRadio* radio);

      virtual DtEntityIdentifier entityId() const;
      virtual void setEntityId(DtEntityIdentifier val);
      boost::signals2::signal<void(DtRadio*, DtEntityIdentifier)> signal_entityIdChanged;

      virtual unsigned short radioId() const;
      virtual void setRadioId(unsigned short val);
      boost::signals2::signal<void(DtRadio*, unsigned short)> signal_radioIdChanged;

      virtual DtEntityType radioEntityType() const;
      virtual void setRadioEntityType(DtEntityType val);
      boost::signals2::signal<void(DtRadio*, DtEntityType)> signal_radioEntityTypeChanged;

      virtual bool isPowered() const;
      virtual void setIsPowered(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_isPoweredChanged;

      virtual bool isTransmitting() const;
      virtual void setIsTransmitting(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_isTransmittingChanged;

      virtual TransmitState transmitState() const;

      virtual InputSource inputSource() const;
      virtual void setInputSource(InputSource val);
      boost::signals2::signal<void(DtRadio*, InputSource)> signal_inputSourceChanged;

      virtual DtVector worldAntennaLocation() const;
      virtual void setWorldAntennaLocation(DtVector val);
      boost::signals2::signal<void(DtRadio*, DtVector)> signal_worldAntennaLocationChanged;

      virtual DtVector32 relativeAntennaLocation() const;
      virtual void setRelativeAntennaLocation(DtVector32 val);
      boost::signals2::signal<void(DtRadio*, DtVector32)> signal_relativeAntennaLocationChanged;

      virtual AntennaPatternType antennaPatternType() const;
      virtual void setAntennaPatternType(AntennaPatternType val);
      boost::signals2::signal<void(DtRadio*, AntennaPatternType)> signal_antennaPatternTypeChanged;

      virtual double frequency() const;
      virtual void setFrequency(double val);
      boost::signals2::signal<void(DtRadio*, double)> signal_frequencyChanged;

      virtual float transmitBandwidth() const;
      virtual void setTransmitBandwidth(float val);
      boost::signals2::signal<void(DtRadio*, float)> signal_transmitBandwidthChanged;

      virtual float power() const;
      virtual void setPower(float val);
      boost::signals2::signal<void(DtRadio*, float)> signal_powerChanged;

      virtual const DtRwModulationType& modulationType() const;
      virtual void setModulationType(DtRwModulationType val);
      boost::signals2::signal<void(DtRadio*, DtRwModulationType)> signal_modulationTypeChanged;

      virtual CryptoMode cryptoMode() const;
      virtual void setCryptoMode(CryptoMode val);
      boost::signals2::signal<void(DtRadio*, CryptoMode)> signal_cryptoModeChanged;

      virtual CryptoSystem cryptoSystem() const;
      virtual void setCryptoSystem(CryptoSystem val);
      boost::signals2::signal<void(DtRadio*, CryptoSystem)> signal_cryptoSystemChanged;

      virtual unsigned short cryptoKey() const;
      virtual void setCryptoKey(unsigned short val);
      boost::signals2::signal<void(DtRadio*, unsigned short)> signal_cryptoKeyChanged;

      virtual const std::vector<unsigned char>& modulationParameters() const;
      virtual void setModulationParameters(const std::vector<unsigned char>& val);
      boost::signals2::signal<void(DtRadio*, const std::vector<unsigned char>&)> signal_modulationParametersChanged;

      virtual const std::vector<unsigned char>& antennaPatternParameters() const;
      virtual void setAntennaPatternParameters(const std::vector<unsigned char>& val);
      boost::signals2::signal<void(DtRadio*, const std::vector<unsigned char>&)> signal_antennaPatternParametersChanged;

      virtual bool freqHopInUse() const;
      virtual void setFreqHopInUse(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_freqHopInUseChanged;

      virtual bool pseudoNoiseInUse() const;
      virtual void setPseudoNoiseInUse(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_pseudoNoiseInUseChanged;

      virtual bool timeHopInUse() const;
      virtual void setTimeHopInUse(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_timeHopInUseChanged;

      virtual std::string radioName() const;
      virtual void setRadioName(const std::string& val);
      boost::signals2::signal<void(DtRadio*, const std::string&)> signal_nameChanged;

      virtual RadioType radioType() const;
      virtual void setRadioType(RadioType val);
      boost::signals2::signal<void(DtRadio*, RadioType)> signal_radioTypeChanged;

      virtual Duplex duplex() const;
      virtual void setDuplex(Duplex val);
      boost::signals2::signal<void(DtRadio*, Duplex)> signal_duplexChanged;

      virtual bool canHearSelf() const;
      virtual void setCanHearSelf(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_canHearSelfChanged;

      virtual float receiveLevel() const;
      virtual void setReceiveLevel(float val);

      virtual float transmitLevel() const;
      virtual void setTransmitLevel(float val);

      virtual float volume() const;
      virtual void setVolume(float val);
      boost::signals2::signal<void(DtRadio*, float)> signal_volumeChanged;

      virtual bool micMuted() const;
      virtual void setMicMuted(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_micMutedChanged;

      virtual bool speakerMuted() const;
      virtual void setSpeakerMuted(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_speakerMutedChanged;

      virtual bool useVox() const;
      virtual void setUseVox(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_useVoxChanged;

      virtual float voxThreshold() const;
      virtual void setVoxThreshold(float val);
      boost::signals2::signal<void(DtRadio*, float)> signal_voxThresholdChanged;

      virtual bool useMultiSource() const;
      virtual void setUseMultiSource(bool val);
      boost::signals2::signal<void(DtRadio*, bool)> signal_useMultiSourceChanged;

      virtual int numChannels() const;

      virtual void addChannel(DtRwRadioChannel& channel);

      virtual void removeChannel(int index);

      virtual void removeAllChannels();

      virtual DtRwRadioChannel* findChannel(int index);

      virtual int currentChannel() const;
      virtual void setCurrentChannel(int index);
      boost::signals2::signal<void(DtRadio*, int)> signal_currentChannelChanged;

      virtual const char* readerWriterType() const;

      static const char* theXmlType();

      virtual const char* xmlType() const
      {
         return theXmlType();
      }

   protected:
      DtEntityIdentifier myEntityId;
      unsigned short myRadioId;
      DtEntityType myRadioEntityType;
      bool myIsTransmitting;
      float myTxLevel;
      float myRxLevel;
      DtVector myWorldAntennaLocation;
      DtVector32 myRelativeAntennaLocation;
      std::vector<unsigned char> myModulationParameters;
      std::vector<unsigned char> myAntennaPatternParameters;

      DtRwString myRadioName;
      DtRwInt myRadioType;
      DtRwInt myDuplex;
      DtRwBoolean myCanHearSelf;
      DtRwReal myVolume;
      DtRwBoolean myIsMicMuted;
      DtRwBoolean myIsSpeakerMuted;
      DtRwBoolean myUseVox;
      DtRwReal myVoxThreshold;
      DtRwBoolean myMultiSource;
      DtRwBoolean myIsPowered;
      DtRwInt myInputSource;
      DtRwInt myAntennaPatternType;
      DtRwReal myFrequency;
      DtRwReal myTransmitBandwidth;
      DtRwReal myPower;
      DtRwModulationType myModulationType;
      DtRwInt myCryptoMode;
      DtRwInt myCryptoSystem;
      DtRwInt myCryptoKey;
      DtRwBoolean myFreqHopInUse;
      DtRwBoolean myPseudoNoiseInUse;
      DtRwBoolean myTimeHopInUse;
      DtRwInt myCurrentChannel;
      DtRwTemplatedListPtr<DtRwRadioChannel, true> myChannels;

      DtRadio* myRadio;
   };
}