Job.h

Go to the documentation of this file.

#pragma once
 
#include "objects/containers/UnorderedMap.h"
#include "objects/geometry/Domain.h"
#include "objects/wrappers/ExtendedEnum.h"
#include "objects/wrappers/SharedPtr.h"
#include "quantities/Storage.h"
#include "run/VirtualSettings.h"
#include "system/Settings.h"
#include "system/Statistics.h"
 
NAMESPACE_SPH_BEGIN
 
class IMaterial;
class IRunCallbacks;
class IRun;
 
class IJobData : public Polymorphic {};
 
enum class JobType {
    PARTICLES,
 
    MATERIAL,
 
    GEOMETRY,
};
 
using ExtJobType = ExtendedEnum<JobType>;
 
struct ParticleData {
    Storage storage;
 
    Statistics stats;
 
    RunSettings overrides = EMPTY_SETTINGS;
};
 
class JobContext : public Polymorphic {
private:
    SharedPtr<IJobData> data;
 
public:
    JobContext() = default;
 
    template <typename TValue>
    JobContext(SharedPtr<TValue> value);
 
    template <typename TValue>
    SharedPtr<TValue> getValue() const;
 
    template <typename TValue>
    SharedPtr<TValue> tryGetValue() const;
 
    JobContext clone() const;
 
    void release();
};
 
class IJob : public Polymorphic {
    friend class JobNode;
 
protected:
    std::string instName;
 
    UnorderedMap<std::string, JobContext> inputs;
 
public:
    explicit IJob(const std::string& name)
        : instName(name) {}
 
    virtual std::string instanceName() const {
        return instName;
    }
 
    virtual std::string className() const = 0;
 
    virtual UnorderedMap<std::string, ExtJobType>
    requires() const {
        return this->getSlots();
    }
 
    virtual UnorderedMap<std::string, ExtJobType> getSlots() const = 0;
 
    virtual Optional<ExtJobType> provides() const = 0;
 
    virtual VirtualSettings getSettings() = 0;
 
    virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) = 0;
 
    virtual JobContext getResult() const = 0;
 
protected:
    template <typename T>
    SharedPtr<T> getInput(const std::string& name) const;
};
 
class IJobDesc : public Polymorphic {
public:
    virtual std::string className() const = 0;
 
    virtual std::string category() const = 0;
 
    virtual std::string tooltip() const {
        return "";
    }
 
    virtual AutoPtr<IJob> create(Optional<std::string> instanceName) const = 0;
};
 
using CreateJobFunc = Function<AutoPtr<IJob>(std::string name)>;
 
struct JobRegistrar {
    JobRegistrar(std::string className, std::string category, CreateJobFunc func, std::string tooltip);
 
    JobRegistrar(std::string className,
        std::string shortName,
        std::string category,
        CreateJobFunc func,
        std::string tooltip);
};
 
ArrayView<const AutoPtr<IJobDesc>> enumerateRegisteredJobs();
 
RawPtr<IJobDesc> getJobDesc(const std::string& name);
 
VirtualSettings::Category& addGenericCategory(VirtualSettings& connector, std::string& instanceName);
 
 
class IParticleJob : public IJob {
protected:
    SharedPtr<ParticleData> result;
 
public:
    explicit IParticleJob(const std::string& name);
 
    ~IParticleJob() override;
 
    virtual Optional<ExtJobType> provides() const override final {
        return JobType::PARTICLES;
    }
 
    virtual JobContext getResult() const override final {
        return result;
    }
};
 
class IRunJob : public IParticleJob {
public:
    explicit IRunJob(const std::string& name);
 
    ~IRunJob() override;
 
    virtual AutoPtr<IRun> getRun(const RunSettings& overrides) const = 0;
 
protected:
    virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override final;
};
 
class IGeometryJob : public IJob {
protected:
    SharedPtr<IDomain> result;
 
public:
    explicit IGeometryJob(const std::string& name)
        : IJob(name) {}
 
    virtual Optional<ExtJobType> provides() const override final {
        return JobType::GEOMETRY;
    }
 
    virtual JobContext getResult() const override final {
        return result;
    }
};
 
class IMaterialJob : public IJob {
protected:
    SharedPtr<IMaterial> result;
 
public:
    explicit IMaterialJob(const std::string& name)
        : IJob(name) {}
 
    virtual Optional<ExtJobType> provides() const override final {
        return JobType::MATERIAL;
    }
 
    virtual JobContext getResult() const override final {
        return result;
    }
};
 
class INullJob : public IJob {
public:
    explicit INullJob(const std::string& name)
        : IJob(name) {}
 
    virtual Optional<ExtJobType> provides() const override final {
        return NOTHING;
    }
 
    virtual JobContext getResult() const override final {
        return {};
    }
};
 
NAMESPACE_SPH_END
 
#include "Job.inl.h"