Add classes for different input types

Author: adazem009

src/internal/scratch3reader.cpp

@@ -3,6 +3,10 @@
 #include "scratch3reader.h"
 #include "../scratch/sprite.h"
 #include "../scratch/stage.h"
+#include "../scratch/internal/shadowinput.h"
+#include "../scratch/internal/variableinput.h"
+#include "../scratch/internal/listinput.h"
+#include "../scratch/internal/blockinput.h"
 #include "reader_common.h"
 
 using namespace libscratchcpp;
@@ -79,8 +83,29 @@ bool Scratch3Reader::load()
             auto inputs = blockInfo["inputs"];
             for (json::iterator it = inputs.begin(); it != inputs.end(); ++it) {
                 auto inputInfo = it.value();
-                auto input = std::make_shared<Input>(it.key(), static_cast<Input::Type>(inputInfo[0]));
+                auto type = static_cast<Input::Type>(inputInfo[0]);
                 auto primary = inputInfo[1];
+                std::shared_ptr<Input> input;
+                if (type == Input::Type::Shadow)
+                    input = std::make_shared<ShadowInput>(it.key(), type);
+                else {
+                    if (primary.is_array()) {
+                        auto valueType = static_cast<InputValue::Type>(primary[0]);
+                        switch (valueType) {
+                            case InputValue::Type::Variable:
+                                input = std::make_shared<VariableInput>(it.key(), type);
+                                break;
+                            case InputValue::Type::List:
+                                input = std::make_shared<ListInput>(it.key(), type);
+                                break;
+                            default:
+                                assert(false); // a block can only be obscured by a variable or a list in this case
+                                break;
+                        }
+                    } else
+                        input = std::make_shared<BlockInput>(it.key(), type);
+                }
+
                 if (primary.is_array()) {
                     input->setPrimaryValue(jsonToValue(primary[1]));
                     input->primaryValue()->setType(static_cast<InputValue::Type>(primary[0]));

src/scratch/CMakeLists.txt

@@ -33,3 +33,5 @@ target_sources(scratchcpp
     broadcast.h
     runningscript.h
 )
+
+add_subdirectory(internal)

src/scratch/input.cpp

@@ -51,51 +51,6 @@ InputValue *Input::secondaryValue()
     return &m_secondaryValue;
 }
 
-/*!
- * Returns the value of the input.\n
- * If there's an obscured shadow, the value will
- * be retrieved from the block that obscures the shadow.\n
- * Use secondaryValue() to get the value of the shadow.
- */
-Value Input::value() const
-{
-    switch (m_type) {
-        case Type::Shadow:
-            return m_primaryValue.value();
-        case Type::NoShadow:
-        case Type::ObscuredShadow: {
-            switch (m_primaryValue.type()) {
-                case InputValue::Type::Variable: {
-                    auto variable = std::static_pointer_cast<Variable>(m_primaryValue.valuePtr());
-                    if (!variable) {
-                        std::cout << "warning: attempted to read a null variable" << std::endl;
-                        return Value();
-                    }
-                    return variable->value();
-                }
-                case InputValue::Type::List: {
-                    auto list = std::static_pointer_cast<List>(m_primaryValue.valuePtr());
-                    if (!list) {
-                        std::cout << "warning: attempted to read a null list" << std::endl;
-                        return Value();
-                    }
-                    return list->toString();
-                }
-                default: {
-                    auto block = m_primaryValue.valueBlock();
-                    if (!block) {
-                        if (m_type == Type::ObscuredShadow)
-                            std::cout << "warning: attempted to get value of an input shadow obscured by a null block" << std::endl;
-                        return Value();
-                    }
-                    return block->run();
-                }
-            }
-        }
-    }
-    return Value();
-}
-
 /*! Sets the primary value. */
 void Input::setPrimaryValue(Value value)
 {

src/scratch/input.h

@@ -31,7 +31,13 @@ class LIBSCRATCHCPP_EXPORT Input
         InputValue *primaryValue();
         InputValue *secondaryValue();
 
-        Value value() const;
+        /*!
+         * Returns the value of the input.\n
+         * If there's an obscured shadow, the value will
+         * be retrieved from the block that obscures the shadow.\n
+         * Use secondaryValue() to get the value of the shadow.
+         */
+        virtual Value value() const = 0;
 
         void setPrimaryValue(Value value);
         void setSecondaryValue(Value value);
@@ -41,12 +47,14 @@ class LIBSCRATCHCPP_EXPORT Input
         void setValueBlock(std::shared_ptr<Block> block);
         void setValueBlockId(std::string id);
 
+    protected:
+        InputValue m_primaryValue;
+        InputValue m_secondaryValue;
+
     private:
         std::string m_name;
         int m_inputId = -1;
         Type m_type;
-        InputValue m_primaryValue;
-        InputValue m_secondaryValue;
 };
 
 } // namespace libscratchcpp

src/scratch/internal/CMakeLists.txt

@@ -0,0 +1,11 @@
+target_sources(scratchcpp
+  PRIVATE
+    shadowinput.cpp
+    shadowinput.h
+    blockinput.cpp
+    blockinput.h
+    variableinput.cpp
+    variableinput.h
+    listinput.cpp
+    listinput.h
+)

src/scratch/internal/blockinput.cpp

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "blockinput.h"
+#include "../block.h"
+
+namespace libscratchcpp
+{
+
+BlockInput::BlockInput(std::string name, Type type) :
+    Input(name, type)
+{
+}
+
+Value BlockInput::value() const
+{
+    return m_primaryValue.valueBlock()->run();
+}
+
+} // namespace libscratchcpp

src/scratch/internal/blockinput.h

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "../input.h"
+
+namespace libscratchcpp
+{
+
+class BlockInput : public Input
+{
+    public:
+        BlockInput(std::string name, Type type);
+
+        Value value() const override;
+};
+
+} // namespace libscratchcpp

src/scratch/internal/listinput.cpp

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "listinput.h"
+#include "../list.h"
+
+namespace libscratchcpp
+{
+
+ListInput::ListInput(std::string name, Type type) :
+    Input(name, type)
+{
+}
+
+Value ListInput::value() const
+{
+    return reinterpret_cast<List *>(m_primaryValue.valuePtr().get())->toString();
+}
+
+} // namespace libscratchcpp

src/scratch/internal/listinput.h

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "../input.h"
+
+namespace libscratchcpp
+{
+
+class ListInput : public Input
+{
+    public:
+        ListInput(std::string name, Type type);
+
+        Value value() const override;
+};
+
+} // namespace libscratchcpp

src/scratch/internal/shadowinput.cpp

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "shadowinput.h"
+
+namespace libscratchcpp
+{
+
+ShadowInput::ShadowInput(std::string name, Type type) :
+    Input(name, type)
+{
+}
+
+Value ShadowInput::value() const
+{
+    return m_primaryValue.value();
+}
+
+} // namespace libscratchcpp