WsfRF_Repeater.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFRF_REPEATER_HPP
#define WSFRF_REPEATER_HPP
 
#include "wsf_mil_export.h"
 
#include "UtCallbackHolder.hpp"
class UtInput;
class WsfEM_Interaction;
class WsfEM_Xmtr;
#include "WsfSensor.hpp"
#include "WsfTrack.hpp"
class WsfTrackId;
#include "WsfWeapon.hpp"

class WSF_MIL_EXPORT WsfRF_Repeater
{
public:
   enum OperatingMode
   {
      cOM_MANUAL, 
      cOM_SEMIAUTO, 
      cOM_AUTO 
   };

   WsfRF_Repeater();

   WsfRF_Repeater(const WsfRF_Repeater& aSrc);
 
   WsfRF_Repeater& operator=(const WsfRF_Repeater&) = delete;
 
   ~WsfRF_Repeater() = default;

   WsfRF_Repeater* Clone() const;

   bool Initialize(double aSimTime, WsfWeapon* aWeaponPtr);

   bool ProcessInput(UtInput& aInput);

   bool ProcessInputBlock(UtInput& aInput);
 
   void Reset(double aSimTime);
 
   OperatingMode GetOperatingMode() const { return mOperatingMode; }
   bool          IsSignalFollowing() const { return mSignalFollowing; }
 
   void       RegisterTrack(const WsfTrack* aTrackPtr);
   void       RegisterTrackId(WsfTrackId aTrackId, size_t aTargetIndex);
   void       RemoveTrackId(WsfTrackId aTrackId, size_t aTargetIndex);
   WsfTrackId MergedTrackId(WsfTrackId aProcessedTrackId);

   bool CheckDetectAndUpdate(double                   aSimTime,
                             WsfEM_Xmtr*              aXmtrPtr,
                             WsfSensorResult&         aResult,
                             const WsfEM_Interaction& aTargetInteraction);

   void SensorTrackDropped(double aSimTime, WsfTrackId aTrackId, size_t aTargetIndex);

   void SensorTrackInitiated(double aSimTime, const WsfTrack* aTrackPtr);

   void SensorTrackUpdated(double aSimTime, const WsfTrack* aTrackPtr);
 
private:
   // Monitor track signal changes and make jamming changes as required.
   using TrackIdtoSignalMap = std::map<WsfTrackId, std::vector<WsfTrack::Signal>>;
 
   using TrackIdToTrackIdMap = std::map<WsfTrackId, WsfTrackId>;
 
   using TargetIndexToSensorNameId = std::map<size_t, WsfStringId>;
   using TargetIndexToTrackIdMap   = std::map<size_t, WsfTrackId>;
 
   void AddUpdateSignalList(const WsfTrack* aTrackPtr);
 
   bool MergeTrack(const WsfTrack* aDetectedTrackPtr);
 
   void UpdateTrack(const WsfTrack* aTrackPtr);
 
   WsfWeapon* mWeaponPtr;
 
   OperatingMode mOperatingMode;
   bool          mSignalFollowing;
   bool          mDebug;
 
   TrackIdtoSignalMap        mTrackIdToSignalMap;
   TargetIndexToSensorNameId mTargetIndexToSensorNameId;
 
   TrackIdToTrackIdMap mMergedTrackIdMap;        // processed to raw track mappings
   TrackIdToTrackIdMap mReverseMergedTrackIdMap; // raw to processed track mappings
};
 
#endif