WsfComponentFactoryList.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 WSFCOMPONENTFACTORYLIST_HPP
#define WSFCOMPONENTFACTORYLIST_HPP
 
#include <memory>
 
#include "UtLog.hpp"
#include "WsfComponentFactory.hpp"
#include "WsfScenario.hpp"

 
template<typename PARENT_TYPE>
class WsfComponentFactoryList
{
public:
   typedef std::vector<std::unique_ptr<WsfComponentFactoryBase>> FactoryList;
   typedef WsfComponentFactory<PARENT_TYPE>                      FactoryType;
 
   class Iterator
   {
   public:
      Iterator(const WsfScenario& aScenario)
         : mFactoryList(aScenario.GetComponentFactoryList())
      {
         mIndex      = 0;
         mSize       = mFactoryList.size();
         mParentRole = cCOMPONENT_ROLE<PARENT_TYPE>();
 
         // If the first factory is defined but doesn't have the desired role, we must advance
         // the iterator to the dereferencing operator will return the first entry with the
         // desired role (if one exists).
         if ((mIndex != mSize) && (mParentRole != mFactoryList[mIndex]->GetParentRole()))
         {
            AdvanceP();
         }
      }

      FactoryType* operator*() const { return static_cast<FactoryType*>(mFactoryList[mIndex].get()); }

      Iterator& operator++()
      {
         AdvanceP();
         return *this;
      }

      bool AtEnd() const { return mIndex >= mSize; }
 
   private:
      void AdvanceP()
      {
         ++mIndex;
         while ((mIndex < mSize) && (mParentRole != mFactoryList[mIndex]->GetParentRole()))
         {
            ++mIndex;
         }
      }
 
      const FactoryList& mFactoryList;
      size_t             mSize;
      size_t             mIndex;
      int                mParentRole;
   };


 
   static void PreInput(const WsfScenario& aScenario, PARENT_TYPE& aParent)
   {
      for (Iterator iter(aScenario); !iter.AtEnd(); ++iter)
      {
         (*iter)->PreInput(aParent);
      }
   }
 
   static bool ProcessInput(const WsfScenario& aScenario, UtInput& aInput, PARENT_TYPE& aParent)
   {
      for (Iterator iter(aScenario); !iter.AtEnd(); ++iter)
      {
         if ((*iter)->ProcessInput(aInput, aParent))
         {
            return true;
         }
      }
      return false;
   }
 
   static bool ProcessAddOrEditCommand(const WsfScenario& aScenario, UtInput& aInput, PARENT_TYPE& aParent, bool aIsAdding)
   {
      for (Iterator iter(aScenario); !iter.AtEnd(); ++iter)
      {
         if ((*iter)->ProcessAddOrEditCommand(aInput, aParent, aIsAdding))
         {
            return true;
         }
      }
      return false;
   }
 
   static void ProcessDeleteCommand(const WsfScenario& aScenario, UtInput& aInput, PARENT_TYPE& aParent)
   {
      std::string componentType(aInput.GetCommand());
      for (Iterator iter(aScenario); !iter.AtEnd(); ++iter)
      {
         if ((*iter)->ProcessDeleteCommand(aInput, aParent))
         {
            return;
         }
      }
      throw UtInput::BadValue(aInput, "Unknown object type to delete: " + componentType);
   }
 
   static bool PreInitialize(const WsfScenario& aScenario, double aSimTime, PARENT_TYPE& aParent)
   {
      bool ok(true);
      for (Iterator iter(aScenario); !iter.AtEnd(); ++iter)
      {
         if (!(*iter)->PreInitialize(aSimTime, aParent))
         {
            ok       = false;
            auto out = ut::log::error() << "Component factory pre-initialization failed.";
            out.AddNote() << "Component: " << aParent.GetName();
         }
      }
      return ok;
   }

};
 
#endif