view.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/callback.h"
#include "legionDataStore/readStateInstance.h"
#include "legionDataStore/viewManager.h"

#include "legionDataStoreImpl/c_api.h"

#include <vector>
#include <string>
#include <atomic>
#include <mutex>

namespace Legion
{
   typedef UInt64 ViewHandle;
   typedef UInt64 InstanceHandle;

   class SimulationDatabase;

   class LEGION_DLL View
   {
   public:
      View(ViewHandle handle, SimulationDatabase& database);

      virtual ~View();

      virtual void initialize();
      
      virtual std::string name() const;

      virtual UInt32 count() const;

      virtual Scope scope() const;


      SimulationDatabase& database() const;

   protected:
      virtual void reset();

      ViewHandle myHandle;
      SimulationDatabase& myDatabase;
      friend class ViewManager;
      
      std::atomic<UInt32> myCount;
      bool myDirty;
   };


   template<typename SET_TYPE>
   class SetView : public View
   {
   public:
      struct InstanceUpdateData
      {
         SET_TYPE instance;
         std::vector<UInt32> attributesChanged;
      };

      typedef Callback<void(const std::vector<SET_TYPE>&)> InstanceCallback;
      typedef Callback<void(const std::vector<InstanceUpdateData>&)> InstanceUpdateCallback;
      typedef Callback<bool(const SET_TYPE& instance)> PredicateCallback;

   public:
      SetView(ViewHandle handle, SimulationDatabase& database);

      virtual ~SetView();

      std::vector<SET_TYPE>& instances();

      virtual bool addInstanceAddedCallback(InstanceCallback cb);
      virtual bool removeInstanceAddedCallback(InstanceCallback cb);

      virtual bool addInstanceMovedCallback(InstanceCallback cb);
      virtual bool removeInstanceMovedCallback(InstanceCallback cb);
     
      virtual bool addInstanceRemovedCallback(InstanceCallback cb);
      virtual bool removeInstanceRemovedCallback(InstanceCallback cb);

      virtual bool addInstanceUpdatedCallback(InstanceUpdateCallback cb, const std::vector<int>* attributeIndexFilter = nullptr);
      virtual bool removeInstanceUpdatedCallback(InstanceUpdateCallback cb);

      virtual void setPredicateFunction(PredicateCallback cb);

   protected:
      virtual void rebuildInstanceList();

      std::vector<SET_TYPE> myInstances;
      std::mutex myRebuildMutex;

      std::vector<InstanceCallback> myAddedCallbacks;
      std::vector<InstanceCallback> myMovedCallbacks;
      std::vector<InstanceCallback> myRemovedCallbacks;
      std::vector<InstanceUpdateCallback> myUpdatedCallbacks;
      PredicateCallback myPredicateFunction;

      static void addedCallback(void* usr, const InstanceHandle* instances, UInt32 count);
      static void movedCallback(void* usr, const InstanceHandle* instances, UInt32 count);
      static void removedCallback(void* usr, const InstanceHandle* instances, UInt32 count);
      static void updatedCallback(void* usr, const LEG_InstanceUpdateData* instances, UInt32 count, int cbIndex);
      static int predicate(void* usr, InstanceHandle instance);

      void callAddedCallbacks(const InstanceHandle* instances, UInt32 count);
      void callMovedCallbacks(const InstanceHandle* instances, UInt32 count);
      void callRemovedCallbacks(const InstanceHandle* instances, UInt32 count);
      void callUpdatedCallbacks(const LEG_InstanceUpdateData* instances, UInt32 count, int cbIndex);
   };
}

#include "legionDataStore/view.inl"