Merge pull request #2 from scratchcpp/refactor

Refactor the code

Author: adazem009

CMakeLists.txt

@@ -14,7 +14,39 @@ find_package(utf8cpp REQUIRED)
 
 add_library(scratchcpp SHARED)
 add_subdirectory(src)
-include_directories(src)
+include_directories(src) # TODO: Remove this line
+include_directories(include)
+
+target_sources(scratchcpp
+  PUBLIC
+    include/scratchcpp/global.h
+    include/scratchcpp/project.h
+    include/scratchcpp/scratchconfiguration.h
+    include/scratchcpp/iengine.h
+    include/scratchcpp/iextension.h
+    include/scratchcpp/iblocksection.h
+    include/scratchcpp/asset.h
+    include/scratchcpp/costume.h
+    include/scratchcpp/sound.h
+    include/scratchcpp/value.h
+    include/scratchcpp/entity.h
+    include/scratchcpp/variable.h
+    include/scratchcpp/list.h
+    include/scratchcpp/inputvalue.h
+    include/scratchcpp/input.h
+    include/scratchcpp/field.h
+    include/scratchcpp/script.h
+    include/scratchcpp/broadcast.h
+    include/scratchcpp/compiler.h
+    include/scratchcpp/virtualmachine.h
+    include/scratchcpp/blockprototype.h
+    include/scratchcpp/block.h
+    include/scratchcpp/istagehandler.h
+    include/scratchcpp/ispritehandler.h
+    include/scratchcpp/target.h
+    include/scratchcpp/stage.h
+    include/scratchcpp/sprite.h
+)
 
 add_library(zip SHARED
 	${ZIP_SRC}/zip.c
@@ -23,6 +55,8 @@ add_library(zip SHARED
 )
 include_directories(thirdparty/zip/src)
 
+include_directories(thirdparty/spimpl)
+
 target_link_libraries(scratchcpp PRIVATE nlohmann_json::nlohmann_json)
 target_link_libraries(scratchcpp PRIVATE utf8cpp)
 target_link_libraries(scratchcpp PRIVATE zip)

Doxyfile

@@ -128,6 +128,7 @@ REPEAT_BRIEF           = YES
 # specifies, contains, represents, a, an and the.
 
 ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name interface" \
                          "The $name widget" \
                          "The $name file" \
                          is \
@@ -180,7 +181,7 @@ STRIP_FROM_PATH        =
 # specify the list of include paths that are normally passed to the compiler
 # using the -I flag.
 
-STRIP_FROM_INC_PATH    = src
+STRIP_FROM_INC_PATH    = include
 
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
 # less readable) file names. This can be useful is your file systems doesn't
@@ -865,7 +866,7 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = src \
+INPUT                  = include \
                          docs
 
 # This tag can be used to specify the character encoding of the source files
@@ -954,7 +955,8 @@ RECURSIVE              = YES
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                = docs/theme
+EXCLUDE                = docs/theme \
+                         include/scratchcpp/spimpl.h
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded

README.md

@@ -95,10 +95,10 @@ We're working on the documentation, it'll be available soon.
 
 A minimal CLI program for running Scratch projects:
 ```cpp
-#include <scratchproject.h>
+#include <scratchcpp/project.h>
 
 int main(int argc, char **argv) {
-  libscratchcpp::ScratchProject p("/path/to/project.sb3");
+  libscratchcpp::Project p("/path/to/project.sb3");
   bool ret = p.load();
   if (!ret)
     return 1;

docs/Block sections.md

@@ -74,17 +74,17 @@ void MySection::compileHelloWorld(Compiler *compiler) {
 }
 ```
 
-The value of the input can be read during runtime using the \link libscratchcpp::VirtualMachine::getArg() getArg() \endlink function:
+The value of the input can be read during runtime using the \link libscratchcpp::VirtualMachine::getInput() getInput() \endlink function:
 ```cpp
 unsigned int MySection::helloWorld(VirtualMachine *vm) {
-    std::cout << "Hello, " << vm->getArg(0, 1)->toString() << "!" << std::endl;
+    std::cout << "Hello, " << vm->getInput(0, 1)->toString() << "!" << std::endl;
     return 1;
 }
 ```
 \note The order of the inputs is the same as in the compile function. Do not use the `Inputs` enumeration in runtime functions.
 
 ```cpp
-vm->getArg(0, 1)
+vm->getInput(0, 1)
 ```
 The first argument is the index of the input and the second argument is the amount of inputs.
 \note Make sure to return the amount of inputs in the `helloWorld` function.

docs/Extensions.md

@@ -20,7 +20,7 @@ using namespace libscratchcpp;
 ### Registering block sections
 Block sections can be registered by overriding the \link libscratchcpp::IExtension::registerSections() registerSections() \endlink function:
 ```cpp
-void MyExtension::registerSections(Engine *engine) {
+void MyExtension::registerSections(IEngine *engine) {
     engine->registerSection(std::make_shared<MySection>());
 }
 ```

docs/Getting started.md

@@ -1,18 +1,18 @@
 \page gettingStarted Getting started
 
 libscratchcpp doesn't have any GUI support, but sprites and the stage can be easily implemented using
-the \link libscratchcpp::IScratchStage IScratchStage \endlink and
-\link libscratchcpp::IScratchTarget IScratchTarget \endlink interfaces.
+the \link libscratchcpp::IStageHandler IStageHandler \endlink and
+\link libscratchcpp::ISpriteHandler ISpriteHandler \endlink interfaces.
 
 They can be subclassed for listening to events such as when the X and Y coordinates
 of a sprite change.
 
 ## CLI-only example
 ```cpp
-#include <scratchproject.h>
+#include <scratchcpp/project.h>
 
 int main(int argc, char **argv) {
-  libscratchcpp::ScratchProject p("/path/to/project.sb3");
+  libscratchcpp::Project p("/path/to/project.sb3");
   bool ret = p.load();
   if (!ret)
     return 1;
@@ -21,9 +21,9 @@ int main(int argc, char **argv) {
   return 0;
 }
 ```
-The \link libscratchcpp::ScratchProject::run() run() \endlink method runs an event loop which stops after all scripts finish.
+The \link libscratchcpp::Project::run() run() \endlink method runs an event loop which stops after all scripts finish.
 
-For CLI project players, using \link libscratchcpp::ScratchProject::run() run() \endlink is enough. If you are developing
+For CLI project players, using \link libscratchcpp::Project::run() run() \endlink is enough. If you are developing
 a GUI project player and need to receive input events such as key presses, you'll need to implement your own event loop
 or use the one provided by the GUI framework.
 
@@ -33,18 +33,19 @@ Qt provides an event loop which can be easily used to run frames with a specific
 For example, a `Player` class which **inherits from QObject** can use a timer:
 ```cpp
 #include <QObject>
-#include <scratchproject.h>
+#include <scratchcpp/project.h>
 
 class Player : public QObject {
     Q_OBJECT
     public:
         Player(QObject *parent = nullptr);
+        Player(const Player &) = delete; // Project is not copyable
 
     protected:
         void timerEvent(QTimerEvent *event) override;
 
     private:
-        libscratchcpp::ScratchProject m_proj;
+        libscratchcpp::Project m_proj;
 }
 
 Player::Player(QObject *parent) {

docs/Virtual machine.md

@@ -53,16 +53,16 @@ OP_LOOP_END
 ### Repeat until
 Scratch has a while loop, but until is used more frequently, so the VM doesn't support the while loop.
 
-The repeat until loop can be implemented using \link libscratchcpp::vm::OP_REPEAT_UNTIL OP_REPEAT_UNTIL \endlink
+The repeat until loop can be implemented using \link libscratchcpp::vm::OP_UNTIL_LOOP OP_UNTIL_LOOP \endlink
 and \link libscratchcpp::vm::OP_BEGIN_UNTIL_LOOP OP_BEGIN_UNTIL_LOOP \endlink.
 ```
-OP_REPEAT_UNTIL
+OP_UNTIL_LOOP
 (evaluate the condition here)
 OP_BEGIN_UNTIL_LOOP
 ...
 OP_LOOP_END
 ```
-\note The condition is evaluated after \link libscratchcpp::vm::OP_REPEAT_UNTIL OP_REPEAT_UNTIL \endlink and the loop
+\note The condition is evaluated after \link libscratchcpp::vm::OP_UNTIL_LOOP OP_UNTIL_LOOP \endlink and the loop
 starts with \link libscratchcpp::vm::OP_BEGIN_UNTIL_LOOP OP_BEGIN_UNTIL_LOOP \endlink.
 
 ### Forever
@@ -75,7 +75,7 @@ OP_LOOP_END
 
 This is equivalent to:
 ```
-OP_REPEAT_UNTIL
+OP_UNTIL_LOOP
 OP_NULL
 OP_BEGIN_UNTIL_LOOP
 ...

src/scratch/asset.h include/scratchcpp/asset.hsrc/scratch/asset.h renamed to include/scratchcpp/asset.h

@@ -2,30 +2,32 @@
 
 #pragma once
 
-#include "../libscratchcpp_global.h"
 #include <string>
+#include "spimpl.h"
+
+#include "global.h"
 
 namespace libscratchcpp
 {
 
+class AssetPrivate;
+
 /*! \brief The Asset class represents a Scratch asset, for example a Costume or a Sound. */
 class LIBSCRATCHCPP_EXPORT Asset
 {
     public:
         Asset(std::string name, std::string id, std::string format);
 
-        std::string assetId() const;
+        const std::string &assetId() const;
 
-        std::string name() const;
+        const std::string &name() const;
 
-        std::string md5ext() const;
+        const std::string &md5ext() const;
 
-        std::string dataFormat() const;
+        const std::string &dataFormat() const;
 
     private:
-        std::string m_assetId;
-        std::string m_name;
-        std::string m_dataFormat;
+        spimpl::impl_ptr<AssetPrivate> impl;
 };
 
 } // namespace libscratchcpp

src/scratch/block.h include/scratchcpp/block.hsrc/scratch/block.h renamed to include/scratchcpp/block.h

@@ -2,26 +2,23 @@
 
 #pragma once
 
-#include "../engine/global.h"
-#include "field.h"
-#include "ientity.h"
-#include "input.h"
+#include "entity.h"
 #include "blockprototype.h"
-#include <memory>
-#include <unordered_map>
-#include <string>
 
 namespace libscratchcpp
 {
 
-class LIBSCRATCHCPP_EXPORT Engine;
-class LIBSCRATCHCPP_EXPORT Target;
+class IEngine;
+class Target;
+class Input;
+class Field;
+class BlockPrivate;
 
 /*! \brief The Block class represents a Scratch block. */
-class LIBSCRATCHCPP_EXPORT Block : public IEntity
+class LIBSCRATCHCPP_EXPORT Block : public Entity
 {
     public:
-        Block(std::string id, std::string opcode);
+        Block(const std::string &id, const std::string &opcode);
         Block(const Block &) = delete;
 
         void compile(Compiler *compiler);
@@ -58,7 +55,7 @@ class LIBSCRATCHCPP_EXPORT Block : public IEntity
         bool topLevel() const;
         void setTopLevel(bool newTopLevel);
 
-        void setEngine(Engine *newEngine);
+        void setEngine(IEngine *newEngine);
 
         void setTarget(Target *newTarget);
 
@@ -71,22 +68,7 @@ class LIBSCRATCHCPP_EXPORT Block : public IEntity
         BlockPrototype *mutationPrototype();
 
     private:
-        std::string m_opcode;
-        BlockComp m_compileFunction = nullptr;
-        std::shared_ptr<Block> m_next = nullptr;
-        std::string m_nextId;
-        std::shared_ptr<Block> m_parent = nullptr;
-        std::string m_parentId;
-        std::vector<std::shared_ptr<Input>> m_inputs;
-        std::unordered_map<int, Input *> m_inputMap;
-        std::vector<std::shared_ptr<Field>> m_fields;
-        std::unordered_map<int, Field *> m_fieldMap;
-        bool m_shadow = false;
-        bool m_topLevel = false;
-        Engine *m_engine = nullptr;
-        Target *m_target = nullptr;
-        BlockPrototype m_mutationPrototype;
-        bool m_mutationHasNext = true;
+        spimpl::unique_impl_ptr<BlockPrivate> impl;
 };
 
 } // namespace libscratchcpp

src/scratch/blockprototype.h include/scratchcpp/blockprototype.hsrc/scratch/blockprototype.h renamed to include/scratchcpp/blockprototype.h

@@ -2,12 +2,16 @@
 
 #pragma once
 
-#include "value.h"
 #include <vector>
 
+#include "spimpl.h"
+#include "value.h"
+
 namespace libscratchcpp
 {
 
+class BlockPrototypePrivate;
+
 /*! \brief The BlockPrototype class represents the prototype of a custom block. */
 class LIBSCRATCHCPP_EXPORT BlockPrototype
 {
@@ -38,12 +42,7 @@ class LIBSCRATCHCPP_EXPORT BlockPrototype
         void setWarp(bool newWarp);
 
     private:
-        std::string m_procCode;
-        std::vector<std::string> m_argumentIds;
-        std::vector<std::string> m_argumentNames;
-        std::vector<Value> m_argumentDefaults;
-        std::vector<ArgType> m_argumentTypes;
-        bool m_warp = false;
+        spimpl::impl_ptr<BlockPrototypePrivate> impl;
 };
 
 } // namespace libscratchcpp