zuspec-arl-dm 0.1.0.15264414400rc0__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

zsp_arl_dm/share/include/zsp/arl/dm/impl/CopyVisitor.h

@@ -0,0 +1,204 @@
+/**
+ * CopyVisitor.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/IContext.h"
+#include "zsp/arl/dm/IModelBuildContext.h"
+#include "zsp/arl/dm/impl/ModelBuildContext.h"
+#include "zsp/arl/dm/impl/VisitorDelegator.h"
+#include "vsc/dm/impl/CopyVisitor.h"
+#include "dmgr/IDebugMgr.h"
+#include "dmgr/impl/DebugMacros.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class CopyVisitor : public virtual VisitorDelegator {
+public:
+    CopyVisitor(
+        IContext                *ctxt,
+        IModelBuildContext      *build_ctxt=0) : VisitorDelegator(&m_core), 
+        m_dbg(0), m_ctxt(ctxt), m_build_ctxt(build_ctxt?build_ctxt:&m_build_ctxt_l),
+        m_build_ctxt_l(ctxt), m_core(ctxt, m_build_ctxt, this) { 
+        DEBUG_INIT("CopyVisitor", ctxt->getDebugMgr());
+    }
+
+    virtual ~CopyVisitor() { }
+
+    vsc::dm::IAccept *copy(vsc::dm::IAccept *o) {
+        return m_core.copy(o);
+    }
+
+    template <class T> T *copyT(vsc::dm::IAccept *o) {
+        return dynamic_cast<T *>(copy(o));
+    }
+
+	virtual void visitDataTypeComponent(IDataTypeComponent *t) override {
+
+    }
+
+	virtual void visitDataTypeFlowObj(IDataTypeFlowObj *t) override { }
+
+	virtual void visitDataTypeFunction(IDataTypeFunction *t) override { }
+
+	virtual void visitDataTypeResource(IDataTypeResource *t) override { }
+
+	virtual void visitModelActivityParallel(IModelActivityParallel *a) override { }
+
+	virtual void visitModelActivityReplicate(IModelActivityReplicate *a) override { 
+        vsc::dm::IModelExpr *count_e = copyT<vsc::dm::IModelExpr>(a->getCountExpr());
+        IModelActivityReplicate *ac = m_ctxt->mkModelActivityReplicate(count_e);
+
+        for (std::vector<vsc::dm::IModelFieldUP>::const_iterator
+            it=a->getFields().begin();
+            it!=a->getFields().end(); it++) {
+            ac->addField(copyT<vsc::dm::IModelField>(it->get()));
+        }
+        
+        for (std::vector<vsc::dm::IModelConstraintUP>::const_iterator
+            it=a->getConstraints().begin();
+            it!=a->getConstraints().end(); it++) {
+            ac->addConstraint(copyT<vsc::dm::IModelConstraint>(it->get()));
+        }
+
+        for (std::vector<IModelActivity *>::const_iterator
+            it=a->activities().begin();
+            it!=a->activities().end(); it++) {
+            IModelActivity *it_c = copyT<IModelActivity>(*it);
+            ac->addActivity(it_c, true);
+        }
+
+        ret(ac);
+    }
+
+	virtual void visitModelActivitySchedule(IModelActivitySchedule *a) override { }
+
+	virtual void visitModelActivityScope(IModelActivityScope *a) override { 
+        IModelActivityScope *ac = m_ctxt->mkModelActivityScope(a->getType());
+
+        for (std::vector<IModelActivity *>::const_iterator
+            it=a->activities().begin();
+            it!=a->activities().end(); it++) {
+            IModelActivity *it_c = copyT<IModelActivity>(*it);
+            ac->addActivity(it_c, true);
+        }
+
+        ret(ac);
+    }
+
+	virtual void visitModelActivitySequence(IModelActivitySequence *a) override { }
+
+	virtual void visitModelActivityTraverse(IModelActivityTraverse *a) override { 
+        DEBUG_ENTER("visitModelActivityTravserse");
+        vsc::dm::IModelConstraint *with_c = 0;
+        if (a->getWithC()) {
+            with_c = copyT<vsc::dm::IModelConstraint>(a->getWithC());
+        }
+
+        DEBUG("target=%p target_c=%p", 
+            a->getTarget(), get_copyT<IModelFieldAction>(a->getTarget()));
+
+        IModelActivity *activity = 0;
+        if (a->getActivity()) {
+            activity = copyT<IModelActivity>(a->getActivity());
+        }
+
+        IModelActivityTraverse *ac = m_ctxt->mkModelActivityTraverse(
+            get_copyT<IModelFieldAction>(a->getTarget()),
+            with_c,
+            true,
+            activity,
+            true
+        );
+
+        ret(ac);
+        DEBUG_LEAVE("visitModelActivityTravserse");
+    }
+
+	virtual void visitModelFieldAction(IModelFieldAction *f) override {
+        DEBUG_ENTER("visitModelFieldAction");
+        IModelFieldAction *fc = m_ctxt->mkModelFieldActionRoot(
+            f->name(),
+            f->getDataTypeT<IDataTypeAction>()
+        );
+
+        DEBUG("src=%p copy=%p", f, fc);
+        add_copy(f, fc);
+
+        for (std::vector<vsc::dm::IModelFieldUP>::const_iterator
+            it=f->getFields().begin();
+            it!=f->getFields().end(); it++) {
+            fc->addField(copyT<vsc::dm::IModelField>(it->get()));
+        }
+
+        for (std::vector<vsc::dm::IModelConstraintUP>::const_iterator
+            it=f->getConstraints().begin();
+            it!=f->getConstraints().end(); it++) {
+            fc->addConstraint(copyT<vsc::dm::IModelConstraint>(it->get()));
+        }
+
+        if (f->getActivity()) {
+            fc->setActivity(copyT<IModelActivityScope>(f->getActivity()));
+        }
+        DEBUG_LEAVE("visitModelFieldAction");
+    }
+
+	virtual void visitModelFieldComponent(IModelFieldComponent *f) override { }
+
+	virtual void visitModelFieldExecutor(IModelFieldExecutor *f) override { }
+
+	virtual void visitModelFieldExecutorClaim(IModelFieldExecutorClaim *f) override { }
+
+	virtual void visitModelFieldPool(IModelFieldPool *f) override { }
+
+public:
+
+    void ret(vsc::dm::IAccept *ret) { m_core.ret(ret); }
+
+    vsc::dm::IAccept *get_copy(vsc::dm::IAccept *s) {
+        return m_core.get_copy(s);
+    }
+
+	template <class T> T *get_copyT(vsc::dm::IAccept *s) {
+		return dynamic_cast<T *>(get_copy(s));
+	}
+
+    void add_copy(vsc::dm::IAccept *s, vsc::dm::IAccept *c) {
+        m_core.add_copy(s, c);
+    }
+
+protected:
+    dmgr::IDebug                            *m_dbg;
+    IContext                                *m_ctxt;
+    IModelBuildContext                      *m_build_ctxt;
+    ModelBuildContext                       m_build_ctxt_l;
+    vsc::dm::CopyVisitor                    m_core;
+
+};
+
+
+}
+}
+}
+
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/IsResourcePool.h

@@ -0,0 +1,55 @@
+/**
+ * IsResourcePool.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/impl/VisitorBase.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class IsResourcePool : public VisitorBase {
+public:
+    IsResourcePool() : m_ret(false) { }
+
+    virtual ~IsResourcePool() { }
+
+    bool test(IModelFieldPool *pool) {
+        m_ret = false;
+        pool->getDataTypePool()->accept(m_this);
+        return m_ret;
+    }
+
+	virtual void visitDataTypeFlowObj(IDataTypeFlowObj *t) override { }
+
+	virtual void visitDataTypeResource(IDataTypeResource *t) override {
+        m_ret = true;
+    }
+
+private:
+    bool                m_ret;
+};
+
+}
+}
+}
+
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/ModelBuildContext.h

@@ -0,0 +1,52 @@
+/*
+ * ModelBuildContext.h
+ *
+ *  Created on: Jun 12, 2022
+ *      Author: mballance
+ */
+
+#pragma once
+#include "zsp/arl/dm/IModelBuildContext.h"
+#include "vsc/dm/impl/ModelBuildContext.h"
+#include "vsc/dm/IModelField.h"
+#include <vector>
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+class ModelBuildContext : public virtual IModelBuildContext, public virtual vsc::dm::ModelBuildContext {
+public:
+	ModelBuildContext(IContext *ctxt) : vsc::dm::ModelBuildContext(ctxt) { }
+
+	virtual ~ModelBuildContext() { }
+
+	virtual void pushActivityScope(IModelActivityScope *a) override {
+		m_activity_scope_s.push_back(a);
+	}
+
+	virtual IModelActivityScope *getActivityScope() override {
+		return (m_activity_scope_s.size())?m_activity_scope_s.back():0;
+	}
+
+	virtual IModelActivityScope *popActivityScope() override {
+		IModelActivityScope *ret = getActivityScope();
+		if (ret) {
+			m_activity_scope_s.pop_back();
+		}
+		return ret;
+	}
+
+	virtual IContext *ctxt() const override { return dynamic_cast<IContext *>(m_ctxt); }
+
+protected:
+
+	std::vector<IModelActivityScope *>			m_activity_scope_s;
+
+};
+
+}
+}
+}
+

zsp_arl_dm/share/include/zsp/arl/dm/impl/ModelEvalIteratorListenerBase.h

@@ -0,0 +1,60 @@
+/**
+ * ModelEvalIteratorListenerBase.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/IModelEvalIteratorListener.h"
+
+namespace zsp {
+namespace arl {
+namespace dm {
+
+
+
+class ModelEvalIteratorListenerBase : public virtual IModelEvalIteratorListener {
+public:
+    ModelEvalIteratorListenerBase() { }
+
+    virtual ~ModelEvalIteratorListenerBase() { }
+
+    virtual void enterCompoundAction(IModelFieldAction *a) override { }
+
+    virtual void leaveCompoundAction(IModelFieldAction *a) override { }
+
+    virtual void atomicAction(IModelFieldAction *a) override { }
+
+    virtual void enterParallel(IModelActivityScope *p) override { }
+
+    virtual void enterParallelBranch(IModelActivity *a) override { }
+
+    virtual void leaveParallelBranch(IModelActivity *a) override { }
+
+    virtual void leaveParallel(IModelActivityScope *p) override { }
+
+    virtual void enterSequence(IModelActivityScope *a) override { }
+
+    virtual void leaveSequence(IModelActivityScope *a) override { }
+
+};
+
+}
+}
+}
+
+