Add monitor change function

Author: adazem009

include/scratchcpp/global.h

@@ -32,6 +32,7 @@ enum class ScratchVersion
 class VirtualMachine;
 class Compiler;
 class Block;
+class Value;
 
 /*!
  * \typedef BlockFunc
@@ -54,6 +55,13 @@ using BlockComp = void (*)(Compiler *);
  */
 using MonitorNameFunc = const std::string &(*)(Block *);
 
+/*!
+ * \typedef MonitorChangeFunc
+ *
+ * MonitorChangeFunc is a function pointer for functions which are used to change monitor values.
+ */
+using MonitorChangeFunc = void (*)(Block *, const Value &newValue);
+
 } // namespace libscratchcpp
 
 #endif // LIBSCRATCHCPP_GLOBAL_H

include/scratchcpp/iengine.h

@@ -223,6 +223,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
          */
         virtual void addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f) = 0;
 
+        /*!
+         * Call this from IBlockSection#registerBlocks() to add a monitor value change function to a block section.
+         * \see <a href="blockSections.html">Block sections</a>
+         */
+        virtual void addMonitorChangeFunction(IBlockSection *section, const std::string &opcode, MonitorChangeFunc f) = 0;
+
         /*!
          * Call this from IBlockSection#registerBlocks() to add a hat block to a block section.
          * \see <a href="blockSections.html">Block sections</a>

src/engine/internal/blocksectioncontainer.cpp

@@ -16,6 +16,11 @@ void BlockSectionContainer::addMonitorNameFunction(const std::string &opcode, Mo
     m_monitorNameFunctions[opcode] = f;
 }
 
+void BlockSectionContainer::addMonitorChangeFunction(const std::string &opcode, MonitorChangeFunc f)
+{
+    m_monitorChangeFunctions[opcode] = f;
+}
+
 void BlockSectionContainer::addHatBlock(const std::string &opcode)
 {
     m_compileFunctions[opcode] = &dummyFunction;
@@ -50,6 +55,13 @@ MonitorNameFunc BlockSectionContainer::resolveMonitorNameFunc(const std::string
     return nullptr;
 }
 
+MonitorChangeFunc BlockSectionContainer::resolveMonitorChangeFunc(const std::string &opcode) const
+{
+    if (m_monitorChangeFunctions.count(opcode) == 1)
+        return m_monitorChangeFunctions.at(opcode);
+    return nullptr;
+}
+
 int BlockSectionContainer::resolveInput(const std::string &name) const
 {
     if (m_inputs.count(name) == 1)

src/engine/internal/blocksectioncontainer.h

@@ -17,20 +17,23 @@ class BlockSectionContainer
 
         void addCompileFunction(const std::string &opcode, BlockComp f);
         void addMonitorNameFunction(const std::string &opcode, MonitorNameFunc f);
+        void addMonitorChangeFunction(const std::string &opcode, MonitorChangeFunc f);
         void addHatBlock(const std::string &opcode);
         void addInput(const std::string &name, int id);
         void addField(const std::string &name, int id);
         void addFieldValue(const std::string &value, int id);
 
         BlockComp resolveBlockCompileFunc(const std::string &opcode) const;
         MonitorNameFunc resolveMonitorNameFunc(const std::string &opcode) const;
+        MonitorChangeFunc resolveMonitorChangeFunc(const std::string &opcode) const;
         int resolveInput(const std::string &name) const;
         int resolveField(const std::string &name) const;
         int resolveFieldValue(const std::string &value) const;
 
     private:
         std::unordered_map<std::string, BlockComp> m_compileFunctions;
         std::unordered_map<std::string, MonitorNameFunc> m_monitorNameFunctions;
+        std::unordered_map<std::string, MonitorChangeFunc> m_monitorChangeFunctions;
         std::unordered_map<std::string, int> m_inputs;
         std::unordered_map<std::string, int> m_fields;
         std::unordered_map<std::string, int> m_fieldValues;

src/engine/internal/engine.cpp

@@ -820,6 +820,14 @@ void Engine::addMonitorNameFunction(IBlockSection *section, const std::string &o
         container->addMonitorNameFunction(opcode, f);
 }
 
+void Engine::addMonitorChangeFunction(IBlockSection *section, const std::string &opcode, MonitorChangeFunc f)
+{
+    auto container = blockSectionContainer(section);
+
+    if (container)
+        container->addMonitorChangeFunction(opcode, f);
+}
+
 void Engine::addHatBlock(IBlockSection *section, const std::string &opcode)
 {
     auto container = blockSectionContainer(section);

src/engine/internal/engine.h

@@ -103,6 +103,7 @@ class Engine : public IEngine
 
         void addCompileFunction(IBlockSection *section, const std::string &opcode, BlockComp f) override;
         void addMonitorNameFunction(IBlockSection *section, const std::string &opcode, MonitorNameFunc f) override;
+        void addMonitorChangeFunction(IBlockSection *section, const std::string &opcode, MonitorChangeFunc f) override;
         void addHatBlock(IBlockSection *section, const std::string &opcode) override;
         void addInput(IBlockSection *section, const std::string &name, int id) override;
         void addField(IBlockSection *section, const std::string &name, int id) override;

test/mocks/enginemock.h

@@ -84,6 +84,7 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(void, addCompileFunction, (IBlockSection *, const std::string &, BlockComp), (override));
         MOCK_METHOD(void, addMonitorNameFunction, (IBlockSection *, const std::string &, MonitorNameFunc), (override));
+        MOCK_METHOD(void, addMonitorChangeFunction, (IBlockSection *, const std::string &, MonitorChangeFunc), (override));
         MOCK_METHOD(void, addHatBlock, (IBlockSection *, const std::string &), (override));
         MOCK_METHOD(void, addInput, (IBlockSection *, const std::string &, int), (override));
         MOCK_METHOD(void, addField, (IBlockSection *, const std::string &, int), (override));