Implement data_hidelist block

Author: adazem009

src/blocks/listblocks.cpp

@@ -36,6 +36,7 @@ void ListBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "data_lengthoflist", &compileLengthOfList);
     engine->addCompileFunction(this, "data_listcontainsitem", &compileListContainsItem);
     engine->addCompileFunction(this, "data_showlist", &compileShowList);
+    engine->addCompileFunction(this, "data_hidelist", &compileHideList);
 
     // Monitor names
     engine->addMonitorNameFunction(this, "data_listcontents", &listContentsMonitorName);
@@ -125,6 +126,21 @@ void ListBlocks::compileShowList(Compiler *compiler)
         compiler->addFunctionCall(&showList);
 }
 
+void ListBlocks::compileHideList(Compiler *compiler)
+{
+    Field *field = compiler->field(LIST);
+    assert(field);
+    List *var = static_cast<List *>(field->valuePtr().get());
+    assert(var);
+
+    compiler->addConstValue(var->id());
+
+    if (var->target() == static_cast<Target *>(compiler->engine()->stage()))
+        compiler->addFunctionCall(&hideGlobalList);
+    else
+        compiler->addFunctionCall(&hideList);
+}
+
 void ListBlocks::setListVisible(std::shared_ptr<List> list, bool visible)
 {
     if (list) {
@@ -153,6 +169,26 @@ unsigned int ListBlocks::showList(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int ListBlocks::hideGlobalList(VirtualMachine *vm)
+{
+    if (Stage *target = vm->engine()->stage()) {
+        int index = target->findListById(vm->getInput(0, 1)->toString());
+        setListVisible(target->listAt(index), false);
+    }
+
+    return 1;
+}
+
+unsigned int ListBlocks::hideList(VirtualMachine *vm)
+{
+    if (Target *target = vm->target()) {
+        int index = target->findListById(vm->getInput(0, 1)->toString());
+        setListVisible(target->listAt(index), false);
+    }
+
+    return 1;
+}
+
 const std::string &ListBlocks::listContentsMonitorName(Block *block)
 {
     List *list = dynamic_cast<List *>(block->findFieldById(LIST)->valuePtr().get());

src/blocks/listblocks.h

@@ -41,11 +41,14 @@ class ListBlocks : public IBlockSection
         static void compileLengthOfList(Compiler *compiler);
         static void compileListContainsItem(Compiler *compiler);
         static void compileShowList(Compiler *compiler);
+        static void compileHideList(Compiler *compiler);
 
         static void setListVisible(std::shared_ptr<List> list, bool visible);
 
         static unsigned int showGlobalList(VirtualMachine *vm);
         static unsigned int showList(VirtualMachine *vm);
+        static unsigned int hideGlobalList(VirtualMachine *vm);
+        static unsigned int hideList(VirtualMachine *vm);
 
         static const std::string &listContentsMonitorName(Block *block);
 

test/blocks/list_blocks_test.cpp

@@ -109,6 +109,7 @@ TEST_F(ListBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_lengthoflist", &ListBlocks::compileLengthOfList)).Times(1);
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_listcontainsitem", &ListBlocks::compileListContainsItem)).Times(1);
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_showlist", &ListBlocks::compileShowList)).Times(1);
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "data_hidelist", &ListBlocks::compileHideList)).Times(1);
 
     // Monitor names
     EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "data_listcontents", &ListBlocks::listContentsMonitorName));
@@ -543,3 +544,106 @@ TEST_F(ListBlocksTest, ShowListImpl)
     ASSERT_FALSE(monitor1.visible());
     ASSERT_TRUE(monitor2.visible());
 }
+
+TEST_F(ListBlocksTest, HideList)
+{
+    Compiler compiler(&m_engineMock);
+    Stage stage;
+    Target target;
+
+    // hide list [list1]
+    auto list1 = std::make_shared<List>("b", "list1");
+    list1->setTarget(&stage);
+    auto block1 = createListBlock("a", "data_hidelist", list1);
+
+    // hide list [list2]
+    auto list2 = std::make_shared<List>("d", "list2");
+    list2->setTarget(&target);
+    auto block2 = createListBlock("c", "data_hidelist", list2);
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&ListBlocks::hideGlobalList)).WillOnce(Return(0));
+    compiler.init();
+    compiler.setBlock(block1);
+    ListBlocks::compileHideList(&compiler);
+
+    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&ListBlocks::hideList)).WillOnce(Return(1));
+    compiler.setBlock(block2);
+    ListBlocks::compileHideList(&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(ListBlocksTest, HideListImpl)
+{
+    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[] = { &ListBlocks::hideGlobalList, &ListBlocks::hideList };
+    static Value constValues[] = { "a", "b", "c", "d" };
+
+    auto list1 = std::make_shared<List>("b", "");
+    Monitor monitor1("b", "");
+    monitor1.setVisible(true);
+    list1->setMonitor(&monitor1);
+
+    auto list2 = std::make_shared<List>("d", "");
+    Monitor monitor2("d", "");
+    monitor2.setVisible(true);
+    list2->setMonitor(&monitor2);
+
+    Stage stage;
+    stage.addList(list1);
+
+    Target target;
+    target.addList(list2);
+
+    // 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());
+}