From 49dd9ef548116b697bda259489ad661a1366bad4 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Tue, 17 Sep 2019 14:24:01 +0200
Subject: [PATCH] map range: enable creation on arbitrary target range (of same
 type with real target space as sub-space)

---
 src/include/helper_tools.cc.h | 17 ++++++++++
 src/include/helper_tools.h    | 13 ++++++++
 src/include/map_range.cc.h    | 58 ++++++++++++++++++++++++++++++++++-
 src/include/map_range.h       | 17 ++++++++++
 4 files changed, 104 insertions(+), 1 deletion(-)

diff --git a/src/include/helper_tools.cc.h b/src/include/helper_tools.cc.h
index 5b1fa72..d3285d8 100644
--- a/src/include/helper_tools.cc.h
+++ b/src/include/helper_tools.cc.h
@@ -53,6 +53,15 @@ namespace MultiArrayTools
 	return createExplicit( mrf );
     }
 
+    template <SpaceType STYPE, class Op, class MA, class... RangeTypes>
+    auto mkGenMapRwith(const std::shared_ptr<MapORType<Op,STYPE>>& outr, const std::tuple<Op,MA>& f,
+                       std::shared_ptr<RangeTypes>... ranges)
+	-> std::shared_ptr<GenMapRange<Op,STYPE,RangeTypes...> >
+    {
+        GenMapRangeFactory<Op,STYPE,RangeTypes...> mrf(outr, f, ranges... );
+	return createExplicit( mrf );
+    }
+
     template <SpaceType STYPE, class Op, class MA, class... IndexTypes>
     auto mkGenMapI(const std::tuple<Op,MA>& f, std::shared_ptr<IndexTypes>... indices)
 	-> decltype( getIndex( mkGenMapR<STYPE>( f, indices->range()... ) ) )
@@ -69,6 +78,14 @@ namespace MultiArrayTools
         return mkGenMapR<SpaceType::ANY>(f, ranges... );
     }
 
+    template <class Op, class MA, class... RangeTypes>
+    auto mkMapRwith(const std::shared_ptr<MapORType<Op,SpaceType::ANY>>& outr, const std::tuple<Op,MA>& f,
+                    std::shared_ptr<RangeTypes>... ranges)
+	-> decltype( mkGenMapRwith<SpaceType::ANY>(outr, f, ranges... ) )
+    {
+        return mkGenMapRwith<SpaceType::ANY>(outr, f, ranges... );
+    }
+
     template <class Op, class MA, class... IndexTypes>
     auto mkMapI(const std::tuple<Op,MA>& f, std::shared_ptr<IndexTypes>... indices)
 	-> decltype( mkGenMapI<SpaceType::ANY>(f, indices... ) )
diff --git a/src/include/helper_tools.h b/src/include/helper_tools.h
index 2c66148..fb7512f 100644
--- a/src/include/helper_tools.h
+++ b/src/include/helper_tools.h
@@ -32,6 +32,14 @@ namespace MultiArrayTools
     auto mkGenMapR(const std::tuple<Op,MA>& f, std::shared_ptr<RangeTypes>... ranges)
 	-> std::shared_ptr<GenMapRange<Op,STYPE,RangeTypes...> >;
 
+    template <class Op, SpaceType XSTYPE>
+    using MapORType = SingleRange<typename Op::value_type,XSTYPE>;
+    
+    template <SpaceType STYPE, class Op, class MA, class... RangeTypes>
+    auto mkGenMapRwith(const std::shared_ptr<MapORType<Op,STYPE>>& outr, const std::tuple<Op,MA>& f,
+                       std::shared_ptr<RangeTypes>... ranges)
+	-> std::shared_ptr<GenMapRange<Op,STYPE,RangeTypes...> >;
+
     template <SpaceType STYPE, class Op, class MA, class... IndexTypes>
     auto mkGenMapI(const std::tuple<Op,MA>& f, std::shared_ptr<IndexTypes>... indices)
 	-> decltype( getIndex( mkGenMapR<STYPE>( f, indices->range()... ) ) );
@@ -40,6 +48,11 @@ namespace MultiArrayTools
     auto mkMapR(const std::tuple<Op,MA>& f, std::shared_ptr<RangeTypes>... ranges)
 	-> decltype( mkGenMapR<SpaceType::ANY>(f, ranges... ) );
 
+    template <class Op, class MA, class... RangeTypes>
+    auto mkMapRwith(const std::shared_ptr<MapORType<Op,SpaceType::ANY>>& outr, const std::tuple<Op,MA>& f,
+                    std::shared_ptr<RangeTypes>... ranges)
+	-> decltype( mkGenMapRwith<SpaceType::ANY>(outr, f, ranges... ) );
+
     template <class Op, class MA, class... IndexTypes>
     auto mkMapI(const std::tuple<Op,MA>& f, std::shared_ptr<IndexTypes>... indices)
 	-> decltype( mkGenMapI<SpaceType::ANY>(f, indices... ) );
diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 51e5e92..da601a9 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -327,6 +327,26 @@ namespace MultiArrayTools
      *   MapRangeFactory   *
      *************************/
 
+    template <class Op, SpaceType XSTYPE, class... Ranges>
+    template <class MA>
+    GenMapRangeFactory<Op,XSTYPE,Ranges...>::GenMapRangeFactory(const std::shared_ptr<ORType>& outr,
+                                                                const std::tuple<Op,MA>& mapf,
+                                                                const std::shared_ptr<Ranges>&... rs)
+    {
+	mProd = std::shared_ptr< GenMapRange<Op,XSTYPE,Ranges...> >
+            ( new GenMapRange<Op,XSTYPE,Ranges...>( outr, mapf, rs... ) );
+    }
+    
+    template <class Op, SpaceType XSTYPE, class... Ranges>
+    template <class MA>
+    GenMapRangeFactory<Op,XSTYPE,Ranges...>::GenMapRangeFactory(const std::shared_ptr<ORType>& outr,
+                                                                const std::tuple<Op,MA>& mapf,
+                                                                const typename GenMapRange<Op,XSTYPE,Ranges...>::Space& st)
+    {
+	mProd = std::shared_ptr< GenMapRange<Op,XSTYPE,Ranges...> >
+            ( new GenMapRange<Op,XSTYPE,Ranges...>( outr, mapf, st ) );
+    }
+
     template <class Op, SpaceType XSTYPE, class... Ranges>
     template <class MA>
     GenMapRangeFactory<Op,XSTYPE,Ranges...>::GenMapRangeFactory(const std::tuple<Op,MA>& mapf,
@@ -456,7 +476,43 @@ namespace MultiArrayTools
         }
 
     }
-    
+
+    template <class Op, SpaceType XSTYPE, class... Ranges>
+    template <class MA>
+    GenMapRange<Op,XSTYPE,Ranges...>::GenMapRange(const std::shared_ptr<ORType>& outr, const std::tuple<Op,MA>& mapf,
+                                                  const std::shared_ptr<Ranges>&... rs) :
+        mSpace(std::make_tuple(rs...)),
+        mMapf(std::get<0>(mapf)),
+        mOutRange(outr),
+        mMapMult(mOutRange,0),
+        mMapPos(std::get<1>(mapf).size(),mOutRange->size())
+    {
+        auto& ma = std::get<1>(mapf);
+        auto jj = mMapMult.begin();
+        for(auto ii = ma.begin(); ii.pos() != ii.max(); ++ii){
+            ++mMapMult[jj.at(ma[ii])];
+            mMapPos[ii.pos()] = jj.pos();
+        }
+    }
+
+    template <class Op, SpaceType XSTYPE, class... Ranges>
+    template <class MA>
+    GenMapRange<Op,XSTYPE,Ranges...>::GenMapRange(const std::shared_ptr<ORType>& outr, const std::tuple<Op,MA>& mapf,
+                                                  const Space& space) :
+        mSpace(space),
+        mMapf(std::get<0>(mapf)),
+        mOutRange(outr),
+        mMapMult(mOutRange,0),
+        mMapPos(std::get<1>(mapf).size(),mOutRange->size())
+    {
+        auto& ma = std::get<1>(mapf);
+        auto jj = mMapMult.begin();
+        for(auto ii = ma.begin(); ii.pos() != ii.max(); ++ii){
+            ++mMapMult[jj.at(ma[ii])];
+            mMapPos[ii.pos()] = jj.pos();
+        }
+    }
+
     template <class Op, SpaceType XSTYPE, class... Ranges>
     template <class MA>
     GenMapRange<Op,XSTYPE,Ranges...>::GenMapRange(const std::tuple<Op,MA>& mapf,
diff --git a/src/include/map_range.h b/src/include/map_range.h
index 6fa38c8..a22f326 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -211,10 +211,19 @@ namespace MultiArrayTools
     class GenMapRangeFactory : public RangeFactoryBase
     {
     public:
+	typedef SingleRange<typename Op::value_type,XSTYPE> ORType;
 	typedef GenMapRange<Op,XSTYPE,Ranges...> oType;
 	
 	GenMapRangeFactory() = delete;
 
+        template <class MA>
+        GenMapRangeFactory(const std::shared_ptr<ORType>& outr, const std::tuple<Op,MA>& mapf,
+                           const std::shared_ptr<Ranges>&... rs);
+
+        template <class MA>
+        GenMapRangeFactory(const std::shared_ptr<ORType>& outr, const std::tuple<Op,MA>& mapf,
+                           const typename GenMapRange<Op,XSTYPE,Ranges...>::Space& st);
+
         template <class MA>
 	GenMapRangeFactory(const std::tuple<Op,MA>& mapf, const std::shared_ptr<Ranges>&... rs);
 
@@ -252,6 +261,14 @@ namespace MultiArrayTools
 	GenMapRange(const GenMapRange& in) = delete;
 	GenMapRange& operator=(const GenMapRange& in) = delete;
 
+        template <class MA>
+        GenMapRange(const std::shared_ptr<ORType>& outr, const std::tuple<Op,MA>& mapf,
+                    const std::shared_ptr<Ranges>&... rs);
+
+        template <class MA>
+        GenMapRange(const std::shared_ptr<ORType>& outr, const std::tuple<Op,MA>& mapf,
+                    const Space& space);
+
         template <class MA>
         GenMapRange(const std::tuple<Op,MA>& mapf, const Space& space);