Project.h

Go to the documentation of this file.

#ifndef CHRYSALIS_PROJECT_H
#define CHRYSALIS_PROJECT_H
 
#include <queue>
#include <condition_variable>
 
#include "Option.h"
#include "Pattern.h"
#include "Parameter.h"
#include "Expression.h"
#include "ProjectSpace.h"
#include "instructions/BaseInstructionsContainer.h"
 
namespace Chrysalis {
    class Project {
        PROVIDE_SERIALIZATION_ACCESS(Project)
    public:
        static constexpr auto PROJECT_FILE_SUFFIX = "chrysalis";
        static constexpr auto PROJECT_NAME_FILTER = "Chrysalis Project (*.chrysalis)";
 
        explicit Project(std::string name, std::unique_ptr<ProjectSpace> space,
                         std::unique_ptr<PatternsContainer> patterns, std::unique_ptr<ParametersContainer> parameters,
                         std::unique_ptr<OptionsContainer> options, std::unique_ptr<ExpressionsContainer> expressions,
                         std::unique_ptr<InstructionsContainer> instructions);
        ~Project();
 
        static std::unique_ptr<Project> create();
        static std::unique_ptr<Project> create(const std::string& name);
 
        std::vector<char> bytes() const;
        static std::unique_ptr<Project> fromBytes(const char* bytes, size_t size);
 
        static std::unique_ptr<Project> read(const std::string& filePath);
        static void write(const std::string& filePath, const Project& project);
 
        std::string getName();
        void setName(const std::string& name);
 
        void execute();
        void onExecuted(const std::function<void()>& function);
 
        [[nodiscard]] ProjectSpace* getSpace() const;
        [[nodiscard]] OptionsContainer* getOptions() const;
        [[nodiscard]] PatternsContainer* getPatterns() const;
        [[nodiscard]] ParametersContainer* getParameters() const;
        [[nodiscard]] ExpressionsContainer* getExpressions() const;
        [[nodiscard]] InstructionsContainer* getInstructions() const;
    private:
        std::mutex mutex_;
        std::condition_variable startExecution_;
        std::atomic<bool> pendingExecution_ = false;
 
        std::queue<std::function<void()>> queue_;
        std::jthread thread_;
 
        std::string name_;
        std::unique_ptr<ProjectSpace> space_;
        std::unique_ptr<OptionsContainer> options_;
        std::unique_ptr<PatternsContainer> patterns_;
        std::unique_ptr<ParametersContainer> parameters_;
        std::unique_ptr<ExpressionsContainer> expressions_;
        std::unique_ptr<InstructionsContainer> instructions_;
    };
    SERIALIZE_CONSTRUCTION(Project, name_, space_, patterns_, parameters_, options_, expressions_, instructions_)
}
 
#endif //CHRYSALIS_PROJECT_H