WsfCyberEngagementManager.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2016 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 WSFCYBERENGAGEMENTMANAGER_HPP
#define WSFCYBERENGAGEMENTMANAGER_HPP
 
#include "wsf_cyber_export.h"
 
#include <list>
#include <map>
#include <memory>
 
#include "WsfCyberAttackParameters.hpp"
#include "WsfCyberEngagement.hpp"
#include "effects/WsfCyberEffect.hpp"
class WsfPlatform;
class WsfSimulation;
 
namespace wsf
{
namespace cyber
{
class WSF_CYBER_EXPORT EngagementManager
{
public:
   class EngagementData
   {
   public:
      EngagementData(Engagement aEngagement)
         : mEngagement(std::move(aEngagement))
      {
      }
      ~EngagementData() = default;

      EngagementData(const EngagementData& aSrc) = delete;
      EngagementData(EngagementData&& aSrc)      = default;
 
      Effect*                 GetEffect(const std::string& aEffectName) const;
      Engagement&             GetEngagement() { return mEngagement; }
      const AttackParameters& GetParameters() const { return mParameters; }
      bool                    IsParametersValid() const { return mParametersValid; }
 
      Effect& AddEffect(const std::string& aEffectName);
      void    RemoveEffect(const std::string& aEffectName);
      void    RemoveEffects();
      void    AddParameters(const AttackParameters& aParameters);
      void    RemoveParameters();
 
   protected:
      Engagement mEngagement;

      std::list<UtCloneablePtr<Effect>> mEngagementEffects{};
      AttackParameters                  mParameters{};
      bool                              mParametersValid{false};
   };
 
   using EngagementMap = std::unordered_map<size_t, EngagementData>;

   friend class Event;
 
   static EngagementManager& Get(WsfSimulation& aSimulation);
 
   EngagementManager() { mEngagements.reserve(500U); }
   ~EngagementManager()                             = default;
   EngagementManager(const EngagementManager& aSrc) = delete;
   const EngagementManager& operator=(const EngagementManager& aRhs) = delete;
 
   Engagement* FindEngagement(const std::string& aAttackType, const std::string& aAttacker, const std::string& aVictim);
   Engagement* FindEngagement(size_t aKey);
 
   bool EngagementExists(const std::string& aAttackType, const std::string& aAttacker, const std::string& aVictim) const;
   bool EngagementExists(size_t aKey) const;


   void CullVictimEngagements(const std::string& aVictim);
   void CullAttackerEngagements(const std::string& aAttacker);
 
   bool CyberAttack(const std::string& aAttackType,
                    const std::string& aAttacker,
                    const std::string& aVictim,
                    WsfSimulation&     aSimulation,
                    AttackParameters*  aParameters = nullptr);

   bool CyberScan(const std::string& aAttackType,
                  const std::string& aAttacker,
                  const std::string& aVictim,
                  WsfSimulation&     aSimulation);

   bool Cancel(size_t aKey);
 
protected:
   EngagementMap::iterator FindEngagementByPlatform(const std::string& aName, bool aByVictim);
 
   EngagementData* FindEngagementData(const std::string& aAttackType,
                                      const std::string& aAttacker,
                                      const std::string& aVictim);
   EngagementData* FindEngagementData(size_t aKey);

   EngagementData& AddEngagement(const std::string& aAttackType,
                                 const std::string& aAttacker,
                                 const std::string& aVictim,
                                 WsfSimulation&     aSimulation);


   void CyberScanInitialize(EngagementData& aEngagementData);
   void CyberScan(EngagementData& aEngagementData);


   void CyberAttackInitialize(EngagementData& aEngagementData);
   void CyberAttack(EngagementData& aEngagementData);
   void CyberAttackEffect(EngagementData& aEngagementData);
   void CyberAttackDetectionDelay(EngagementData& aEngagementData);
   void CyberAttackRecoveryDelay(EngagementData& aEngagementData);
 
private:
   EngagementMap mEngagements;
};
 
} // namespace cyber
} // namespace wsf
 
#endif