WsfCommMediumContainer.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 WSFCOMMMEDIUMCONTAINER_HPP
#define WSFCOMMMEDIUMCONTAINER_HPP
 
#include "wsf_export.h"
 
#include <memory>
#include <set>
 
#include "UtInput.hpp"
#include "WsfCommMedium.hpp"
#include "WsfCommMediumTypeIdentifier.hpp"
#include "WsfComponent.hpp"
#include "WsfComponentFactory.hpp"
#include "WsfComponentRoles.hpp"
#include "WsfScenario.hpp"
#include "WsfSimulation.hpp"
 
namespace wsf
{
namespace comm
{
namespace medium
{

class WSF_EXPORT Container
{
public:
   enum InputAction : int
   {
      cNONE,
      cADD,
      cEDIT,
      cDELETE
   };
 
   Container(const WsfScenario& aScenario)
      : mScenario(aScenario)
   {
   }
   Container(const Container& aSrc);
   virtual ~Container() = default;
 
   Medium* GetMedium() const { return mMedium.get(); }
   void    SetMedium(std::shared_ptr<Medium> aMedium) { mMedium = aMedium; }

   virtual bool ProcessInput(UtInput& aInput);
 
   virtual bool Initialize(double aSimTime);

   void SetSimulation(WsfSimulation* aSimPtr) { mSimPtr = aSimPtr; }

   virtual bool ProcessContainerInput(UtInput& aInput, InputAction aAction = cNONE);
 
   const std::set<TypeIdentifier>& GetValidMediums() const { return mValidMediums; }

   void AddValidMedium(TypeIdentifier aValue);

   void AddForbiddenMedium(TypeIdentifier aValue);

   bool IsValidMedium(TypeIdentifier aValue) const;


   void           SetDefaultMedium(TypeIdentifier aValue);
   TypeIdentifier GetDefaultMedium() const { return mDefaultMedium; }

   virtual bool AddDefaultMedium();
 
   const WsfScenario& GetScenario() const { return mScenario; }
 
private:
   const WsfScenario&       mScenario;
   WsfSimulation*           mSimPtr{nullptr};
   std::shared_ptr<Medium>  mMedium{nullptr};
   std::set<TypeIdentifier> mValidMediums{};
   std::set<TypeIdentifier> mForbiddenMediums{};
   TypeIdentifier           mDefaultMedium{TypeIdentifier::cNONE};
};
 
// Forward declare
template<typename PARENT>
class ContainerComponent;

template<typename PARENT>
class ContainerFactory : public WsfComponentFactory<PARENT>
{
public:
   bool ProcessAddOrEditCommand(UtInput& aInput, PARENT& aParent, bool aIsAdding) override
   {
      // This is a wrapper for medium usage. Redirect input back to the container for proper processing.
      auto containerPtr = wsf::comm::medium::ContainerComponent<PARENT>::Find(aParent);
      if (containerPtr)
      {
         wsf::comm::medium::Container::InputAction action;
         if (aIsAdding)
         {
            action = wsf::comm::medium::Container::cADD;
         }
         else
         {
            action = wsf::comm::medium::Container::cEDIT;
         }
 
         return containerPtr->ProcessContainerInput(aInput, action);
      }
 
      return false;
   }
 
   bool ProcessDeleteCommand(UtInput& aInput, PARENT& aParent) override
   {
      // This is a wrapper for medium usage. Redirect input back to the container for proper processing.
      auto containerPtr = wsf::comm::medium::ContainerComponent<PARENT>::Find(aParent);
      if (containerPtr)
      {
         auto action = wsf::comm::medium::Container::cDELETE;
         return containerPtr->ProcessContainerInput(aInput, action);
      }
 
      return false;
   }
 
   bool PreInitialize(double aSimTime, PARENT& aParent) override
   {
      // At the time PreInitialize is called, all input has been parsed.
      // If user input has not resulted in a viable medium added to the container,
      // a default instance is required.
      auto containerPtr = wsf::comm::medium::ContainerComponent<PARENT>::Find(aParent);
      if (containerPtr && !containerPtr->GetMedium())
      {
         return containerPtr->AddDefaultMedium();
      }
 
      return true;
   }
};
 
WSF_EXPORT WsfStringId GetContainerComponentName();

template<typename PARENT>
class ContainerComponent : public Container, public WsfComponentT<PARENT>
{
public:
   ContainerComponent(const WsfScenario& aScenario)
      : Container(aScenario)
   {
   }

   bool Initialize(double aSimTime) override { return Container::Initialize(aSimTime); }

   bool ProcessInput(UtInput& aInput) override { return Container::ProcessInput(aInput); }
 
   ~ContainerComponent() override = default;


   static ContainerComponent<PARENT>* Find(const PARENT& aParent)
   {
      const auto& components   = aParent.GetComponents();
      auto        containerPtr = components.template GetComponent<ContainerComponent<PARENT>>();
 
      return containerPtr;
   }
 
   static ContainerComponent<PARENT>* FindOrCreate(PARENT& aParent, const WsfScenario& aScenario)
   {
      auto containerPtr = Find(aParent);
      if (!containerPtr)
      {
         auto  clonedContainer = ut::make_unique<ContainerComponent<PARENT>>(aScenario);
         auto& components      = aParent.GetComponents();
         if (components.AddComponent(clonedContainer.get()))
         {
            containerPtr = clonedContainer.release();
         }
      }
      return containerPtr;
   }



   WsfComponent* CloneComponent() const override { return new ContainerComponent<PARENT>(*this); }
   WsfStringId   GetComponentName() const override { return GetContainerComponentName(); }
   const int*    GetComponentRoles() const override
   {
      static const int roles[] = {cCOMPONENT_ROLE<ContainerComponent<PARENT>>(), cWSF_COMPONENT_NULL};
 
      return roles;
   }
 
   void* QueryInterface(int aRole) override
   {
      if (aRole == cCOMPONENT_ROLE<ContainerComponent<PARENT>>())
      {
         return this;
      }
 
      return nullptr;
   }

};
 
} // namespace medium
} // namespace comm
} // namespace wsf
 
#endif