WsfComponentList.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 WSFCOMPONENTLIST_HPP
#define WSFCOMPONENTLIST_HPP
 
#include "wsf_export.h"
 
#include <algorithm>
#include <stdexcept>
#include <utility>
#include <vector>
 
#include "WsfComponent.hpp"
 
// *************************************************************************************************
// PROGRAMMING NOTE:
//
// Most of the methods within WsfComponent and WsfComponentList include the word 'Component' in the
// name to avoid name conflicts if this class is derived from by another class (e.g.: WsfPlatform).
// Also, some classes derive from both WsfComponent and WsfComponentList (i.e. they are a component,
// but they also support sub-components). Thus, there may be no name conflicts between them.
// *************************************************************************************************

//
// PROGRAMMING NOTE: This must be exported so these methods are available to all dynamic libraries.
//
// PROGRAMMING NOTE: The base class should not include the AddComponent method. This is a requirement
//                   to ensure type-safety of derived component lists. Otherwise it would be possible
//                   to inject components of the wrong type into a typed component list.
class WSF_EXPORT WsfComponentList
{
public:
   using NameAndComponent = std::pair<WsfStringId, WsfComponent*>;
   using ComponentList    = std::vector<NameAndComponent>;
 
   WsfComponentList();
   WsfComponentList(const WsfComponentList& aSrc);
   WsfComponentList(WsfComponentList&&) = default;
   virtual ~WsfComponentList();
 
   WsfComponentList& operator=(const WsfComponentList& aRhs);
   WsfComponentList& operator=(WsfComponentList&&);

   bool HasComponents() const { return (!mComponentsByName.empty()); }
 
   void DeleteAllComponents();
 
   bool DeleteComponent(WsfStringId aName, int aRole);
 
   unsigned int GetComponentCount(int aRole) const;



   template<class T>
   bool DeleteComponent(WsfStringId aName)
   {
      return DeleteComponent(aName, cCOMPONENT_ROLE<T>());
   }

   template<class T>
   bool DeleteComponent()
   {
      bool deleted(false);
      T*   componentPtr = static_cast<T*>(FindComponentByRoleP(cCOMPONENT_ROLE<T>()));
      if (componentPtr != nullptr)
      {
         deleted = DeleteComponent(componentPtr->GetComponentName(), cCOMPONENT_ROLE<T>());
      }
      return deleted;
   }

   template<class T>
   T* GetComponent() const
   {
      return static_cast<T*>(FindComponentByRoleP(cCOMPONENT_ROLE<T>()));
   }

   template<class T>
   T* GetComponent(WsfStringId aName) const
   {
      return static_cast<T*>(FindComponentP(aName, cCOMPONENT_ROLE<T>()));
   }

   template<class T>
   unsigned int GetComponentCount() const
   {
      return GetComponentCount(cCOMPONENT_ROLE<T>());
   }

   template<class T>
   T* GetComponentEntry(unsigned int aEntry) const
   {
      return static_cast<T*>(GetComponentEntryByRoleP(cCOMPONENT_ROLE<T>(), aEntry));
   }


   template<class T>
   bool FindByRole(T*& aPtr) const
   {
      for (const auto& component : mComponentsByName)
      {
         if (component.second->QueryInterfaceT(aPtr))
         {
            return true;
         }
      }
      return false;
   }
 
   template<class T>
   class RoleRange;

   template<class T>
   class RoleIterator
   {
   public:
      RoleIterator(const WsfComponentList& aComponentList)
         : RoleIterator(aComponentList.mComponentsByName.begin(), aComponentList.mComponentsByName.end())
      {
      }
 
      RoleIterator(const RoleIterator&) = default;
      RoleIterator& operator=(const RoleIterator& aRhs) = default;

      T* operator*() const
      {
         T* componentPtr(nullptr);
         mIter->second->QueryInterfaceT(componentPtr);
         return componentPtr;
      }

      T* operator->() const
      {
         T* componentPtr(nullptr);
         if (!mIter->second->QueryInterfaceT(componentPtr))
         {
            throw std::out_of_range("Dereference of nullptr");
         }
         return componentPtr;
      }

      bool operator==(const RoleIterator& aOther) const { return mIter == aOther.mIter; }

      bool operator!=(const RoleIterator& aOther) const { return mIter != aOther.mIter; }

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

      bool AtEnd() const { return mIter == mEndIter; }
 
   protected:
      friend class RoleRange<T>;
 
      // Invariant: aIter and aEndIter must be from the same list.
      RoleIterator(ComponentList::const_iterator aIter, ComponentList::const_iterator aEndIter)
         : mIter(aIter)
         , mEndIter(aEndIter)
      {
         mRole = cCOMPONENT_ROLE<T>();
 
         if ((mIter != mEndIter) && !mIter->second->ComponentHasRole(mRole))
         {
            AdvanceP();
         }
      }
 
      void AdvanceP()
      {
         ++mIter;
         while (mIter != mEndIter)
         {
            if (mIter->second->ComponentHasRole(mRole))
            {
               break;
            }
            ++mIter;
         }
      }
 
      int                           mRole;
      ComponentList::const_iterator mIter;
      ComponentList::const_iterator mEndIter;
   };

   template<class T>
   class RoleRange
   {
   public:
      RoleRange(const WsfComponentList& aComponentList)
         : mComponentList(&aComponentList)
      {
      }
 
      RoleIterator<T> begin() { return RoleIterator<T>(*mComponentList); }
 
      RoleIterator<T> end()
      {
         return RoleIterator<T>(mComponentList->mComponentsByName.end(), mComponentList->mComponentsByName.end());
      }
 
   private:
      const WsfComponentList* mComponentList;
   };

   template<typename T>
   RoleRange<T> GetComponentRange()
   {
      return RoleRange<T>(*this);
   }
 
protected:
   virtual void ComponentAdded(WsfComponent* aComponentPtr);
   virtual void ComponentDeleted(WsfComponent* aComponentPtr);
 
   bool AddComponentP(WsfComponent* aComponentPtr, bool aDoNotify);
 
   void CopyAllP(const WsfComponentList& aSrc, bool aDoNotify);
 
   void DeleteAllP(bool aDoNotify);
 
   bool DeleteComponentP(WsfStringId aName, int aRole, bool aDoNotify);
 
   WsfComponent* FindComponentP(WsfStringId aName, int aRole) const;
 
   WsfComponent* FindComponentP(WsfStringId aName) const;
 
   WsfComponent* FindComponentByRoleP(int aRole) const;
 
   WsfComponent* GetComponentEntryByRoleP(int aRole, unsigned int aEntry) const;
 
   bool RemoveComponentP(WsfStringId aName, int aRole, bool aDelete, bool aDoNotify);
 
   ComponentList mComponentsByName;
};

template<class COMPONENT_TYPE>
class WsfComponentListT : public WsfComponentList
{
public:
   using ComponentType = COMPONENT_TYPE;
   using ParentType    = typename COMPONENT_TYPE::ParentType;



   class Iterator
   {
   public:
      Iterator(const ComponentList::const_iterator& aSrc)
         : mIterator(aSrc)
      {
      }

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

      bool operator!=(const Iterator& aRhs) const { return mIterator != aRhs.mIterator; }

      ComponentType* operator*() const { return static_cast<ComponentType*>(mIterator->second); }

      ComponentType* operator->() const { return static_cast<ComponentType*>(mIterator->second); }
 
   private:
      ComponentList::const_iterator mIterator;
   };


   Iterator Begin() const { return Iterator(mComponentsByName.begin()); }

   Iterator End() const { return Iterator(mComponentsByName.end()); }
 
   WsfComponentListT()
      : WsfComponentList()
      , mParentOfComponentsPtr(nullptr)
   {
   }
 
   // ===========================================================================================
   // PROGRAMMING NOTE: Do NOT be tempted to put in copy constructor that includes the new parent.
   // In most cases the initializer for this list would be something like: "mComponents(aSrc, this)".
   // and ANYTHING that refers to 'this' (directly or indirectly) is VERY dangerous.
   // ===========================================================================================
 
   WsfComponentListT(const WsfComponentListT& aSrc)
      : WsfComponentList(aSrc)
      , mParentOfComponentsPtr(nullptr)
   {
   }
 
   WsfComponentListT(WsfComponentListT&&) = default;
 
   ~WsfComponentListT() override {}
 
   WsfComponentListT& operator=(const WsfComponentListT& aRhs)
   {
      if (this != &aRhs)
      {
         DeleteAllP(true);
         CopyAllP(aRhs, false);
         SetParentOfComponents(mParentOfComponentsPtr);
      }
      return *this;
   }
 
   WsfComponentListT& operator=(WsfComponentListT&& aRhs)
   {
      if (this != &aRhs)
      {
         this->WsfComponentList::operator=(std::move(aRhs));
         SetParentOfComponents(mParentOfComponentsPtr);
      }
      return *this;
   }

   ParentType* GetParentOfComponents() const { return mParentOfComponentsPtr; }

   void SetParentOfComponents(ParentType* aComponentParentPtr)
   {
      mParentOfComponentsPtr = aComponentParentPtr;
      for (const auto& component : mComponentsByName)
      {
         ComponentType* componentPtr(static_cast<ComponentType*>(component.second));
         componentPtr->SetComponentParent(mParentOfComponentsPtr);
         // The component isn't actually being added to the list here, but it is logically being
         // added to list because this has been deferred to from the copy construction.
         ComponentAdded(componentPtr);
      }
   }
 
   bool AddComponent(ComponentType* aComponentPtr)
   {
      bool added = AddComponentP(aComponentPtr, true);
      if (added)
      {
         aComponentPtr->SetComponentParent(mParentOfComponentsPtr);
      }
      return added;
   }
 
   ComponentType* FindComponent(WsfStringId aName) const { return static_cast<ComponentType*>(FindComponentP(aName)); }
 
   ComponentType* FindComponent(WsfStringId aName, int aRole) const
   {
      return static_cast<ComponentType*>(FindComponentP(aName, aRole));
   }
 
   ComponentType* FindComponentByRole(int aRole) const
   {
      return static_cast<ComponentType*>(FindComponentByRoleP(aRole));
   }
 
   ComponentType* GetComponentEntryByRole(int aRole, unsigned int aEntry) const
   {
      return static_cast<ComponentType*>(GetComponentEntryByRoleP(aRole, aEntry));
   }

   std::vector<ComponentType*> GetComponentsByInitializationOrder() const
   {
      std::vector<ComponentType*> components;
      for (const auto& component : mComponentsByName)
      {
         components.push_back(static_cast<ComponentType*>(component.second));
      }
 
      auto compare = [](const WsfComponent* aLhs, const WsfComponent* aRhs)
      { return aLhs->GetComponentInitializationOrder() < aRhs->GetComponentInitializationOrder(); };
      std::stable_sort(components.begin(), components.end(), compare);
      return components;
   }
 
   bool RemoveComponent(ComponentType* aComponentPtr)
   {
      bool removed =
         RemoveComponentP(aComponentPtr->GetComponentName(), aComponentPtr->GetComponentRoles()[0], false, true);
      if (removed)
      {
         aComponentPtr->SetComponentParent(nullptr);
      }
      return removed;
   }
 
   bool ProcessComponentInput(UtInput& aInput)
   {
      bool myCommand{false};
      for (ComponentType* componentPtr : *this)
      {
         if (componentPtr->ProcessInput(aInput))
         {
            myCommand = true;
            break;
         }
      }
      return myCommand;
   }
 
private:
   ParentType* mParentOfComponentsPtr;
};

using WsfPlatformComponentList = WsfComponentListT<WsfPlatformComponent>;
 
template<class T>
typename WsfComponentListT<T>::Iterator begin(const WsfComponentListT<T>& aList)
{
   return aList.Begin();
}
 
template<class T>
typename WsfComponentListT<T>::Iterator end(const WsfComponentListT<T>& aList)
{
   return aList.End();
}
 
template<class T>
typename WsfComponentListT<T>::Iterator begin(WsfComponentListT<T>& aList)
{
   return aList.Begin();
}
 
template<class T>
typename WsfComponentT<T>::Iterator end(WsfComponentListT<T>& aList)
{
   return aList.End();
}
 
#endif