submodule/include/importers/import_stack.hpp

   1 #ifndef _RIVE_IMPORT_STACK_HPP_
   2 #define _RIVE_IMPORT_STACK_HPP_
   3 #include "status_code.hpp"
   4 #include <algorithm>
   5 #include <unordered_map>
   6 #include <vector>
   7 #include <algorithm>
   8
   9 namespace rive
  10 {
  11         class ImportStackObject
  12         {
  13         public:
  14                 virtual ~ImportStackObject() {}
  15                 virtual StatusCode resolve() { return StatusCode::Ok; }
  16                 virtual bool readNullObject() { return false; }
  17         };
  18
  19         class ImportStack
  20         {
  21         private:
  22                 std::unordered_map<uint16_t, ImportStackObject*> m_Latests;
  23                 std::vector<ImportStackObject*> m_LastAdded;
  24
  25         public:
  26                 template <typename T = ImportStackObject> T* latest(uint16_t coreType)
  27                 {
  28                         auto itr = m_Latests.find(coreType);
  29                         if (itr == m_Latests.end())
  30                         {
  31                                 return nullptr;
  32                         }
  33                         return reinterpret_cast<T*>(itr->second);
  34                 }
  35
  36                 StatusCode makeLatest(uint16_t coreType, ImportStackObject* object)
  37                 {
  38                         // Clean up the old object in the stack.
  39                         auto itr = m_Latests.find(coreType);
  40                         if (itr != m_Latests.end())
  41                         {
  42                                 auto stackObject = itr->second;
  43
  44                                 // Remove it from latests.
  45                                 auto itr = std::find(
  46                                     m_LastAdded.begin(), m_LastAdded.end(), stackObject);
  47                                 if (itr != m_LastAdded.end())
  48                                 {
  49                                         m_LastAdded.erase(itr);
  50                                 }
  51
  52                                 StatusCode code = stackObject->resolve();
  53                                 delete stackObject;
  54                                 if (code != StatusCode::Ok)
  55                                 {
  56                                         m_Latests.erase(coreType);
  57                                         return code;
  58                                 }
  59                         }
  60
  61                         // Set the new one.
  62                         if (object == nullptr)
  63                         {
  64                                 m_Latests.erase(coreType);
  65                         }
  66                         else
  67                         {
  68                                 m_Latests[coreType] = object;
  69                                 m_LastAdded.push_back(object);
  70                         }
  71                         return StatusCode::Ok;
  72                 }
  73
  74                 StatusCode resolve()
  75                 {
  76                         for (auto& pair : m_Latests)
  77                         {
  78                                 StatusCode code = pair.second->resolve();
  79                                 if (code != StatusCode::Ok)
  80                                 {
  81                                         return code;
  82                                 }
  83                         }
  84                         return StatusCode::Ok;
  85                 }
  86
  87                 ~ImportStack()
  88                 {
  89                         for (auto& pair : m_Latests)
  90                         {
  91                                 delete pair.second;
  92                         }
  93                 }
  94
  95                 bool readNullObject()
  96                 {
  97                         for (auto itr = m_LastAdded.rbegin(); itr != m_LastAdded.rend();
  98                              itr++)
  99                         {
 100                                 if ((*itr)->readNullObject())
 101                                 {
 102                                         return true;
 103                                 }
 104                         }
 105                         return false;
 106                 }
 107         };
 108 } // namespace rive
 109 #endif