From 34161f10cb54aea7252aead3013154ff2a86316f Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 27 Aug 2020 17:46:30 +0200
Subject: [PATCH] DynamicOuterOp

---
 src/include/dynamic_operation.cc.h | 50 ++++++++++++++++++++++++++++++
 src/include/dynamic_operation.h    | 33 ++++++++++++++++++++
 2 files changed, 83 insertions(+)

diff --git a/src/include/dynamic_operation.cc.h b/src/include/dynamic_operation.cc.h
index 056628d..227c0ee 100644
--- a/src/include/dynamic_operation.cc.h
+++ b/src/include/dynamic_operation.cc.h
@@ -40,5 +40,55 @@ namespace MultiArrayTools
         return std::make_shared<DynamicOperation<T,Operation>>(*this);
     }
 
+    template <typename T, class Operation, class... Ranges>
+    DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(const Operation& op,
+                                                          const std::shared_ptr<typename Ranges::IndexType>&... inds)
+        : mOp(op)
+    {
+        //...!!!
+        // setup operations
+    }
+
+    template <typename T, class Operation, class... Ranges>
+    OpH<ConstOperationRoot<T,Ranges...>> DynamicOuterOp<T,Operation,Ranges...>::get(const DExtT& pos) const
+    {
+        mOp.get(pos.expl<ET>());
+        //...
+        // execute assignment... care about threads!!!
+        return OpH<ConstOperationRoot<T,Ranges...>>(); // empty
+    }
+    
+    template <typename T, class Operation, class... Ranges>
+    DynamicOperationBase<OpH<ConstOperationRoot<T,Ranges...>>>&
+    DynamicOuterOp<T,Operation,Ranges...>::set(const DExtT& pos)
+    {
+	mOp.set(pos.expl<ET>());
+	return *this;
+    }
+    
+    template <typename T, class Operation, class... Ranges>
+    DExtT DynamicOuterOp<T,Operation,Ranges...>::rootSteps(std::intptr_t iPtrNum) const
+    {
+        return DExtT(mkDExt(mkExtT(mOp.rootSteps(iPtrNum))),None(0));
+    }
+    
+    template <typename T, class Operation, class... Ranges>
+    DynamicExpression DynamicOuterOp<T,Operation,Ranges...>::loop(const DynamicExpression& exp) const
+    {
+        return mOp.loop(exp);
+    }
+    
+    template <typename T, class Operation, class... Ranges>
+    const OpH<ConstOperationRoot<T,Ranges...>>* DynamicOuterOp<T,Operation,Ranges...>::data() const
+    {
+        return &mProto;
+    }
+    
+    template <typename T, class Operation, class... Ranges>
+    std::shared_ptr<DynamicOperationBase<OpH<ConstOperationRoot<T,Ranges...>>>>
+    DynamicOuterOp<T,Operation,Ranges...>::deepCopy() const
+    {
+        return std::make_shared<DynamicOuterOp<T,Operation,Ranges...>>(*this);
+    }
 
 } // namespace MultiArrayTools
diff --git a/src/include/dynamic_operation.h b/src/include/dynamic_operation.h
index 704b3a6..3ba7f86 100644
--- a/src/include/dynamic_operation.h
+++ b/src/include/dynamic_operation.h
@@ -58,6 +58,39 @@ namespace MultiArrayTools
         virtual std::shared_ptr<DynamicOperationBase<T>> deepCopy() const override final;
     };
 
+    template <class Op>
+    struct OpH
+    {
+        Op mOp;
+    };
+    
+    template <typename T, class Operation, class... Ranges>
+    class DynamicOuterOp : public DynamicOperationBase<OpH<ConstOperationRoot<T,Ranges...>>>
+    {
+    private:
+	Operation mOp;
+        //ConstOperationRoot<T,Ranges...> mProto;
+        OpH<ConstOperationRoot<T,Ranges...>> mProto;
+    public:
+        typedef decltype(mOp.rootSteps()) ET;
+	//typedef decltype(std::declval<Operation>().rootSteps()) ET;
+	
+	DynamicOuterOp() = default;
+	DynamicOuterOp(const DynamicOuterOp& in) = default;
+	DynamicOuterOp(DynamicOuterOp&& in) = default;
+	DynamicOuterOp& operator=(const DynamicOuterOp& in) = default;
+	DynamicOuterOp& operator=(DynamicOuterOp&& in) = default;
+
+	DynamicOuterOp(const Operation& op, const std::shared_ptr<typename Ranges::IndexType>&... inds);
+
+	virtual OpH<ConstOperationRoot<T,Ranges...>> get(const DExtT& pos) const override final;
+	virtual DynamicOperationBase<OpH<ConstOperationRoot<T,Ranges...>>>& set(const DExtT& pos) override final;
+	virtual DExtT rootSteps(std::intptr_t iPtrNum = 0) const override final;
+	virtual DynamicExpression loop(const DynamicExpression& exp) const override final;
+	virtual const OpH<ConstOperationRoot<T,Ranges...>>* data() const override final;
+        virtual std::shared_ptr<DynamicOperationBase<OpH<ConstOperationRoot<T,Ranges...>>>> deepCopy() const override final;
+    };
+
     template <typename T>
     class DynamicO : public OperationTemplate<T,DynamicO<T>>
     {