Implement data_hidevariable block

Author: adazem009

src/blocks/variableblocks.cpp

@@ -24,6 +24,7 @@ void VariableBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "data_setvariableto", &compileSetVariable);
     engine->addCompileFunction(this, "data_changevariableby", &compileChangeVariableBy);
     engine->addCompileFunction(this, "data_showvariable", &compileShowVariable);
+    engine->addCompileFunction(this, "data_hidevariable", &compileHideVariable);
 
     // Monitor names
     engine->addMonitorNameFunction(this, "data_variable", &variableMonitorName);
@@ -71,6 +72,21 @@ void VariableBlocks::compileShowVariable(Compiler *compiler)
         compiler->addFunctionCall(&showVariable);
 }
 
+void VariableBlocks::compileHideVariable(Compiler *compiler)
+{
+    Field *field = compiler->field(VARIABLE);
+    assert(field);
+    Variable *var = static_cast<Variable *>(field->valuePtr().get());
+    assert(var);
+
+    compiler->addConstValue(var->id());
+
+    if (var->target() == static_cast<Target *>(compiler->engine()->stage()))
+        compiler->addFunctionCall(&hideGlobalVariable);
+    else
+        compiler->addFunctionCall(&hideVariable);
+}
+
 void VariableBlocks::setVarVisible(std::shared_ptr<Variable> var, bool visible)
 {
     if (var) {
@@ -99,6 +115,26 @@ unsigned int VariableBlocks::showVariable(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int VariableBlocks::hideGlobalVariable(VirtualMachine *vm)
+{
+    if (Stage *target = vm->engine()->stage()) {
+        int index = target->findVariableById(vm->getInput(0, 1)->toString());
+        setVarVisible(target->variableAt(index), false);
+    }
+
+    return 1;
+}
+
+unsigned int VariableBlocks::hideVariable(VirtualMachine *vm)
+{
+    if (Target *target = vm->target()) {
+        int index = target->findVariableById(vm->getInput(0, 1)->toString());
+        setVarVisible(target->variableAt(index), false);
+    }
+
+    return 1;
+}
+
 const std::string &VariableBlocks::variableMonitorName(Block *block)
 {
     Variable *var = dynamic_cast<Variable *>(block->findFieldById(VARIABLE)->valuePtr().get());

src/blocks/variableblocks.h

@@ -32,11 +32,14 @@ class VariableBlocks : public IBlockSection
         static void compileSetVariable(Compiler *compiler);
         static void compileChangeVariableBy(Compiler *compiler);
         static void compileShowVariable(Compiler *compiler);
+        static void compileHideVariable(Compiler *compiler);
 
         static void setVarVisible(std::shared_ptr<Variable> var, bool visible);
 
         static unsigned int showGlobalVariable(VirtualMachine *vm);
         static unsigned int showVariable(VirtualMachine *vm);
+        static unsigned int hideGlobalVariable(VirtualMachine *vm);
+        static unsigned int hideVariable(VirtualMachine *vm);
 
         static const std::string &variableMonitorName(Block *block);
         static void changeVariableMonitorValue(Block *block, const Value &newValue);

test/blocks/variable_blocks_test.cpp

@@ -75,6 +75,7 @@ TEST_F(VariableBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_setvariableto", &VariableBlocks::compileSetVariable)).Times(1);
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_changevariableby", &VariableBlocks::compileChangeVariableBy)).Times(1);
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_showvariable", &VariableBlocks::compileShowVariable)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_hidevariable", &VariableBlocks::compileHideVariable)).Times(1);
 
     // Monitor names
     EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "data_variable", &VariableBlocks::variableMonitorName));
@@ -316,3 +317,106 @@ TEST_F(VariableBlocksTest, ShowVariableImpl)
     ASSERT_FALSE(monitor1.visible());
     ASSERT_TRUE(monitor2.visible());
 }
+
+TEST_F(VariableBlocksTest, HideVariable)
+{
+    Compiler compiler(&m_engineMock);
+    Stage stage;
+    Target target;
+
+    // hide variable [var1]
+    auto var1 = std::make_shared<Variable>("b", "var1");
+    var1->setTarget(&stage);
+    auto block1 = createVariableBlock("a", "data_hidevariable", var1);
+
+    // hide variable [var2]
+    auto var2 = std::make_shared<Variable>("d", "var2");
+    var2->setTarget(&target);
+    auto block2 = createVariableBlock("c", "data_hidevariable", var2);
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&VariableBlocks::hideGlobalVariable)).WillOnce(Return(0));
+    compiler.init();
+    compiler.setBlock(block1);
+    VariableBlocks::compileHideVariable(&compiler);
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&VariableBlocks::hideVariable)).WillOnce(Return(1));
+    compiler.setBlock(block2);
+    VariableBlocks::compileHideVariable(&compiler);
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_CONST, 1, vm::OP_EXEC, 1, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "b", "d" }));
+    ASSERT_TRUE(compiler.variables().empty());
+    ASSERT_TRUE(compiler.lists().empty());
+}
+
+TEST_F(VariableBlocksTest, HideVariableImpl)
+{
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_HALT };
+    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 1, vm::OP_HALT };
+    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 1, vm::OP_HALT };
+    static BlockFunc functions[] = { &VariableBlocks::hideGlobalVariable, &VariableBlocks::hideVariable };
+    static Value constValues[] = { "a", "b", "c", "d" };
+
+    auto var1 = std::make_shared<Variable>("b", "");
+    Monitor monitor1("b", "");
+    monitor1.setVisible(true);
+    var1->setMonitor(&monitor1);
+
+    auto var2 = std::make_shared<Variable>("d", "");
+    Monitor monitor2("d", "");
+    monitor2.setVisible(true);
+    var2->setMonitor(&monitor2);
+
+    Stage stage;
+    stage.addVariable(var1);
+
+    Target target;
+    target.addVariable(var2);
+
+    // Global
+    VirtualMachine vm1(&stage, &m_engineMock, nullptr);
+    vm1.setBytecode(bytecode1);
+    vm1.setFunctions(functions);
+    vm1.setConstValues(constValues);
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    vm1.run();
+
+    ASSERT_EQ(vm1.registerCount(), 0);
+    ASSERT_TRUE(monitor1.visible());
+    ASSERT_TRUE(monitor2.visible());
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    vm1.reset();
+    vm1.setBytecode(bytecode2);
+    vm1.run();
+
+    ASSERT_EQ(vm1.registerCount(), 0);
+    ASSERT_FALSE(monitor1.visible());
+    ASSERT_TRUE(monitor2.visible());
+
+    monitor1.setVisible(true);
+
+    // Local
+    VirtualMachine vm2(&target, &m_engineMock, nullptr);
+    vm2.setBytecode(bytecode3);
+    vm2.setFunctions(functions);
+    vm2.setConstValues(constValues);
+    vm2.run();
+
+    ASSERT_EQ(vm2.registerCount(), 0);
+    ASSERT_TRUE(monitor1.visible());
+    ASSERT_TRUE(monitor2.visible());
+
+    vm2.reset();
+    vm2.setBytecode(bytecode4);
+    vm2.run();
+
+    ASSERT_EQ(vm2.registerCount(), 0);
+    ASSERT_TRUE(monitor1.visible());
+    ASSERT_FALSE(monitor2.visible());
+}