Mirrors/rive-cpp
0
0
Fork 0
mirror of https://github.com/rive-app/rive-cpp.git synced 2026-01-18 21:21:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

Use unique_ptr in import stack.

Browse Source 
Diffs=
01d20e026 Use unique_ptr in import stack. (#7307)

Co-authored-by: Luigi Rosso <luigi-rosso@users.noreply.github.com>
This commit is contained in:
luigi-rosso
2024-05-24 21:30:48 +00:00
parent eb046e6c5c
commit 3f9e940167
3 changed files with 48 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.rive_head
View File

@@ -1 +1 @@
5ad13845d3ca1a130b61fb16e6c3627356e31f79
01d20e02661309cd2f8a0702f9de102107c1a0f1

59
include/rive/importers/import_stack.hpp
View File

@@ -5,6 +5,7 @@
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <memory>
namespace rive
{
@@ -18,41 +19,36 @@ public:
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 @@ public:
// 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 @@ public:
// 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 @@ public:
}
}
// 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 @@ public:
}
return false;
}
private:
std::unordered_map<uint16_t, std::unique_ptr<ImportStackObject>> m_latests;
std::vector<ImportStackObject*> m_lastAdded;
};
} // namespace rive
#endif

41
src/file.cpp
View File

@@ -171,7 +171,7 @@ std::unique_ptr<File> File::import(Span<const uint8_t> bytes,
}
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 @@ ImportResult File::read(BinaryReader& reader, const RuntimeHeader& header)
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 @@ ImportResult File::read(BinaryReader& reader, const RuntimeHeader& header)
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 @@ ImportResult File::read(BinaryReader& reader, const RuntimeHeader& header)
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 @@ ImportResult File::read(BinaryReader& reader, const RuntimeHeader& header)
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;