readStateInstance.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;
   typedef UInt64 DatabaseHandle;

   class SimulationDatabase;

   class LEGION_DLL ReadStateInstance
   {
   public:
      static AttributeSetId setType(InstanceHandle id);
      
      //All derived classes must implement this function
      //static AttributeSetId type();

   public:
      ReadStateInstance();
      explicit ReadStateInstance(InstanceHandle instanceId);

      ReadStateInstance(const ReadStateInstance& orig);

      ReadStateInstance& operator=(const ReadStateInstance& orig);

      virtual ~ReadStateInstance();
      
      virtual bool isValid() const;

      virtual InstanceHandle instanceHandle() const { return myInstanceHandle; }
       
      virtual GlobalIdentifier globalId() const;

      virtual AttributeSetId setType() const;

      DatabaseHandle database() const;

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

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

      virtual UInt32 dataArrayCount(AttributeIndex attributeIndex) const;

      virtual bool hasParent() const;
      virtual Legion::InstanceHandle getParent() const;

      template<typename COMP_TYPE>
      COMP_TYPE findParent() const;

      virtual int extensionCount() const;
      virtual Legion::InstanceHandle getExtension(int index) const;
      virtual Legion::Span<Legion::InstanceHandle> extensions() const;

      //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 ReadStateInstance::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 ReadStateInstance::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 ReadStateInstance::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> ReadStateInstance::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;
   }
}