WsfCommMedium.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2019 Infoscitex, a DCS 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 WSFCOMMMEDIUM_HPP
#define WSFCOMMMEDIUM_HPP
 
#include "wsf_export.h"
 
#include <string>
#include <vector>
 
class UtInput;
#include "UtCloneablePtr.hpp"
#include "UtMath.hpp"
#include "UtScriptAccessible.hpp"
#include "UtScriptClassDefine.hpp"
#include "WsfCommMediumMessageStatus.hpp"
#include "WsfCommMediumTypeIdentifier.hpp"
#include "WsfCommMessage.hpp"
#include "WsfObject.hpp"
#include "WsfRandomVariable.hpp"
#include "WsfScenario.hpp"
#include "WsfSimulation.hpp"
#include "script/WsfScriptObjectClass.hpp"
 
namespace wsf
{
namespace comm
{
 
class Layer;
 
namespace medium
{

enum class TransmissionResult : size_t
{
   cFAILURE_UNSPECIFIED,
   cSUCCESS,
   cFAILURE_CHANNEL_LIMIT_REACHED,
   cFAILURE_NONEXISTENT_RECEIVER,
   cFAILURE_UNCONNECTED_RECEIVER,
   cFAILURE_EM_INTERACTION
};

class WSF_EXPORT Mode : public UtScriptAccessible
{
public:
   Mode() = default;
   Mode(const std::string& aName)
      : mName(aName)
   {
   }
   virtual ~Mode()             = default;
   Mode(const Mode& aSrc)      = default;
   virtual Mode* Clone() const = 0;
 
   const char* GetScriptClassName() const override { return "WsfCommMediumMode"; }
 
   virtual bool ProcessInput(UtInput& aInput) { return false; };
 
   virtual double GetTransmissionTime(double aSimTime, Comm& aXmtr, Layer* aLayerPtr, Message& aMessage) = 0;
 
   virtual double GetPropagationTime(double aSimTime, Comm& aXmtr, Comm& aRcvr, Message& aMessage) = 0;
 
   virtual double GetPacketLossTime(double aSimTime, Message& aMessage) = 0;
 
   const std::string& GetName() const { return mName; }
   void               SetName(const std::string& aName) { mName = aName; }
 
private:
   std::string mName{};
};

class WSF_EXPORT ScriptMediumModeClass : public UtScriptClass
{
public:
   ScriptMediumModeClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);
 
   ~ScriptMediumModeClass() override = default;
 
   UT_DECLARE_SCRIPT_METHOD(GetName);
};

class WSF_EXPORT Medium : public WsfObject
{
public:
   using ModeIt       = std::vector<std::unique_ptr<Mode>>::iterator;
   using const_ModeIt = std::vector<std::unique_ptr<Mode>>::const_iterator;
 
   Medium(WsfScenario& aScenario);
   ~Medium() override = default;
   Medium(const Medium& aSrc);
   Medium& operator=(Medium& aRhs);
 
   const char* GetScriptClassName() const override { return "WsfCommMedium"; }
 
   Medium*      Clone() const override = 0;
   bool         ProcessInput(UtInput& aInput) override;
   virtual bool Initialize(double aSimTime);
 
   void           SetSimulation(WsfSimulation* aSimPtr) { mSimPtr = aSimPtr; }
   WsfSimulation* GetSimulation() const { return mSimPtr; }


   virtual TransmissionResult TransmitMessage(double aSimTime, Layer* aLayerPtr, Message& aMessage, Comm& aXmtr) = 0;
 
   virtual void EndTransmission(double aSimTime, const Message::Identifier& aIdentifier) = 0;
 
   virtual void PropagateMessage(double aSimTime, const Message::Identifier& aIdentifier) = 0;
 
   virtual void EndPropagation(double aSimTime, const Message::Identifier& aIdentifier) = 0;
 
   virtual TypeIdentifier GetMediumIdentifier() const = 0;
 
   size_t                  GetNumModes() const { return mModes.size(); }
   size_t                  GetCurrentModeIndex() const { return mModeIndex; }
   std::pair<size_t, bool> GetModeIndex(const std::string& aModeName) const;
   size_t                  GetNumChannels() const { return mChannels; }
   const std::string&      GetActiveModeName() const;
   bool                    IsMediumShared() const { return mShared; }
   bool                    UserDirectedSharing() const { return mUseSharing; }
   size_t                  GetCurrentTransmissions() const;
   size_t                  GetNumMessageStatuses() const { return mMessages.size(); }


   bool SetActiveMode(const std::string& aModeName);
   bool SetActiveMode(size_t aIndex);
   void SetActiveModeDelayed(const std::string& aModeName);
   void SetActiveModeDelayed(size_t aIndex);
 
   void SetIsShared(bool aIsShared) { mShared = aIsShared; }


   MessageStatus* GetMessageStatus(const Message::Identifier& aIdentifier);
   MessageStatus* GetMessageStatusByIndex(size_t aIndex);

   virtual std::unique_ptr<Mode> CreateDefaultMode() const = 0;
 
   Mode* GetMode(const std::string& aModeName) const;
   Mode* GetMode(size_t aModeIndex) const;

   std::string ExecuteModeOnTransmit(double aSimTime, const Message& aMessage, const Comm& aXmtr, const Comm& aRcvr);
 
protected:
   void RemoveMessageStatus(const Message::Identifier& aIdentifier);
   void SetNumChannels(size_t aNumChannels) { mChannels = aNumChannels; }

   Mode* GetModeForTransmission(double aSimTime, Comm& aXmtr, Comm& aRcvr, Message& aMessage);

   std::unordered_map<Message::Identifier, MessageStatus> mMessages{};

   std::vector<ut::CloneablePtr<Mode>> mModes{};

   bool mShared{false};

   bool mDebug{false};

   std::shared_ptr<int> mEventPtr{nullptr};
 
private:
   size_t         mChannels{std::numeric_limits<size_t>::max()};
   size_t         mModeIndex{0U};
   std::string    mDefaultModeName{"default"};
   WsfScenario&   mScenario;
   WsfSimulation* mSimPtr{nullptr};

   bool mUseSharing{true};
 
   std::unique_ptr<WsfScriptContext> mContextPtr{nullptr};

   UtScript* mModeOnTransmit{nullptr};
};
 
class WSF_EXPORT ScriptMediumClass : public WsfScriptObjectClass
{
public:
   ScriptMediumClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);
 
   ~ScriptMediumClass() override = default;
 
   UT_DECLARE_SCRIPT_METHOD(ModeCount);
   UT_DECLARE_SCRIPT_METHOD(CurrentModeIndex);
   UT_DECLARE_SCRIPT_METHOD(CurrentModeName);
   UT_DECLARE_SCRIPT_METHOD(GetCurrentMode);
   UT_DECLARE_SCRIPT_METHOD(GetMode_1);
   UT_DECLARE_SCRIPT_METHOD(GetMode_2);
   UT_DECLARE_SCRIPT_METHOD(ChannelCount);
 
   UT_DECLARE_SCRIPT_METHOD(TransmissionCount);
   UT_DECLARE_SCRIPT_METHOD(MessageStatusCount);
   UT_DECLARE_SCRIPT_METHOD(GetMessageStatus);
   UT_DECLARE_SCRIPT_METHOD(GetMessageStatusByIndex);
   UT_DECLARE_SCRIPT_METHOD(CheckValidMessageStatus);
 
   UT_DECLARE_SCRIPT_METHOD(IsShared);
 
   UT_DECLARE_SCRIPT_METHOD(SetMode_1);
   UT_DECLARE_SCRIPT_METHOD(SetMode_2);
};
 
} // namespace medium
} // namespace comm
} // namespace wsf
 
#endif