zuspec-arl-dm 0.1.0.15264414400rc0__cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

zsp_arl_dm/share/include/zsp/arl/dm/IModelActivityBind.h

@@ -0,0 +1,46 @@
+/**
+ * IModelActivityBind.h
+ *
+ * Copyright 2022 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+#include <vector>
+#include "zsp/arl/dm/IModelActivity.h"
+#include "vsc/dm/IModelExpr.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+
+class IModelActivityBind : public virtual IModelActivity {
+public:
+
+    virtual ~IModelActivityBind() { }
+
+    virtual const std::vector<vsc::dm::IModelExprUP> &getTargets() const = 0;
+
+};
+
+}
+}
+}
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelActivityParallel.h

@@ -0,0 +1,41 @@
+/*
+ * IModelActivityParallel.h
+ *
+ *  Created on: Jun 5, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include <string>
+#include <vector>
+#include "zsp/arl/dm/IModelActivityScope.h"
+#include "vsc/dm/IModelField.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IModelActivityParallel;
+using IModelActivityParallelUP=vsc::dm::UP<IModelActivityParallel>;
+class IModelActivityParallel : 
+	public virtual IModelActivityScope, 
+	public virtual vsc::dm::IModelField {
+public:
+
+	virtual ~IModelActivityParallel() { }
+
+	virtual const std::vector<IModelActivity *> &branches() const = 0;
+
+	virtual void addBranch(IModelActivity *a) = 0;
+
+	// TODO: Need an optional join-spec
+	// Implicit (not supplied) == join_all
+
+
+};
+
+}
+}
+}
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelActivityReplicate.h

@@ -0,0 +1,49 @@
+/**
+ * IModelActivityReplicate.h
+ *
+ * Copyright 2022 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+#include "zsp/arl/dm/IModelActivityScope.h"
+#include "vsc/dm/IModelExpr.h"
+#include "vsc/dm/IModelField.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class IModelActivityReplicate : public virtual IModelActivityScope {
+public:
+
+    virtual ~IModelActivityReplicate() { }
+
+    virtual vsc::dm::IModelExpr *getCountExpr() const = 0;
+
+    virtual vsc::dm::IModelField *getCountField() const = 0;
+
+    virtual vsc::dm::IModelField *getIndexField() const = 0;
+
+};
+
+}
+}
+}
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelActivitySchedule.h

@@ -0,0 +1,30 @@
+/*
+ * IModelActivitySchedule.h
+ *
+ *  Created on: Jun 5, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include <vector>
+#include "zsp/arl/dm/IModelActivityScope.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IModelActivitySchedule : public virtual IModelActivityScope {
+public:
+
+	virtual ~IModelActivitySchedule() { }
+
+	// TODO: Need an optional join-spec
+	// Implicit (not supplied) == join_all
+
+};
+
+}
+}
+}
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelActivityScope.h

@@ -0,0 +1,52 @@
+/*
+ * IModelActivityScope.h
+ *
+ *  Created on: Jun 17, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include <memory>
+#include "vsc/dm/IModelField.h"
+#include "zsp/arl/dm/IModelActivity.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+enum class ModelActivityScopeT {
+	Parallel,
+	Replicate,
+	Schedule,
+	Sequence
+};
+
+class IModelActivityScope;
+using IModelActivityScopeUP=vsc::dm::UP<IModelActivityScope>;
+class IModelActivityScope : 
+	public virtual vsc::dm::IModelField, 
+	public virtual IModelActivity {
+public:
+
+	virtual ~IModelActivityScope() { }
+
+	virtual ModelActivityScopeT getType() const = 0;
+
+	virtual void setType(ModelActivityScopeT t) = 0;
+
+	virtual const std::vector<IModelActivity *> &activities() const = 0;
+
+	virtual void addActivity(IModelActivity *a, bool own=false)  = 0;
+
+	virtual IModelActivity *getActivity(int32_t i) = 0;
+
+	virtual const std::vector<int32_t> &getRoots() const = 0;
+
+	virtual void addRoot(int32_t r) = 0;
+
+};
+
+}
+}
+}

zsp_arl_dm/share/include/zsp/arl/dm/IModelActivitySequence.h

@@ -0,0 +1,28 @@
+/*
+ * IModelActivitySequence.h
+ *
+ *  Created on: Jun 5, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include <vector>
+#include "zsp/arl/dm/IModelActivity.h"
+#include "zsp/arl/dm/IModelActivityScope.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IModelActivitySequence : public virtual IModelActivityScope {
+public:
+
+	virtual ~IModelActivitySequence() { }
+
+};
+
+}
+}
+}
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelActivityTraverse.h

@@ -0,0 +1,53 @@
+/*
+ * IModelActivityTraverse.h
+ *
+ *  Created on: Jun 5, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include <memory>
+#include "zsp/arl/dm/IModelActivity.h"
+#include "zsp/arl/dm/IModelFieldAction.h"
+#include "zsp/arl/dm/IModelFieldPool.h"
+#include "vsc/dm/IModelConstraint.h"
+#include "vsc/dm/IModelField.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IModelActivityTraverse;
+using IModelActivityTraverseUP=vsc::dm::UP<IModelActivityTraverse>;
+class IModelActivityTraverse : public virtual IModelActivity {
+public:
+
+	virtual ~IModelActivityTraverse() { }
+
+	virtual IModelFieldAction *getTarget() const = 0;
+
+	virtual vsc::dm::IModelConstraint *getWithC() const = 0;
+
+	virtual IModelActivity *getActivity() const = 0;
+
+	/**
+	 * @brief Get the Parent Pool object. This will be non-null
+	 *        when this traversal is inferred. 
+	 * 
+	 * @return IModelFieldPool* 
+	 */
+	virtual IModelFieldPool *getParentPool() const = 0;
+
+	virtual void setParentPool(IModelFieldPool *p) = 0;
+
+	virtual bool getProcessed() const = 0;
+
+	virtual void setProcessed(bool p) = 0;
+
+};
+
+}
+}
+}
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelBuildContext.h

@@ -0,0 +1,36 @@
+/*
+ * IModelBuildContext.h
+ *
+ *  Created on: Jun 13, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include "zsp/arl/dm/IContext.h"
+#include "zsp/arl/dm/IModelActivityScope.h"
+#include "vsc/dm/IModelBuildContext.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+class IModelBuildContext;
+using IModelBuildContextUP=vsc::dm::UP<IModelBuildContext>;
+class IModelBuildContext : public virtual vsc::dm::IModelBuildContext {
+public:
+
+	virtual ~IModelBuildContext() { }
+
+	virtual arl::dm::IContext *ctxt() const = 0;
+
+	virtual void pushActivityScope(IModelActivityScope *a)  = 0;
+
+	virtual IModelActivityScope *getActivityScope() = 0;
+
+	virtual IModelActivityScope *popActivityScope() = 0;
+
+};
+
+}
+}
+}

zsp_arl_dm/share/include/zsp/arl/dm/IModelComponentTreeData.h

@@ -0,0 +1,92 @@
+/**
+ * IModelComponentTreeData.h
+ *
+ * Copyright 2022 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+#include <vector>
+#include "zsp/arl/dm/IDataTypeComponent.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+
+class IModelComponentTreeData {
+public:
+
+    virtual ~IModelComponentTreeData() { }
+
+    virtual const std::vector<vsc::dm::IModelField *> &getCompTypeInsts(
+        IDataTypeComponent *t) const = 0;
+
+    virtual const std::vector<int32_t> &getCompInstPath(
+        IModelFieldComponent *comp) = 0;
+
+    virtual const std::vector<IDataTypeComponent *> &getCompTypes() const = 0;
+
+    /**
+     * @brief Get a list of instances of target_t in parent context 'id'
+     * 
+     * @param target_t  - Component type of interest
+     * @param parent_t  - Parent component type
+     * @param parent_id - Parent instance id
+     * @return * const std::vector<int32_t>& 
+     * 
+     */
+    virtual const std::vector<int32_t> &getCompTypeSubInsts(
+        IDataTypeComponent *target_t,
+        IDataTypeComponent *parent_t,
+        int32_t             parent_id) const = 0;
+
+    virtual const std::vector<IModelFieldPool *> &getPools(vsc::dm::IDataType *t) = 0;
+
+    /**
+     * @brief Returns aggregated list of resource objects for a given type
+     * 
+     * @param res_t 
+     * @return const std::vector<vsc::dm::IModelField *>& 
+     */
+    virtual const std::vector<vsc::dm::IModelField *> &getResObjects(IDataTypeResource *res_t) = 0;
+
+    /**
+     * @brief Returns the range of objects associated with the specified pool
+     * 
+     * @param pool 
+     * @return const std::vector<std::pair<int32_t, int32_t>>& 
+     */
+    virtual std::pair<int32_t, int32_t> getResPoolObjRange(IModelFieldPool *pool) = 0;
+
+    /**
+     * @brief Returns the list of per-context bindings for the specified claim type
+     * 
+     * @param claim 
+     * @return std::pair<int32_t, IModelFieldPool *> 
+     */
+    virtual const std::vector<std::pair<int32_t, IModelFieldPool *>> &getClaimBoundCompPool(
+        ITypeFieldClaim *claim) = 0;
+
+};
+
+}
+}
+}
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelEvalIterator.h

@@ -0,0 +1,72 @@
+/*
+ * IModelEvalIterator.h
+ *
+ *  Created on: Apr 24, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include "zsp/arl/dm/IModelEvalIteratorListener.h"
+#include "zsp/arl/dm/IModelFieldAction.h"
+#include "vsc/dm/IModelField.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+enum class ModelEvalNodeT {
+	/**
+	 * 'action' supplies the model to traverse
+	 */
+	Action,
+
+    /**
+     * function call
+     * 
+     */
+    Call,
+
+	/**
+	 * 'iterator' provides the branch iterator
+	 */
+	Parallel,
+
+	/**
+	 * 'iterator' provides the sequence iterator
+	 */
+	Sequence
+
+};
+
+class IModelEvalIterator;
+using IModelEvalIteratorUP=vsc::dm::UP<IModelEvalIterator>;
+class IModelEvalIterator {
+public:
+
+	virtual ~IModelEvalIterator() { }
+
+	/**
+	 * Either 'action' or 'iterator' will be valid on a 'true' return.
+	 * On return of 'false', the iterator is no longer valid
+	 */
+	virtual bool next() = 0;
+
+	virtual bool valid() = 0;
+
+	virtual ModelEvalNodeT type() const = 0;
+
+	virtual IModelFieldAction *action() = 0;
+
+	virtual IModelEvalIterator *iterator() = 0;
+
+    virtual void addListener(IModelEvalIteratorListener *l) = 0;
+
+    virtual void remListener(IModelEvalIteratorListener *l) = 0;
+
+
+};
+
+}
+}
+}

zsp_arl_dm/share/include/zsp/arl/dm/IModelEvalIteratorListener.h

@@ -0,0 +1,62 @@
+/**
+ * IModelEvalIteratorListener.h
+ *
+ * Copyright 2022 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+#include "zsp/arl/dm/IModelFieldAction.h"
+#include "zsp/arl/dm/IModelActivityScope.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class IModelEvalIteratorListener {
+public:
+
+    virtual ~IModelEvalIteratorListener() { }
+
+    virtual void enterCompoundAction(IModelFieldAction *a) = 0;
+
+    virtual void leaveCompoundAction(IModelFieldAction *a) = 0;
+
+    virtual void atomicAction(IModelFieldAction *a) = 0;
+
+    virtual void enterParallel(IModelActivityScope *p) = 0;
+
+    virtual void enterParallelBranch(IModelActivity *a) = 0;
+
+    virtual void leaveParallelBranch(IModelActivity *a) = 0;
+
+    virtual void leaveParallel(IModelActivityScope *p) = 0;
+
+    virtual void enterSequence(IModelActivityScope *a) = 0;
+
+    virtual void leaveSequence(IModelActivityScope *a) = 0;
+
+//    virtual void enterSequence()
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelEvaluator.h

@@ -0,0 +1,41 @@
+/*
+ * IModelEvaluator.h
+ *
+ *  Created on: Apr 24, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include "zsp/arl/dm/IModelEvalIterator.h"
+#include "zsp/arl/dm/IModelFieldComponent.h"
+#include "vsc/dm/IModelField.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IDataTypeAction;
+
+enum class ModelEvaluatorKind {
+	FullElab,
+	IncrElab
+};
+
+class IModelEvaluator;
+using IModelEvaluatorUP=vsc::dm::UP<IModelEvaluator>;
+class IModelEvaluator {
+public:
+
+	virtual ~IModelEvaluator() { }
+
+	virtual IModelEvalIterator *eval(
+			const vsc::dm::IRandState	*randstate,
+			IModelFieldComponent	*root_comp,
+			IDataTypeAction			*root_action) = 0;
+
+};
+
+}
+}
+}

zsp_arl_dm/share/include/zsp/arl/dm/IModelExec.h

@@ -0,0 +1,40 @@
+/**
+ * IModelExec.h
+ *
+ * Copyright 2023 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class IModelExec {
+public:
+
+    virtual ~IModelExec() { }
+
+};
+
+} /* namespace dm */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_dm/share/include/zsp/arl/dm/IModelFieldAction.h

@@ -0,0 +1,34 @@
+/*
+ * IModelFieldAction.h
+ *
+ *  Created on: Jun 5, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include "zsp/arl/dm/IModelActivityScope.h"
+#include "vsc/dm/IModelField.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IModelFieldAction;
+using IModelFieldActionUP=vsc::dm::UP<IModelFieldAction>;
+class IModelFieldAction : public virtual vsc::dm::IModelField {
+public:
+
+	virtual ~IModelFieldAction() { }
+
+	virtual bool isCompound() const = 0;
+
+	virtual IModelActivityScope *getActivity() const = 0;
+
+	virtual void setActivity(IModelActivityScope *a) = 0;
+
+};
+
+}
+}
+}