Add a way to get variable and list owner target

Author: adazem009

include/scratchcpp/iengine.h

@@ -16,6 +16,8 @@ class Broadcast;
 class Block;
 class Target;
 class Sprite;
+class Variable;
+class List;
 class Script;
 
 /*!
@@ -176,6 +178,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the index of the target with the given name. */
         virtual int findTarget(const std::string &targetName) const = 0;
 
+        /*! Returns the target which owns the given variable. If it is the stage, the variable is global. */
+        virtual Target *variableOwner(Variable *variable) const = 0;
+
+        /*! Returns the target which owns the given list. If it is the stage, the list is global. */
+        virtual Target *listOwner(List *list) const = 0;
+
         /*! Returns the list of extension names. */
         virtual const std::vector<std::string> &extensions() const = 0;
 

src/engine/internal/engine.cpp

@@ -509,15 +509,31 @@ const std::vector<std::shared_ptr<Target>> &Engine::targets() const
 void Engine::setTargets(const std::vector<std::shared_ptr<Target>> &newTargets)
 {
     m_targets = newTargets;
+    m_variableOwners.clear();
+    m_listOwners.clear();
 
-    // Set engine in targets and engine and target in all blocks
     for (auto target : m_targets) {
+        // Set engine in the target
         target->setEngine(this);
         auto blocks = target->blocks();
+
         for (auto block : blocks) {
+            // Set engine and target in the block
             block->setEngine(this);
             block->setTarget(target.get());
         }
+
+        // Add variables to owner map
+        const auto &variables = target->variables();
+
+        for (auto variable : variables)
+            m_variableOwners[variable.get()] = target.get();
+
+        // Add lists to owner map
+        const auto &lists = target->lists();
+
+        for (auto list : lists)
+            m_listOwners[list.get()] = target.get();
     }
 }
 
@@ -540,6 +556,26 @@ int Engine::findTarget(const std::string &targetName) const
     return -1;
 }
 
+Target *Engine::variableOwner(Variable *variable) const
+{
+    auto it = m_variableOwners.find(variable);
+
+    if (it == m_variableOwners.cend())
+        return nullptr;
+
+    return it->second;
+}
+
+Target *Engine::listOwner(List *list) const
+{
+    auto it = m_listOwners.find(list);
+
+    if (it == m_listOwners.cend())
+        return nullptr;
+
+    return it->second;
+}
+
 const std::vector<std::string> &Engine::extensions() const
 {
     return m_extensions;

src/engine/internal/engine.h

@@ -68,6 +68,9 @@ class Engine : public IEngine
         Target *targetAt(int index) const override;
         int findTarget(const std::string &targetName) const override;
 
+        Target *variableOwner(Variable *variable) const override;
+        Target *listOwner(List *list) const override;
+
         const std::vector<std::string> &extensions() const override;
         void setExtensions(const std::vector<std::string> &newExtensions) override;
 
@@ -95,6 +98,8 @@ class Engine : public IEngine
         std::vector<VirtualMachine *> m_scriptsToRemove;
         std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> m_scripts;
         std::vector<BlockFunc> m_functions;
+        std::unordered_map<Variable *, Target *> m_variableOwners;
+        std::unordered_map<List *, Target *> m_listOwners;
 
         bool m_breakFrame = false;
         bool m_skipFrame = false;

test/engine/engine_test.cpp

@@ -1,5 +1,7 @@
 #include <scratchcpp/broadcast.h>
 #include <scratchcpp/block.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 
 #include "../common.h"
 #include "testsection.h"
@@ -283,3 +285,49 @@ TEST(EngineTest, Targets)
     ASSERT_EQ(block1->engine(), &engine);
     ASSERT_EQ(block2->engine(), &engine);
 }
+
+TEST(EngineTest, VariableOwner)
+{
+    Engine engine;
+    auto t1 = std::make_shared<Target>();
+    auto t2 = std::make_shared<Target>();
+    auto t3 = std::make_shared<Target>();
+
+    auto var1 = std::make_shared<Variable>("", "", Value());
+    auto var2 = std::make_shared<Variable>("", "", Value());
+    auto var3 = std::make_shared<Variable>("", "", Value());
+    auto var4 = std::make_shared<Variable>("", "", Value());
+    t1->addVariable(var1);
+    t1->addVariable(var4);
+    t3->addVariable(var3);
+
+    engine.setTargets({ t1, t2, t3 });
+
+    ASSERT_EQ(engine.variableOwner(var1.get()), t1.get());
+    ASSERT_EQ(engine.variableOwner(var2.get()), nullptr);
+    ASSERT_EQ(engine.variableOwner(var3.get()), t3.get());
+    ASSERT_EQ(engine.variableOwner(var4.get()), t1.get());
+}
+
+TEST(EngineTest, ListOwner)
+{
+    Engine engine;
+    auto t1 = std::make_shared<Target>();
+    auto t2 = std::make_shared<Target>();
+    auto t3 = std::make_shared<Target>();
+
+    auto list1 = std::make_shared<List>("", "");
+    auto list2 = std::make_shared<List>("", "");
+    auto list3 = std::make_shared<List>("", "");
+    auto list4 = std::make_shared<List>("", "");
+    t1->addList(list1);
+    t1->addList(list4);
+    t3->addList(list3);
+
+    engine.setTargets({ t1, t2, t3 });
+
+    ASSERT_EQ(engine.listOwner(list1.get()), t1.get());
+    ASSERT_EQ(engine.listOwner(list2.get()), nullptr);
+    ASSERT_EQ(engine.listOwner(list3.get()), t3.get());
+    ASSERT_EQ(engine.listOwner(list4.get()), t1.get());
+}

test/mocks/enginemock.h

@@ -56,6 +56,9 @@ class EngineMock : public IEngine
         MOCK_METHOD(Target *, targetAt, (int), (const, override));
         MOCK_METHOD(int, findTarget, (const std::string &), (const, override));
 
+        MOCK_METHOD(Target *, variableOwner, (Variable *), (const, override));
+        MOCK_METHOD(Target *, listOwner, (List *), (const, override));
+
         MOCK_METHOD(std::vector<std::string> &, extensions, (), (const, override));
         MOCK_METHOD(void, setExtensions, (const std::vector<std::string> &), (override));