Node.h

Go to the documentation of this file.

#pragma once
 
 
#include "io/Output.h"
#include "objects/containers/CallbackSet.h"
#include "objects/containers/UnorderedMap.h"
#include "objects/wrappers/Any.h"
#include "quantities/Storage.h"
#include "run/IRun.h"
#include "run/Job.h"
#include "run/VirtualSettings.h"
#include "system/Statistics.h"
#include <set>
 
NAMESPACE_SPH_BEGIN
 
class ConfigNode;
class JobNode;
 
class IJobCallbacks : public IRunCallbacks {
public:
    virtual void onStart(const IJob& job) = 0;
 
    virtual void onEnd(const Storage& storage, const Statistics& stats) = 0;
};
 
class NullJobCallbacks : public IJobCallbacks {
public:
    virtual void onStart(const IJob& UNUSED(job)) override {}
 
    virtual void onEnd(const Storage& UNUSED(storage), const Statistics& UNUSED(stats)) override {}
 
    virtual void onSetUp(const Storage& UNUSED(storage), Statistics& UNUSED(stats)) override {}
 
    virtual void onTimeStep(const Storage& UNUSED(storage), Statistics& UNUSED(stats)) override {}
 
    virtual bool shouldAbortRun() const override {
        return false;
    }
};
 
class INode : public Polymorphic {
public:
    virtual void run(const RunSettings& global, IJobCallbacks& callbacks) = 0;
};
 
struct SlotData {
    std::string name;
 
    ExtJobType type;
 
    bool used;
 
    SharedPtr<JobNode> provider;
};
 
enum JobNotificationType {
    ENTRY_CHANGED,
    PROVIDER_CONNECTED,
    PROVIDER_DISCONNECTED,
    DEPENDENT_CONNECTED,
    DEPENDENT_DISCONNECTED,
};
 
class JobNode : public ShareFromThis<JobNode>, public INode {
public:
    using Accessor = Function<void(JobNotificationType, const Any& value)>;
 
private:
    UnorderedMap<std::string, SharedPtr<JobNode>> providers;
 
    Array<WeakPtr<JobNode>> dependents;
 
    AutoPtr<IJob> job;
 
    CallbackSet<Accessor> accessors;
 
public:
    explicit JobNode(AutoPtr<IJob>&& job);
 
    std::string instanceName() const;
 
    std::string className() const;
 
    VirtualSettings getSettings() const;
 
    RawPtr<IJob> getJob() const;
 
    void addAccessor(const SharedToken& owner, const Accessor& accessor);
 
    Optional<ExtJobType> provides() const;
 
    void connect(SharedPtr<JobNode> dependent, const std::string& slotName);
 
    void disconnect(SharedPtr<JobNode> dependent);
 
    void disconnectAll();
 
    Size getSlotCnt() const;
 
    SlotData getSlot(const Size index) const;
 
    Size getDependentCnt() const;
 
    SharedPtr<JobNode> getDependent(const Size index) const;
 
    void enumerate(Function<void(const SharedPtr<JobNode>& job)> func);
 
    void enumerate(Function<void(const SharedPtr<JobNode>& job, Size depth)> func);
 
    virtual void run(const RunSettings& global, IJobCallbacks& callbacks) override;
 
    virtual void prepare(const RunSettings& global, IJobCallbacks& callbacks);
 
private:
    void enumerate(Function<void(const SharedPtr<JobNode>& job, Size depth)> func,
        Size depth,
        std::set<JobNode*>& visited);
 
    void run(const RunSettings& global, IJobCallbacks& callbacks, std::set<JobNode*>& visited);
 
    void prepare(const RunSettings& global, IJobCallbacks& callbacks, std::set<JobNode*>& visited);
};
 
template <typename TJob, typename... TArgs>
SharedPtr<JobNode> makeNode(TArgs&&... args) {
    return makeShared<JobNode>(makeAuto<TJob>(std::forward<TArgs>(args)...));
}
 
AutoPtr<JobNode> cloneNode(const JobNode& node, const std::string& name = "");
 
SharedPtr<JobNode> cloneHierarchy(JobNode& node, const Optional<std::string>& prefix = NOTHING);
 
NAMESPACE_SPH_END