Use unique_ptr in import stack. Diffs= 01d20e026 Use unique_ptr in import stack. (#7307) Co-authored-by: Luigi Rosso <luigi-rosso@users.noreply.github.com>
diff --git a/.rive_head b/.rive_head index 8e96435..ee9abc1 100644 --- a/.rive_head +++ b/.rive_head
@@ -1 +1 @@ -5ad13845d3ca1a130b61fb16e6c3627356e31f79 +01d20e02661309cd2f8a0702f9de102107c1a0f1
diff --git a/include/rive/importers/import_stack.hpp b/include/rive/importers/import_stack.hpp index ae03495..5e0436f 100644 --- a/include/rive/importers/import_stack.hpp +++ b/include/rive/importers/import_stack.hpp
@@ -5,6 +5,7 @@ #include <unordered_map> #include <vector> #include <algorithm> +#include <memory> namespace rive { @@ -18,41 +19,36 @@ class ImportStack { -private: - std::unordered_map<uint16_t, ImportStackObject*> m_Latests; - std::vector<ImportStackObject*> m_LastAdded; - public: template <typename T = ImportStackObject> T* latest(uint16_t coreType) { - auto itr = m_Latests.find(coreType); - if (itr == m_Latests.end()) + auto itr = m_latests.find(coreType); + if (itr == m_latests.end()) { return nullptr; } - return static_cast<T*>(itr->second); + return static_cast<T*>(itr->second.get()); } - StatusCode makeLatest(uint16_t coreType, ImportStackObject* object) + StatusCode makeLatest(uint16_t coreType, std::unique_ptr<ImportStackObject> object) { // Clean up the old object in the stack. - auto itr = m_Latests.find(coreType); - if (itr != m_Latests.end()) + auto itr = m_latests.find(coreType); + if (itr != m_latests.end()) { - auto stackObject = itr->second; + auto stackObject = itr->second.get(); // Remove it from latests. - auto lastAddedItr = std::find(m_LastAdded.begin(), m_LastAdded.end(), stackObject); - if (lastAddedItr != m_LastAdded.end()) + auto lastAddedItr = std::find(m_lastAdded.begin(), m_lastAdded.end(), stackObject); + if (lastAddedItr != m_lastAdded.end()) { - m_LastAdded.erase(lastAddedItr); + m_lastAdded.erase(lastAddedItr); } StatusCode code = stackObject->resolve(); - delete stackObject; if (code != StatusCode::Ok) { - m_Latests.erase(coreType); + m_latests.erase(coreType); return code; } } @@ -60,12 +56,12 @@ // Set the new one. if (object == nullptr) { - m_Latests.erase(coreType); + m_latests.erase(coreType); } else { - m_Latests[coreType] = object; - m_LastAdded.push_back(object); + m_lastAdded.push_back(object.get()); + m_latests[coreType] = std::move(object); } return StatusCode::Ok; } @@ -76,7 +72,7 @@ // Reverse iterate the last added import stack objects and resolve them. // If any don't resolve, capture the return code and stop resolving. - for (auto itr = m_LastAdded.rbegin(); itr != m_LastAdded.rend(); itr++) + for (auto itr = m_lastAdded.rbegin(); itr != m_lastAdded.rend(); itr++) { StatusCode code = (*itr)->resolve(); if (code != StatusCode::Ok) @@ -86,28 +82,15 @@ } } - // Clean the import stack before returning the resolve code. - for (ImportStackObject* stackObject : m_LastAdded) - { - delete stackObject; - } - m_Latests.clear(); - m_LastAdded.clear(); + m_latests.clear(); + m_lastAdded.clear(); return returnCode; } - ~ImportStack() - { - for (auto& pair : m_Latests) - { - delete pair.second; - } - } - bool readNullObject() { - for (auto itr = m_LastAdded.rbegin(); itr != m_LastAdded.rend(); itr++) + for (auto itr = m_lastAdded.rbegin(); itr != m_lastAdded.rend(); itr++) { if ((*itr)->readNullObject()) { @@ -116,6 +99,10 @@ } return false; } + +private: + std::unordered_map<uint16_t, std::unique_ptr<ImportStackObject>> m_latests; + std::vector<ImportStackObject*> m_lastAdded; }; } // namespace rive #endif
diff --git a/src/file.cpp b/src/file.cpp index 83edfc6..1fc3fbb 100644 --- a/src/file.cpp +++ b/src/file.cpp
@@ -171,7 +171,7 @@ } return nullptr; } - auto file = std::unique_ptr<File>(new File(factory, assetLoader)); + auto file = rivestd::make_unique<File>(factory, assetLoader); auto readResult = file->read(reader, header); if (result) @@ -226,22 +226,23 @@ delete object; continue; } - ImportStackObject* stackObject = nullptr; + std::unique_ptr<ImportStackObject> stackObject = nullptr; auto stackType = object->coreType(); switch (stackType) { case Backboard::typeKey: - stackObject = new BackboardImporter(object->as<Backboard>()); + stackObject = rivestd::make_unique<BackboardImporter>(object->as<Backboard>()); break; case Artboard::typeKey: - stackObject = new ArtboardImporter(object->as<Artboard>()); + stackObject = rivestd::make_unique<ArtboardImporter>(object->as<Artboard>()); break; case LinearAnimation::typeKey: - stackObject = new LinearAnimationImporter(object->as<LinearAnimation>()); + stackObject = + rivestd::make_unique<LinearAnimationImporter>(object->as<LinearAnimation>()); break; case KeyedObject::typeKey: - stackObject = new KeyedObjectImporter(object->as<KeyedObject>()); + stackObject = rivestd::make_unique<KeyedObjectImporter>(object->as<KeyedObject>()); break; case KeyedProperty::typeKey: { @@ -252,11 +253,13 @@ return ImportResult::malformed; } stackObject = - new KeyedPropertyImporter(importer->animation(), object->as<KeyedProperty>()); + rivestd::make_unique<KeyedPropertyImporter>(importer->animation(), + object->as<KeyedProperty>()); break; } case StateMachine::typeKey: - stackObject = new StateMachineImporter(object->as<StateMachine>()); + stackObject = + rivestd::make_unique<StateMachineImporter>(object->as<StateMachine>()); break; case StateMachineLayer::typeKey: { @@ -266,8 +269,9 @@ return ImportResult::malformed; } - stackObject = new StateMachineLayerImporter(object->as<StateMachineLayer>(), - artboardImporter->artboard()); + stackObject = + rivestd::make_unique<StateMachineLayerImporter>(object->as<StateMachineLayer>(), + artboardImporter->artboard()); break; } @@ -277,33 +281,36 @@ case AnimationState::typeKey: case BlendState1D::typeKey: case BlendStateDirect::typeKey: - stackObject = new LayerStateImporter(object->as<LayerState>()); + stackObject = rivestd::make_unique<LayerStateImporter>(object->as<LayerState>()); stackType = LayerState::typeKey; break; case StateTransition::typeKey: case BlendStateTransition::typeKey: - stackObject = new StateTransitionImporter(object->as<StateTransition>()); + stackObject = + rivestd::make_unique<StateTransitionImporter>(object->as<StateTransition>()); stackType = StateTransition::typeKey; break; case StateMachineListener::typeKey: - stackObject = new StateMachineListenerImporter(object->as<StateMachineListener>()); + stackObject = rivestd::make_unique<StateMachineListenerImporter>( + object->as<StateMachineListener>()); break; case ImageAsset::typeKey: case FontAsset::typeKey: case AudioAsset::typeKey: - stackObject = - new FileAssetImporter(object->as<FileAsset>(), m_assetLoader, m_factory); + stackObject = rivestd::make_unique<FileAssetImporter>(object->as<FileAsset>(), + m_assetLoader, + m_factory); stackType = FileAsset::typeKey; break; } - if (importStack.makeLatest(stackType, stackObject) != StatusCode::Ok) + if (importStack.makeLatest(stackType, std::move(stackObject)) != StatusCode::Ok) { // Some previous stack item didn't resolve. return ImportResult::malformed; } if (object->is<StateMachineLayerComponent>() && importStack.makeLatest(StateMachineLayerComponent::typeKey, - new StateMachineLayerComponentImporter( + rivestd::make_unique<StateMachineLayerComponentImporter>( object->as<StateMachineLayerComponent>())) != StatusCode::Ok) { return ImportResult::malformed;