writeStateInstance.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/


#pragma once

#include "legionDataStore/export.h"
#include "legionDataStore/dataTypes.h"
#include "legionDataStore/span.h"

#include <string>
#include <vector>

namespace Legion
{
   typedef UInt64 InstanceHandle;
   typedef UInt32 AttributeIndex;
   typedef UInt32 AttributeSetId;

   class SimulationDatabase;

   class LEGION_DLL WriteStateInstance
   {
   public:
      static AttributeSetId setType(InstanceHandle id);

      //All derived classes must implement this function
      //static AttributeSetId type();

   public:
      WriteStateInstance();
      WriteStateInstance(InstanceHandle instanceId);

      virtual ~WriteStateInstance();

      WriteStateInstance(const WriteStateInstance& orig);

      WriteStateInstance& operator=(const WriteStateInstance& orig);

      bool isValid() const;

      InstanceHandle instanceHandle() const { return myInstanceHandle; }

      GlobalIdentifier globalId() const;

      AttributeSetId setType() const;

      template<typename DATA_TYPE>
      DATA_TYPE data(AttributeIndex attributeId) const;

      template<typename DATA_TYPE>
      const Span<DATA_TYPE> dataArray(AttributeIndex attributeIndex) const;


      template<typename DATA_TYPE>
      void setData(AttributeIndex attributeIndex, const DATA_TYPE& val);

      template<typename DATA_TYPE>
      void setDataArray(AttributeIndex attributeIndex, const Span<DATA_TYPE>& val);



      template<typename DATA_TYPE>
      void addDataArray(AttributeIndex attributeIndex, const Span<DATA_TYPE>& val);

      template<typename DATA_TYPE>
      void removeDataArray(AttributeIndex attributeIndex, const Span<DATA_TYPE>& val);

      UInt32 dataArrayCount(AttributeIndex attributeIndex) const;
      void setDataArrayCount(AttributeIndex attributeIndex, UInt32 count);

      virtual bool hasParent() const;
      virtual Legion::InstanceHandle getParent() const;
      virtual void setParent(const WriteStateInstance& val);

      template<typename COMP_TYPE>
      COMP_TYPE findParent() const;

      virtual int extensionCount() const;
      virtual void addExtension(WriteStateInstance& val);
      virtual void removeExtension(WriteStateInstance& val);

      virtual Legion::InstanceHandle getExtension(int index) const;
      virtual Legion::Span<Legion::InstanceHandle> extensions() const;
      virtual void setExtensions(Legion::Span<Legion::InstanceHandle> val);

      //tries to find the component of a given type.  If there is more than
      //one component of that type, this gets the ordinal index component of that type
      //from a list of only those component types.
      //i.e findComponent<IffComponent>(2) will return the 3rd IffComponent attached to the entity if it exists
      template<typename COMP_TYPE>
      COMP_TYPE findTypeExtension(int index) const;

      //convince function for finding the count of a given type of component
      template<typename COMP_TYPE>
      int typeExtensionCount() const;

      template<typename COMP_TYPE>
      std::vector<COMP_TYPE> getTypeExtensions() const;

   protected:
      InstanceHandle myInstanceHandle;
   };

   template<typename COMP_TYPE>
   COMP_TYPE WriteStateInstance::findParent() const
   {
      Legion::InstanceHandle parentId = getParent();
      if (COMP_TYPE::isType(parentId))
      {
         return COMP_TYPE(parentId);  // create component interface
      }

      return COMP_TYPE();
   }

   template<typename COMP_TYPE>
   COMP_TYPE WriteStateInstance::findTypeExtension(int index) const
   {
      int maxComponents = extensionCount();
      int matchedCompCount = -1;
      for (int i = 0; i < maxComponents; i++)
      {
         Legion::InstanceHandle compId = getExtension(i);
         if (!COMP_TYPE::isType(compId))
         {
            continue;
         }

         matchedCompCount++;
         if (matchedCompCount == index)
         {
            return COMP_TYPE(compId);  // create component interface
         }
      }

      return COMP_TYPE();
   }

   template<typename COMP_TYPE>
   int WriteStateInstance::typeExtensionCount() const
   {
      int count = 0;
      int maxComponents = extensionCount();
      for (int i = 0; i < maxComponents; i++)
      {
         if (COMP_TYPE::isType(getExtension(i)))
         {
            count++;
         }
      }

      return count;
   }

   template<typename COMP_TYPE>
   std::vector<COMP_TYPE> WriteStateInstance::getTypeExtensions() const
   {
      std::vector<COMP_TYPE> ret;
      int maxComponents = extensionCount();
      for (int i = 0; i < maxComponents; i++)
      {
         Legion::InstanceHandle compId = getExtension(i);
         if (COMP_TYPE::isType(compId))
         {
            ret.push_back(COMP_TYPE(compId));
         }
      }

      return ret;
   }
}