Initial commit

include/wfr/common/wep/AbstractWepNode.h

@@ -0,0 +1,79 @@
+
+#pragma once
+
+#include <wfr/common/types/WepTypes.h>
+#include <wfr/common/types/WfrTypes.h>
+#include <wfr/common/types/WfsTypes.h>
+#include <vector>
+#include <atomic>
+#include <memory>
+#include <stdint.h>
+
+
+namespace wfr {
+
+// Forward declarations
+namespace enactment {
+class WepBuilder;
+}
+
+namespace wep {
+
+
+class AbstractWepNode {
+friend class enactment::WepBuilder;
+
+// Static non-public properties
+protected:
+	/**
+	 * Static variable holding the next free wepID.
+	 **/
+	static std::atomic<wfr_id_t> nextWepNodeID;
+
+	/**
+	 * Returns the next free wepID.
+	 *
+	 * @return next free wepID.
+	 */
+	static wfr_id_t getNextWepNodeID() noexcept { return nextWepNodeID.fetch_add(1); }
+
+// Mutable properties that need to be accessed via getter-/setter-functions.
+protected:
+	std::vector<AbstractWepNode*> predecessors;
+	std::vector<AbstractWepNode*> successors;
+	std::shared_ptr<void> userData;
+	uint64_t visitationCount = 0;
+
+// Invariant properties that can be accessed directly.
+public:
+	const wfr_id_t nodeID;
+	const WepNodeType nodeType;
+	const bool withActivityInstance;
+
+// Public functions
+public:
+	AbstractWepNode(WepNodeType nodeType, bool withInstance) noexcept
+			: nodeID(getNextWepNodeID()), nodeType(nodeType), withActivityInstance(withInstance) {}
+	virtual ~AbstractWepNode() noexcept {}
+
+	const std::vector<AbstractWepNode*>& getPredecessors() const noexcept { return predecessors; }
+	std::vector<AbstractWepNode*>& getPredecessors() noexcept { return predecessors; }
+	const std::vector<AbstractWepNode*>& getSuccessors() const noexcept { return successors; }
+	std::vector<AbstractWepNode*>& getSuccessors() noexcept { return successors; }
+
+	std::shared_ptr<void> getUserData() const noexcept { return userData; }
+	void setUserData(std::shared_ptr<void> data) noexcept { userData = data; }
+
+	uint64_t getVisitationCount() const noexcept { return visitationCount; }
+	virtual void addToVisitationCount(uint64_t val = 1) noexcept { visitationCount += val; }
+
+	template<class T>
+	T& as() noexcept { return *static_cast<T*>(this); }
+
+	template<class T>
+	const T& as() const noexcept { return *static_cast<const T*>(this); }
+};
+
+} /* namespace wep */
+} /* namespace wfr */
+

include/wfr/common/wep/ActivityWepNode.h

@@ -0,0 +1,43 @@
+
+#pragma once
+
+#include <wfr/common/wep/AbstractWepNode.h>
+
+
+// Forward declarations
+namespace wfr {
+namespace enactment {
+class WepBuilder;
+}
+namespace wfs {
+class ActivityInstance;
+}
+
+// Main namespace
+namespace wep {
+
+
+class ActivityWepNode : public AbstractWepNode {
+friend class enactment::WepBuilder;
+
+// Mutable properties that need to be accessed via getter-/setter-functions.
+protected:
+	wfr::wfs::ActivityInstanceStatus lastKnownActivityStatus;
+
+// Invariant properties that can be accessed directly.
+public:
+	wfs::ActivityInstance& activity;
+
+public:
+	ActivityWepNode(WepNodeType nodeType, wfs::ActivityInstance& activity) noexcept;
+
+	virtual void addToVisitationCount(uint64_t val = 1) noexcept override;
+
+	virtual wfs::ActivityInstanceStatus getLastKnownInstanceStatus() const noexcept { return lastKnownActivityStatus; }
+
+	virtual void updateInstanceStatus();
+};
+
+} /* namespace wep */
+} /* namespace wfr */
+

include/wfr/common/wep/WorkflowExecutionPlan.h

@@ -0,0 +1,65 @@
+
+#pragma once
+
+
+#include <wfr/common/types/WfrTypes.h>
+#include <atomic>
+#include <stdint.h>
+
+// Forward declarations
+namespace wfr {
+namespace wfs {
+class Workflow;
+}
+
+// Main namespace
+namespace wep {
+
+
+class AbstractWepNode;
+
+class WorkflowExecutionPlan {
+
+// Static non-public properties
+private:
+	/**
+	 * Static variable holding the next free wepID.
+	 **/
+	static std::atomic<wfr_id_t> nextWepID;
+
+	/**
+	 * Returns the next free wepID.
+	 *
+	 * @return next free wepID.
+	 */
+	static wfr_id_t getNextWepID() { return nextWepID.fetch_add(1); }
+
+// Mutable properties that need to be accessed via getter-/setter-functions.
+private:
+	AbstractWepNode* startNode;
+	AbstractWepNode* endNode;
+
+	wfr_id_t version = 0;
+
+// Invariant properties that can be accessed directly.
+public:
+	const wfr_id_t wepID;
+	wfr::wfs::Workflow& workflow;
+
+// Public functions
+public:
+	WorkflowExecutionPlan(wfr::wfs::Workflow& wf, AbstractWepNode* startNode, AbstractWepNode* endNode) noexcept
+			: startNode(startNode), endNode(endNode), wepID(getNextWepID()), workflow(wf) {}
+	~WorkflowExecutionPlan() noexcept;
+
+	AbstractWepNode* getStartNode() const noexcept { return startNode; }
+	AbstractWepNode* getEndNode() const noexcept { return endNode; }
+
+	wfr_id_t getVersion() const noexcept { return version; }
+
+	void increaseVersion(wfr_id_t value = 1) noexcept { this->version += value; }
+};
+
+} /* namespace wep */
+} /* namespace wfr */
+

include/wfr/common/wep/activities/AssignWepNode.h

@@ -0,0 +1,29 @@
+
+#pragma once
+
+#include <wfr/common/wep/ActivityWepNode.h>
+
+
+namespace wfr {
+
+// Forward declarations
+namespace enactment {
+class WepBuilder;
+}
+
+namespace wep {
+
+
+class AssignWepNode: public ActivityWepNode {
+friend class enactment::WepBuilder;
+
+public:
+	AssignWepNode(wfs::ActivityInstance& instance)
+		: ActivityWepNode(WepNodeType::Assign, instance) {}
+};
+
+
+} /* namespace wep */
+} /* namespace wfr */
+
+

include/wfr/common/wep/activities/AtomicWepNode.h

@@ -0,0 +1,29 @@
+
+#pragma once
+
+#include <wfr/common/wep/ActivityWepNode.h>
+
+
+namespace wfr {
+
+// Forward declarations
+namespace enactment {
+class WepBuilder;
+}
+
+namespace wep {
+
+
+class AtomicWepNode: public ActivityWepNode {
+friend class enactment::WepBuilder;
+
+public:
+	AtomicWepNode(wfs::ActivityInstance& instance)
+		: ActivityWepNode(WepNodeType::Atomic, instance) {}
+};
+
+
+} /* namespace wep */
+} /* namespace wfr */
+
+

include/wfr/common/wep/activities/CompositeEndWepNode.h

@@ -0,0 +1,36 @@
+
+#pragma once
+
+#include <wfr/common/wep/ActivityWepNode.h>
+
+
+namespace wfr {
+
+// Forward declarations
+namespace enactment {
+class WepBuilder;
+}
+
+namespace wep {
+
+// Forward declarations
+class CompositeStartWepNode;
+
+
+class CompositeEndWepNode: public ActivityWepNode {
+friend class enactment::WepBuilder;
+
+private:
+	CompositeStartWepNode* startNode = nullptr;
+
+public:
+	CompositeEndWepNode(wfs::ActivityInstance& instance) noexcept
+		: ActivityWepNode(WepNodeType::CompositeEnd, instance) {}
+
+	CompositeStartWepNode* getStartNode() const noexcept { return startNode; }
+};
+
+
+} /* namespace wep */
+} /* namespace wfr */
+

include/wfr/common/wep/activities/CompositeStartWepNode.h

@@ -0,0 +1,36 @@
+
+#pragma once
+
+#include <wfr/common/wep/ActivityWepNode.h>
+
+
+namespace wfr {
+
+// Forward declarations
+namespace enactment {
+class WepBuilder;
+}
+
+namespace wep {
+
+// Forward declarations
+class CompositeEndWepNode;
+
+
+class CompositeStartWepNode: public ActivityWepNode {
+friend class enactment::WepBuilder;
+
+private:
+	CompositeEndWepNode* endNode = nullptr;
+
+public:
+	CompositeStartWepNode(wfs::ActivityInstance& instance)
+		: ActivityWepNode(WepNodeType::CompositeStart, instance) {}
+
+	CompositeEndWepNode* getEndNode() const noexcept { return endNode; }
+};
+
+
+} /* namespace wep */
+} /* namespace wfr */
+

include/wfr/common/wep/activities/IterationEndWepNode.h

@@ -0,0 +1,42 @@
+
+#pragma once
+
+#include <wfr/common/wep/ActivityWepNode.h>
+
+
+namespace wfr {
+
+// Forward declarations
+namespace enactment {
+class WepBuilder;
+}
+
+namespace wep {
+
+class IterationStartWepNode;
+
+
+class IterationEndWepNode: public ActivityWepNode {
+friend class enactment::WepBuilder;
+
+private:
+	IterationStartWepNode* startNode = nullptr;
+
+public:
+	const wfr_id_t iterationID;
+
+public:
+	IterationEndWepNode(wfs::ActivityInstance& instance, wfr_id_t iterationID)
+		: ActivityWepNode(WepNodeType::IterationEnd, instance), iterationID(iterationID) {}
+
+	virtual void updateInstanceStatus() override;
+
+	virtual wfs::ActivityInstanceStatus getLastKnownInstanceStatus() const noexcept override;
+
+	IterationStartWepNode* getStartNode() const noexcept { return startNode; }
+};
+
+
+} /* namespace wep */
+} /* namespace wfr */
+

include/wfr/common/wep/activities/IterationStartWepNode.h

@@ -0,0 +1,40 @@
+
+#pragma once
+
+#include <wfr/common/wep/ActivityWepNode.h>
+
+
+namespace wfr {
+
+// Forward declarations
+namespace enactment {
+class WepBuilder;
+}
+
+namespace wep {
+
+class IterationEndWepNode;
+
+
+class IterationStartWepNode: public ActivityWepNode {
+friend class enactment::WepBuilder;
+
+private:
+	IterationEndWepNode* endNode = nullptr;
+
+public:
+	const wfr_id_t iterationID;
+
+public:
+	IterationStartWepNode(wfs::ActivityInstance& instance, wfr_id_t iterationID)
+		: ActivityWepNode(WepNodeType::IterationStart, instance), iterationID(iterationID) {}
+
+	virtual void updateInstanceStatus() override;
+
+	IterationEndWepNode* getEndNode() const noexcept { return endNode; }
+};
+
+
+} /* namespace wep */
+} /* namespace wfr */
+