WsfObjectTypeList.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 WSFOBJECTTYPELIST_HPP
#define WSFOBJECTTYPELIST_HPP
 
#include "wsf_export.h"
 
#include <algorithm>
#include <cassert>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
#include "WsfObject.hpp"
#include "WsfObjectTypeListBase.hpp"
#include "WsfStringId.hpp"
#include "WsfTypes.hpp"

 
template<class T>
class WsfObjectTypeList : public WsfObjectTypeListBase
{
public:
   typedef T               ObjectType;
   typedef std::vector<T*> ObjectPtrList;
 
protected:
   template<typename DEFAULT_TYPE>
   static WsfObject* CreateDefaultFunction()
   {
      return new DEFAULT_TYPE;
   }
 
   static WsfObject* CreateFunction()
   {
      WsfObject* objectPtr = new ObjectType();
      return objectPtr;
   }
 
   template<typename FACTORY_LIST>
   static WsfObject* FactoryCreateFunction(void* aListPtr, const std::string& aTypeName)
   {
      const FACTORY_LIST& aList = *((FACTORY_LIST*)aListPtr);
      for (typename FACTORY_LIST::const_iterator i = aList.begin(); i != aList.end(); ++i)
      {
         WsfObject* newObjectPtr = (*i)(aTypeName);
         if (newObjectPtr != nullptr)
         {
            return newObjectPtr;
         }
      }
      return nullptr;
   }
 
public:
   WsfObjectTypeList(WsfScenario& aScenario, unsigned int aFlags, const std::string& aBlockName)
      : WsfObjectTypeListBase(aFlags, aBlockName, &aScenario)
   {
   }
 
   WsfObjectTypeList(WsfScenario& aScenario, const std::string& aBlockName)
      : WsfObjectTypeListBase(0, aBlockName, &aScenario)
   {
   }

   bool Add(WsfStringId aId, std::unique_ptr<T> aDefinitionPtr)
   {
      static_assert(std::is_base_of<WsfObject, T>::value, "Add requires a WsfObject");
      return AddP(aId, std::move(aDefinitionPtr));
   }

   bool AddCoreType(WsfStringId aId, std::unique_ptr<T> aDefinitionPtr)
   {
      static_assert(std::is_base_of<WsfObject, T>::value, "AddCoreType requires a WsfObject");
      if (AddP(aId, std::move(aDefinitionPtr)))
      {
         mCoreTypes.insert(aId);
         return true;
      }
      return false;
   }

   T* Clone(WsfStringId aId) const override
   {
      static_assert(std::is_base_of<WsfObject, ObjectType>::value, "Type does not support Clone()");
      return static_cast<T*>(CloneP(aId));
   }

 
   T* Find(WsfStringId aId) const override { return static_cast<ObjectType*>(FindP(aId)); }

   ObjectPtrList GetCoreTypes() const
   {
      ObjectPtrList typePtrVec;
      for (const auto& typeEntry : mCoreTypes)
      {
         auto it = mTypeMap.find(typeEntry);
         if (it != std::end(mTypeMap))
         {
            typePtrVec.push_back(static_cast<ObjectType*>(it->second.get()));
         }
      }
 
      return typePtrVec;
   }
 
   void GetCurrentTypes(ObjectPtrList& aListOfPtrs) const
   {
      aListOfPtrs.clear();
 
      for (TypeMap::const_iterator iter = mTypeMap.begin(); iter != mTypeMap.end(); ++iter)
      {
         aListOfPtrs.push_back(static_cast<ObjectType*>(iter->second.get()));
      }
   }

   void GetCurrentUserTypes(ObjectPtrList& aListOfPtrs) const
   {
      aListOfPtrs.clear();
 
      for (TypeMap::const_iterator iter = mTypeMap.begin(); iter != mTypeMap.end(); ++iter)
      {
         if (mCoreTypes.find(iter->first) == mCoreTypes.end())
         {
            aListOfPtrs.push_back(static_cast<ObjectType*>(iter->second.get()));
         }
      }
   }
 
   bool IsType(WsfStringId aTypeName) const { return Find(aTypeName) != nullptr; }

   struct LoadResult
   {
      LoadResult()
         : mIsCommandProcessed(false)
         , mObjectTypePtr(nullptr)
      {
      }

           operator bool() const { return mIsCommandProcessed; }
      bool mIsCommandProcessed;
      ObjectType* mObjectTypePtr;
   };
 
   void SetSingularBaseType()
   {
      mCreateSingularTypeFunction = &WsfObjectTypeList<T>::CreateFunction;
      assert(mFactoryCreateFunction == nullptr);
      mFlags |= cSINGULAR_BASE_TYPE;
   }
 
   template<typename FACTORY_LIST>
   void SetObjectFactory(const FACTORY_LIST* aFactoryListPtr)
   {
      mFactoryPtr = (void*)aFactoryListPtr;
      // mFactoryCreateFunction = &WsfObjectTypeList<T>::FactoryCreateFunction<FACTORY_LIST>;
      mFactoryCreateFunction = &FactoryCreateFunction<FACTORY_LIST>;
      assert(mCreateSingularTypeFunction == nullptr);
   }
 
   template<typename DEFAULT_TYPE>
   void SetObjectFactoryDefault()
   {
      mFactoryCreateDefault = &CreateDefaultFunction<DEFAULT_TYPE>;
   }
 
   // =================================================================================================
   virtual LoadResult LoadType(UtInput& aInput)
   {
      LoadResult result;
      WsfObject* loadedObjectPtr = nullptr;
      result.mIsCommandProcessed = LoadTypeP(aInput, loadedObjectPtr);
      result.mObjectTypePtr      = static_cast<ObjectType*>(loadedObjectPtr);
      return result;
   }
 
   bool ProcessInput(UtInput& aInput) override { return LoadType(aInput); }
 
   virtual bool InitializeType(ObjectType* aTypePtr) { return true; }


   bool LoadNamedComponent(UtInput& aInput, WsfPlatform& aPlatform, bool aIsAdding, int aRole)
   {
      return LoadComponentP(aInput, aPlatform, aIsAdding, aRole, true, true);
   }
 
   bool LoadUnnamedComponent(UtInput& aInput, WsfPlatform& aPlatform, bool aIsAdding, int aRole)
   {
      return LoadComponentP(aInput, aPlatform, aIsAdding, aRole, false, true);
   }
 
   bool LoadUnnamedComponentWithoutEdit(UtInput& aInput, WsfPlatform& aPlatform, bool aIsAdding, int aRole)
   {
      return LoadComponentP(aInput, aPlatform, aIsAdding, aRole, false, false);
   }
 
   bool DeleteNamedComponent(UtInput& aInput, WsfPlatform& aPlatform, int aRole)
   {
      return DeleteComponentP(aInput, aPlatform, aRole, true);
   }
 
   bool DeleteUnnamedComponent(UtInput& aInput, WsfPlatform& aPlatform, int aRole)
   {
      return DeleteComponentP(aInput, aPlatform, aRole, false);
   }

 
protected:
   bool InitializeTypeP(WsfObject* aObjectPtr) override { return InitializeType(static_cast<ObjectType*>(aObjectPtr)); }
 
private:
   // Copy constructor is declared but not defined in order to prevent its use.
   WsfObjectTypeList(const WsfObjectTypeList& aSrc) = delete;
   // Assignment operator is declared but not defined in order to prevent its use.
   WsfObjectTypeList& operator=(const WsfObjectTypeList& aRhs) = delete;
};
 
#endif