ProceduralSystem.hpp

#pragma once
 
#include <Infinity/api.h>
#include <Infinity/Types/All.hpp>
 
#include <filesystem>
#include <vector>
#include <memory>
#include <string>
 
namespace Infinity::Procedural {
 
class ProceduralSystemImpl;
 
class INFINITY_API_PUBLIC ProceduralSystem
{
    public:
        explicit ProceduralSystem(const std::filesystem::path& file);
 
        ProceduralSystem(const std::vector<unsigned char>& buffer, const std::filesystem::path& loadPath = {});
 
        ProceduralSystem(ProceduralSystem&& other);
 
        ~ProceduralSystem();
 
        ProceduralSystem& operator=(ProceduralSystem&& other);
 
        std::string id() const;
 
        void execute();
 
        void setSeed(uint64_t seed);
 
        bool setLoop(int start, int stop, int step);
 
        bool setLoop(std::string portName);
 
        void clearLoop();
 
        template<typename T>
        const T& getIn(const std::string& name) const
        {
            if constexpr (std::is_base_of_v<Infinity::Types::Core::Data, T>)
            {
                return *dynamic_cast<const T*>(getInData(name));
            } else {
                return dynamic_cast<const Infinity::Types::Core::Value<T>*>(getInData(name))->get();
            }
        }
 
        template<typename T>
        const T& getOut(const std::string& name) const
        {
            if constexpr (std::is_base_of_v<Infinity::Types::Core::Data, T>)
            {
                return *dynamic_cast<const T*>(getOutData(name));
            } else {
                return dynamic_cast<const Infinity::Types::Core::Value<T>*>(getOutData(name))->get();
            }
        }
 
        template<typename T>
        void setIn(const std::string& name, T&& val)
        {
            if constexpr (std::is_base_of_v<Infinity::Types::Core::Data, T>)
            {
                setInData(name, std::make_shared<T>(std::move(val)));
            } else {
                setInData(name, std::make_shared<Infinity::Types::Core::Value<T>>(val));
            }
        }
 
        template<typename T>
        void setIn(const std::string& name, const T& val)
        {
            if constexpr (std::is_base_of_v<Infinity::Types::Core::Data, T>)
            {
                setInData(name, std::make_shared<T>(val));
            } else {
                setInData(name, std::make_shared<Infinity::Types::Core::Value<T>>(val));
            }
        }
 
        template<typename T>
        void setIn(const std::string& name, const T* val)
        {
            setInData(name, std::make_shared<T>(*val));
        }
    
    private:
        ProceduralSystem() = delete;
        ProceduralSystem(std::unique_ptr<ProceduralSystemImpl>&& impl);
 
        const Infinity::Types::Core::Base* getInData(const std::string& name) const;
 
        const Infinity::Types::Core::Base* getOutData(const std::string& name) const;
 
        void setInData(const std::string& name, std::shared_ptr<const Infinity::Types::Core::Base> data);
 
        std::unique_ptr<ProceduralSystemImpl> _impl;
 
        friend class ProceduralSystemImpl;
};
 
}