DtKeyedDataManagerTemplate.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>

#include <vrvUtil/signalslib.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtVirtualBaseClassCreator.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <tbb/concurrent_hash_map.h>
#include <tbb/concurrent_unordered_set.h>
#include <tbb/concurrent_vector.h>
#include <tbb/concurrent_queue.h>
#include <tbb/parallel_for.h>

#include <thread>
#include <functional>

#include <vlutil/vlUtil.h>


namespace makVrv
{
   class DtKeyedData;

   struct CreationResult
   {
      DtKeyedData* myTcsData = nullptr;
      bool myCreated = false;
   };

   template<typename KeyType, typename KeyTypeHasher>
   class DtKeyedDataManagerTemplate : public DtVirtualBaseClass
   {
   public:
      enum FlushKeysLocation
      {
         PRE_TICK = 0, POST_TICK = 1, NONE = 2
      };
   public:
      boost::signalslib::signal<void()> signal_KeysDeleted;
   public:
      DtKeyedDataManagerTemplate(DtDe& de, FlushKeysLocation flushLocation);

      virtual ~DtKeyedDataManagerTemplate();
   private:
      DtKeyedDataManagerTemplate() = delete;
      DtKeyedDataManagerTemplate(const DtKeyedDataManagerTemplate& rhs) = delete;
      DtKeyedDataManagerTemplate& operator=(const DtKeyedDataManagerTemplate& rhs) = delete;

   public:
      virtual CreationResult getOrCreate(const KeyType& key);

      virtual DtKeyedData* find(const KeyType& key) const;

      virtual void forEachKeyedData(const std::function<void(DtKeyedData*)>& func);

      virtual void keyedDatas(std::vector<DtKeyedData*>& vecKeyedDatas);

      template <class T>
      struct TemplatedCreationResult
      {
         T* myTcsUserData = nullptr;
         bool myCreated = false;
      };

      template<class ClassToCreate, class ...ConstructorArgs>
      TemplatedCreationResult<ClassToCreate> getOrCreateUserData(const KeyType& key, const void* userPointer
         , DtVirtualBaseClassCreator<ClassToCreate, ConstructorArgs...>* creator, ConstructorArgs&&... constructorArgs)
      {
         auto result = getOrCreate(key);
         DtKeyedData* tcsData = result.myTcsData;
         if (tcsData == nullptr)
         {
            myDe.DT_LOG_WARN << "tcsData == nullptr" << std::endl;
            return TemplatedCreationResult<ClassToCreate>{nullptr, false};
         }

         auto resultUserData = tcsData->getOrCreateUserData(userPointer, creator, std::forward<ConstructorArgs>(constructorArgs)...);
         ClassToCreate* userData = static_cast<ClassToCreate*>(resultUserData.myTcsUserData);
         if (userData == nullptr)
         {
            myDe.DT_LOG_WARN << "userData == nullptr" << std::endl;
         }

         return TemplatedCreationResult<ClassToCreate>{userData, resultUserData.myCreated};
      }
      template<class T>
      T* findUserData(const KeyType& key, const void* userPointer, bool log = true) const
      {
         DtKeyedData* tcsData = find(key);
         if (tcsData == nullptr)
         {
            if (log)
            {
               myDe.DT_LOG_WARN << "tcsData == nullptr" << std::endl;
            }
            return nullptr;
         }
         T* userData = static_cast<T*>(tcsData->findUserData(userPointer));
         if (userData == nullptr)
         {
            if (log)
            {
               myDe.DT_LOG_WARN << "userData == nullptr" << std::endl;
            }
         }
         return userData;
      }

      template <class T>
      struct FindResult
      {
         DtKeyedData* myTcsData = nullptr;
         T* myTcsUserData = nullptr;
      };

      template<class T>
      FindResult<T> findTcsDataAndUserData(const KeyType& key, const void* userPointer, bool log = true) const
      {
         DtKeyedData* tcsData = find(key);
         if (tcsData == nullptr)
         {
            if (log)
            {
               myDe.DT_LOG_WARN << "tcsData == nullptr" << std::endl;
            }
            return { nullptr, nullptr };
         }
         T* userData = static_cast<T*>(tcsData->findUserData(userPointer));
         if (userData == nullptr)
         {
            if (log)
            {
               myDe.DT_LOG_WARN << "userData == nullptr" << std::endl;
            }
         }
         return { tcsData, userData };
      }

      virtual void deleteTcsData(DtKeyedData* tcsData);
   protected:
      virtual void slot_preTick();

      virtual void slot_postTick();

      virtual void flushInvalidKeys();
   protected:

      typedef tbb::concurrent_hash_map< KeyType, DtKeyedData*, KeyTypeHasher> HashTable;
      HashTable myHashTable;

      DtDe& myDe;

      DtSignalConnectionManager myConnections;

      tbb::concurrent_queue<KeyType> myKeysToEraseScratchPad;
   };

   template<typename KeyType, typename KeyTypeHasher>
   DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::DtKeyedDataManagerTemplate(DtDe& de, FlushKeysLocation flushLocation)
      : myDe(de)
   {
      if (flushLocation == PRE_TICK)
      {
         myConnections += myDe.signal_preTick.connect(
            std::bind(&DtKeyedDataManagerTemplate::slot_preTick,
               this));
      }
      else if (flushLocation == POST_TICK)
      {
         myConnections += myDe.signal_postTick.connect(
            std::bind(&DtKeyedDataManagerTemplate::slot_postTick,
               this));
      }
      else if (flushLocation == NONE)
      {
         // no op
      }
      else
      {
         myDe.DT_LOG_WARN << "Unknown flush location: " << flushLocation << std::endl;
      }
   }

   template<typename KeyType, typename KeyTypeHasher>
   DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::~DtKeyedDataManagerTemplate()
   {
      tbb::parallel_for(myHashTable.range(), [](const typename HashTable::range_type& r) {
         for (auto i = r.begin(); i != r.end(); i++)
         {
            DtDELETE(i->second);
         }
         });
   }

   template<typename KeyType, typename KeyTypeHasher>
   void DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::forEachKeyedData(const std::function<void(DtKeyedData*)>& func)
   {
      tbb::parallel_for(myHashTable.range(), [=](const typename HashTable::range_type& r) {
         for (auto i = r.begin(); i != r.end(); i++)
         {
            func(i->second);
         }
         });
   }

   template<typename KeyType, typename KeyTypeHasher>
   void DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::keyedDatas(std::vector<DtKeyedData*>& vecKeyedDatas)
   {
      tbb::concurrent_queue<DtKeyedData*> queueKeyedDatas;
      tbb::parallel_for(myHashTable.range(), [&](const typename HashTable::range_type& r) {
         for (auto i = r.begin(); i != r.end(); i++)
         {
            queueKeyedDatas.push(i->second);
         }
         });

      DtKeyedData* keyedData = nullptr;
      while (queueKeyedDatas.try_pop(keyedData))
      {
         vecKeyedDatas.push_back(keyedData);
      }
   }

   template<typename KeyType, typename KeyTypeHasher>
   CreationResult DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::getOrCreate(const KeyType& key)
   {
      CreationResult result;
      typename HashTable::accessor accessor;
      const bool inserted = myHashTable.insert(accessor, key);
      if (inserted)
      {
         auto& entry = accessor->second;
         entry = new DtKeyedData(myDe, key.myName);
      }

      DtKeyedData* tcsData = accessor->second;
      if (tcsData == nullptr)
      {
         myDe.DT_LOG_WARN << "tcsData == nullptr" << std::endl;
      }
      return { tcsData, inserted };
   }

   template<typename KeyType, typename KeyTypeHasher>
   DtKeyedData* DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::find(const KeyType& key) const
   {
      typename HashTable::const_accessor accessor;
      const bool found = myHashTable.find(accessor, key);
      if (found == false)
      {
         return nullptr;
      }
      return accessor->second;
   }

   template<typename KeyType, typename KeyTypeHasher>
   void DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::deleteTcsData(DtKeyedData* tcsData)
   {
      if (tcsData == nullptr)
      {
         myDe.DT_LOG_WARN << "tcsData == nullptr" << std::endl;
         return;
      }

      KeyType keyToErase;
      std::atomic<bool> found{ false };
      tbb::parallel_for(myHashTable.range(), [&](const typename HashTable::range_type& r) {
         for (auto i = r.begin(); i != r.end(); i++)
         {
            if (i->second == tcsData)
            {
               found = true;
               keyToErase = i->first;
            }
         }
         });

      if (!found)
      {
         myDe.DT_LOG_WARN << "found == false" << std::endl;
         return;
      }

      myHashTable.erase(keyToErase);
      DtDELETE(tcsData);
   }

   template<typename KeyType, typename KeyTypeHasher>
   void DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::flushInvalidKeys(void)
   {
      myKeysToEraseScratchPad.clear();
      tbb::parallel_for(myHashTable.range(), [&](const typename HashTable::range_type& r) {
         for (auto i = r.begin(); i != r.end(); i++)
         {
            if (!i->first.valid())
            {
               myKeysToEraseScratchPad.push(i->first);
            }
         }
         });


      bool atleastOneDeleted = false;
      KeyType key;
      while (myKeysToEraseScratchPad.try_pop(key))
      {
         typename HashTable::accessor accessor;
         bool found = myHashTable.find(accessor, key);
         if (!found)
         {
            myDe.DT_LOG_WARN << "found == false" << std::endl;
            continue;
         }
         DtDELETE(accessor->second);
         myHashTable.erase(accessor);
         atleastOneDeleted = true;
      }

      if (atleastOneDeleted)
      {
         signal_KeysDeleted();
      }
   }

   template<typename KeyType, typename KeyTypeHasher>
   void DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::slot_preTick()
   {
      flushInvalidKeys();
   }

   template<typename KeyType, typename KeyTypeHasher>
   void DtKeyedDataManagerTemplate<KeyType, KeyTypeHasher>::slot_postTick()
   {
      flushInvalidKeys();
   }
}