WsfCoverageIntervalConstraint.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2021 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 WSFCOVERAGEINTERVALCONSTRAINT_HPP
#define WSFCOVERAGEINTERVALCONSTRAINT_HPP
 
#include <string>
#include <vector>
 
#include "UtCloneablePtr.hpp"
class UtInput;
 
#include "wsf_coverage_export.h"
 
#include "WsfCoverageRawDataOutput.hpp"
 
namespace wsf
{
namespace coverage
{
 
class AccessInterval;
class Coverage;
class FreeAsset;
class GridAsset;

class WSF_COVERAGE_EXPORT IntervalConstraint
{
public:
   IntervalConstraint()                                 = default;
   IntervalConstraint(const IntervalConstraint& aOther) = default;
   ~IntervalConstraint()                                = default;
 
   IntervalConstraint* Clone() const { return new IntervalConstraint{*this}; }
   bool                ProcessInput(UtInput& aInput);

   void Initialize(const Coverage& aCoverage, const std::string& aOutputDir);

   void Finalize(const UtCalendar& aSimStartEpoch) const;

   bool FilterInterval(const GridAsset& aGridAsset, const FreeAsset& aFreeAsset, const AccessInterval& aInterval) const;

   std::string GetOutputFileName() const;
 
private:
   class Filter
   {
   public:
      bool ProcessInput(UtInput& aInput);
 
      bool FilterInterval(const IntervalConstraint& aConstraint,
                          const GridAsset&          aGridAsset,
                          const FreeAsset&          aFreeAsset,
                          const AccessInterval&     aInterval) const;
 
   private:
      enum class ConstraintType
      {
         cPLATFORM_NAME,
         cPLATFORM_TYPE,
         cDEVICE_NAME,
         cDEVICE_TYPE,
         cUNKNOWN
      };
 
      void ReadLimits(UtInput& aInput);
      bool MeetsConstraint(double aDuration) const;
 
      ConstraintType mType{ConstraintType::cUNKNOWN};
      std::string    mIdentifier{};
      double         mMinimum{-1.0};
      double         mMaximum{-2.0};
   };
 
   bool IsPlatformOfType(const std::string& aPlatformName, const std::string& aPlatformType) const;
   bool IsPlatformDeviceOfType(const std::string& aPlatformName,
                               const std::string& aDeviceName,
                               const std::string& aDeviceType) const;

   const Coverage* mCoveragePtr{nullptr};

   ut::CloneablePtr<RawDataOutput> mFilteredIntervalsPtr{nullptr};

   std::vector<Filter> mFilters{};
};
 
} // namespace coverage
} // namespace wsf
 
#endif // WSFCOVERAGEINTERVALCONSTRAINT_HPP