further packnum replacements

src/include/map_range.cc.h

@@ -175,10 +175,7 @@ namespace MultiArrayTools
     template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
     GenMapIndex<OIType,Op,XSTYPE,Indices...>& GenMapIndex<OIType,Op,XSTYPE,Indices...>::operator()(const std::shared_ptr<Indices>&... indices)
     {
-	//RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, indices...);
-	//RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, IB::mPos);
 	return (*this)(std::make_tuple(indices...));
-	//return *this;
     }
 
     template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
@@ -186,7 +183,6 @@ namespace MultiArrayTools
     {
 	sfor_pn<0,sizeof...(Indices)>
 	    ( [&](auto i) { std::get<i>(mIPack) = std::get<i>(indices); return 0; } );
-	//RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, indices...);
 	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, IB::mPos);
 	return *this;
     }
@@ -386,7 +382,9 @@ namespace MultiArrayTools
 	bool check = false;
 	for(auto& x: MapRangeFactoryProductMap::mAleadyCreated){
 	    if(x.second.size() == sizeof...(Ranges)){
-		check = RPackNum<sizeof...(Ranges)-1>::checkIfCreated(ptp, x.second);
+		check = sfor_p<0,sizeof...(Ranges)>
+		    ( [&](auto i) { return reinterpret_cast<std::intptr_t>( std::get<i>(ptp).get() ) == x.second[i]; },
+		      [&](auto a, auto b) { return a and b; } );
 		if(check){
 		    out = x.first;
 		    break;
@@ -395,7 +393,8 @@ namespace MultiArrayTools
 	}
 	if(not check){
 	    vector<std::intptr_t> pv(sizeof...(Ranges));
-	    RPackNum<sizeof...(Ranges)-1>::RangesToVec(ptp, pv);
+	    sfor_pn<0,sizeof...(Ranges)>
+		( [&](auto i) { pv[i] = reinterpret_cast<std::intptr_t>( std::get<i>(ptp).get() ); return 0; } );
 	    pv.push_back( reinterpret_cast<std::intptr_t>
 			  ( &std::dynamic_pointer_cast<oType>( mProd )->mMapf ) );
 	    MapRangeFactoryProductMap::mAleadyCreated[mProd] = pv;
@@ -626,7 +625,13 @@ namespace MultiArrayTools
 	//out.reserve(h.metaSize + sizeof(DataHeader));
 	char* hcp = reinterpret_cast<char*>(&h);
 	out.insert(out.end(), hcp, hcp + sizeof(DataHeader));
-	RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
+	sfor_pn<0,sizeof...(Ranges)>
+	    ( [&](auto i) {
+		vector<char> part = std::get<i>(mSpace)->data();
+		out.insert(out.end(), part.begin(), part.end());
+		return 0;
+	    } );
+	//RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
 	return out;
     }
 

src/include/ranges/anonymous_range.h

@@ -171,23 +171,28 @@ namespace MultiArrayTools
 
     std::shared_ptr<AnonymousRange> defaultRange(size_t size = 0);
 }
-
+namespace MultiArrayTools
+{
+    namespace RangeHelper
+    {
+	template <>
+	inline void resolveSetRange<AnonymousRange>(std::shared_ptr<AnonymousRange>& rp,
+						    const vector<std::shared_ptr<RangeBase> >& orig,
+						    size_t origpos, size_t size)
+	{
+	    AnonymousRangeFactory arf;
+	    for(size_t op = origpos; op != origpos + size; ++op){
+		//VCHECK(op);
+		arf.append(orig[op]);
+	    }
+	    rp = std::dynamic_pointer_cast<AnonymousRange>( arf.create() );
+	}
+    }
+}
 namespace MultiArrayHelper
 {
     using namespace MultiArrayTools;
 
-    template <>
-    inline void resolveSetRange<AnonymousRange>(std::shared_ptr<AnonymousRange>& rp,
-						const vector<std::shared_ptr<RangeBase> >& orig,
-						size_t origpos, size_t size)
-    {
-    	AnonymousRangeFactory arf;
-	for(size_t op = origpos; op != origpos + size; ++op){
-	    //VCHECK(op);
-	    arf.append(orig[op]);
-	}
-    	rp = std::dynamic_pointer_cast<AnonymousRange>( arf.create() );
-    }
 
     template <>
     inline void setRangeToVec<AnonymousRange>(vector<std::shared_ptr<RangeBase> >& v,
@@ -212,7 +217,9 @@ namespace MultiArrayTools
     GenSingleRange<size_t,SpaceType::ANON,MUI>::GenSingleRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs) :
 	RangeInterface<AnonymousIndex>()
     {
-	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( origs, mOrig );
+	mOrig.resize(sizeof...(RangeTypes));
+	sfor_pn<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { mOrig[i] = std::get<i>(origs); return 0; } );
 	mSize = sfor_p<0,sizeof...(RangeTypes)>
 	    ( [&](auto i) { return std::get<i>(origs)->size(); },
 	      [&](auto a, auto b) { return a * b; } );
@@ -226,7 +233,9 @@ namespace MultiArrayTools
 	RangeInterface<AnonymousIndex>()
     {
 	auto rst = std::make_tuple(origs...);
-	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( rst, mOrig );
+	mOrig.resize(sizeof...(RangeTypes));
+	sfor_pn<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { mOrig[i] = std::get<i>(rst); return 0; } );
 	mSize = sfor_p<0,sizeof...(RangeTypes)>
 	    ( [&](auto i) { return std::get<i>(rst)->size(); },
 	      [&](auto a, auto b) { return a * b; } );
@@ -245,7 +254,8 @@ namespace MultiArrayTools
     std::shared_ptr<MultiRange<Ranges...> > GenSingleRange<size_t,SpaceType::ANON,MUI>::scast(SIZET<Ranges>... sizes) const
     {
 	std::tuple<std::shared_ptr<Ranges>...> rtp;
-	RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);
+	RangeHelper::resolveRangeType<0>(mOrig, rtp, 0, sizes...);
+	//RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);
 	MultiRangeFactory<Ranges...> mrf(rtp);
 	return std::dynamic_pointer_cast<MultiRange<Ranges...> >( mrf.create() );
     }

src/include/ranges/container_range.h

@@ -154,9 +154,6 @@ namespace MultiArrayTools
 
 	size_t getStepSize(size_t n);
 
-	std::string id() const;
-	void print(size_t offset);
-	
 	template <class Exprs>
 	auto ifor(size_t step, Exprs exs) const;
 
@@ -457,24 +454,6 @@ namespace MultiArrayTools
 	}
 	return mBlockSizes[n+1];
     }
-    
-    template <typename T, class... Indices>
-    std::string ContainerIndex<T,Indices...>::id() const
-    {
-	return std::string("con") + std::to_string(IB::mId);
-    }
-
-    template <typename T, class... Indices>
-    void ContainerIndex<T,Indices...>::print(size_t offset)
-    {
-	if(offset == 0){
-	    std::cout << " === " << std::endl;
-	}
-	for(size_t j = 0; j != offset; ++j) { std::cout << "\t"; }
-	std::cout << id() << "[" << reinterpret_cast<std::intptr_t>(this) << "]"
-		  << "(" << IB::mRangePtr << "): " << meta() << std::endl;
-	RPackNum<sizeof...(Indices)-1>::printIndex(mIPack, offset+1);
-    }
 
     template <typename T, class... Indices>
     template <class Exprs>

src/include/ranges/dynamic_range.cc.h

@@ -143,7 +143,9 @@ namespace MultiArrayTools
     DynamicRange::DynamicRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs) :
 	RangeInterface<DynamicIndex>()
     {
-	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( origs, mOrig );
+	mOrig.resize(sizeof...(RangeTypes));
+	sfor_pn<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { mOrig[i] = std::get<i>(origs); return 0; } );
 	mSize = sfor_p<0,sizeof...(RangeTypes)>
 	    ( [&](auto i) { return std::get<i>(origs)->size(); },
 	      [&](auto a, auto b) { return a * b; } );
@@ -158,7 +160,9 @@ namespace MultiArrayTools
 	RangeInterface<DynamicIndex>()
     {
 	auto rst = std::make_tuple(origs...);
-	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( rst, mOrig );
+	mOrig.resize(sizeof...(RangeTypes));
+	sfor_pn<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { mOrig[i] = std::get<i>(rst); return 0; } );
 	mSize = sfor_p<0,sizeof...(RangeTypes)>
 	    ( [&](auto i) { return std::get<i>(rst)->size(); },
 	      [&](auto a, auto b) { return a * b; } );
@@ -179,7 +183,8 @@ namespace MultiArrayTools
     std::shared_ptr<MultiRange<Ranges...> > DynamicRange::scast(SIZET<Ranges>... sizes) const
     {
 	std::tuple<std::shared_ptr<Ranges>...> rtp;
-	RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);
+	RangeHelper::resolveRangeType<0>(mOrig, rtp, 0, sizes...);
+	//RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);
 	MultiRangeFactory<Ranges...> mrf(rtp);
 	return std::dynamic_pointer_cast<MultiRange<Ranges...> >( mrf.create() );
     }
@@ -187,25 +192,33 @@ namespace MultiArrayTools
     
 } // end namespace MultiArrayTools
 
+namespace MultiArrayTools
+{
+    namespace RangeHelper
+    {
+	template <>
+	inline void resolveSetRange<DynamicRange>(std::shared_ptr<DynamicRange>& rp,
+						  const vector<std::shared_ptr<RangeBase> >& orig,
+						  size_t origpos, size_t size)
+	{
+	    DynamicRangeFactory arf;
+	    for(size_t op = origpos; op != origpos + size; ++op){
+		//VCHECK(op);
+		arf.append(orig[op]);
+	    }
+	    rp = std::dynamic_pointer_cast<DynamicRange>( arf.create() );
+	}
+	
+    }
+}
+
 namespace MultiArrayHelper
 {
     namespace
     {
         using namespace MultiArrayTools;
     }
-
+    
-    template <>
-    inline void resolveSetRange<DynamicRange>(std::shared_ptr<DynamicRange>& rp,
-                                              const vector<std::shared_ptr<RangeBase> >& orig,
-                                              size_t origpos, size_t size)
-    {
-    	DynamicRangeFactory arf;
-	for(size_t op = origpos; op != origpos + size; ++op){
-	    //VCHECK(op);
-	    arf.append(orig[op]);
-	}
-    	rp = std::dynamic_pointer_cast<DynamicRange>( arf.create() );
-    }
 
     template <>
     inline void setRangeToVec<DynamicRange>(vector<std::shared_ptr<RangeBase> >& v,

src/include/ranges/multi_range.h

@@ -528,7 +528,9 @@ namespace MultiArrayTools
 	bool check = false;
 	for(auto& x: MultiRangeFactoryProductMap::mAleadyCreated){
 	    if(x.second.size() == sizeof...(Ranges)){
-		check = RPackNum<sizeof...(Ranges)-1>::checkIfCreated(ptp, x.second);
+		check = sfor_p<0,sizeof...(Ranges)>
+		    ( [&](auto i) { return reinterpret_cast<std::intptr_t>( std::get<i>(ptp).get() ) == x.second[i]; },
+		      [&](auto a, auto b) { return a and b; } );
 		if(check){
 		    out = x.first;
 		    break;
@@ -537,7 +539,8 @@ namespace MultiArrayTools
 	}
 	if(not check){
 	    vector<std::intptr_t> pv(sizeof...(Ranges));
-	    RPackNum<sizeof...(Ranges)-1>::RangesToVec(ptp, pv);
+	    sfor_pn<0,sizeof...(Ranges)>
+		( [&](auto i) { pv[i] = reinterpret_cast<std::intptr_t>( std::get<i>(ptp).get() ); return 0; } );
 	    MultiRangeFactoryProductMap::mAleadyCreated[mProd] = pv;
 	    out = mProd;
 	}
@@ -647,7 +650,13 @@ namespace MultiArrayTools
 	//out.reserve(h.metaSize + sizeof(DataHeader));
 	char* hcp = reinterpret_cast<char*>(&h);
 	out.insert(out.end(), hcp, hcp + sizeof(DataHeader));
-	RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
+	sfor_pn<0,sizeof...(Ranges)>
+	    ( [&](auto i) {
+		vector<char> part = std::get<i>(mSpace)->data();
+		out.insert(out.end(), part.begin(), part.end());
+		return 0;
+	    } );
+	//RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
 	return out;
     }
 

src/include/ranges/range_helper.h

@@ -6,6 +6,14 @@ namespace MultiArrayTools
 {
     namespace RangeHelper
     {
+	template <class Range>
+	inline void resolveSetRange(std::shared_ptr<Range>& rp, const vector<std::shared_ptr<RangeBase> >& orig,
+				    size_t origpos, size_t size)
+	{
+	    assert(size == 1);
+	    rp = std::dynamic_pointer_cast<Range>( orig[origpos] ); // catch bad cast here!!
+	}
+
 	template <size_t N, class IndexPack>
 	void setIndexPack(IndexPack& iPack, size_t pos)
 	{
@@ -80,6 +88,26 @@ namespace MultiArrayTools
 		return std::get<N>(ipack)->pifor( step*std::get<N+1>(ba), exs);
 	    }
 	}
+
+	template <size_t N, class RangeTuple, typename... SIZET>
+	inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
+				     RangeTuple& rtp, size_t off, size_t size, SIZET... sizes)
+	{
+	    constexpr size_t tps = std::tuple_size<RangeTuple>::value;
+	    ::MultiArrayTools::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
+	    if constexpr(N < tps-1){
+		resolveRangeType<N+1>(orig, rtp, off+size, sizes...);
+	    }
+	}
+
+	template <size_t N, class RangeTuple>
+	inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
+				     RangeTuple& rtp, size_t off, size_t size)
+	{
+	    constexpr size_t tps = std::tuple_size<RangeTuple>::value;
+	    ::MultiArrayTools::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
+	}
+
 	
     } // namespace RangeHelper
 } // namespace MultiArrayTools

src/include/ranges/rpack_num.cc.h

@@ -1,5 +1,6 @@
 
 #include "rpack_num.h"
+
 namespace MultiArrayHelper
 {
     using namespace MultiArrayTools;
@@ -17,7 +18,7 @@ namespace MultiArrayHelper
     }
 
 
-    
+    /*
     template <class Range>
     inline void resolveSetRange(std::shared_ptr<Range>& rp, const vector<std::shared_ptr<RangeBase> >& orig,
 				size_t origpos, size_t size)
@@ -25,6 +26,7 @@ namespace MultiArrayHelper
 	assert(size == 1);
 	rp = std::dynamic_pointer_cast<Range>( orig[origpos] ); // catch bad cast here!!
     }
+    */
 
     template <class Range>
     inline void setRangeToVec(vector<std::shared_ptr<RangeBase> >& v,
@@ -41,23 +43,6 @@ namespace MultiArrayHelper
         return RPackNum<N-1>::makePos(iPtrTup, blockSize) + std::get<N>(iPtrTup)->pos() * std::get<N+1>(blockSize);
     }
 
-    template <size_t N>
-    template <class Pack, class IndexType, class... Indices>
-    void RPackNum<N>::swapIndices(Pack& ipack, const std::shared_ptr<IndexType>& nind,
-                                         const std::shared_ptr<Indices>&... ninds)
-    {
-        std::get<std::tuple_size<Pack>::value-N-1>(ipack) = nind;
-        RPackNum<N-1>::swapIndices(ipack, ninds...);
-    }
-
-    template <size_t N>
-    template <class Pack, class... Indices>
-    void RPackNum<N>::swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds)
-    {
-        std::get<N>(ipack) = std::get<N>(ninds);
-        RPackNum<N-1>::swapIndices(ipack, ninds);
-    }
-
     template <size_t N>
     template <class... Indices>
     size_t RPackNum<N>::blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
@@ -65,26 +50,6 @@ namespace MultiArrayHelper
         return std::get<sizeof...(Indices)-N>(pack)->max() * RPackNum<N-1>::blockSize(pack);
     }
 
-
-    template <size_t N>
-    template <class... Ranges>
-    inline void RPackNum<N>::RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-                                                vector<std::shared_ptr<RangeBase> >& v)
-    {
-        setRangeToVec(v, std::get<N>(rst));
-        RPackNum<N-1>::RangesToVec(rst, v);
-    }
-
-    template <size_t N>
-    template <class... Ranges>
-    inline void RPackNum<N>::RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-                                                vector<std::intptr_t>& v)
-    {
-        v[N] = reinterpret_cast<std::intptr_t>( std::get<N>(rst).get() );
-        RPackNum<N-1>::RangesToVec(rst, v);
-    }
-
-
     template <size_t N>
     template <class Index>
     inline void RPackNum<N>::getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx)
@@ -99,25 +64,6 @@ namespace MultiArrayHelper
         RPackNum<N-1>::getStepSizeX(ii, j, ss, sx);
     }
 
-    template <size_t N>
-    template <class RangeTuple, typename... SIZET>
-    inline void RPackNum<N>::resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
-                                                     RangeTuple& rtp, size_t off, size_t size, SIZET... sizes)
-    {
-        constexpr size_t tps = std::tuple_size<RangeTuple>::value;
-        resolveSetRange(std::get<tps-N-1>(rtp), orig, off, size);
-        RPackNum<N-1>::resolveRangeType(orig, rtp, off+size, sizes...);
-    }
-
-    template <size_t N>
-    template <class... Ranges>
-    inline bool RPackNum<N>::checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& p,
-                                                   const vector<std::intptr_t>& a)
-    {
-        return reinterpret_cast<std::intptr_t>( std::get<N>(p).get() ) == a[N] and
-            RPackNum<N-1>::checkIfCreated(p,a);
-    }
-
     template <size_t N>
     template <class MIndex>
     inline std::string RPackNum<N>::getStringMeta(const MIndex& mi)
@@ -125,16 +71,6 @@ namespace MultiArrayHelper
         return RPackNum<N-1>::getStringMeta(mi) + "," + mi.template getPtr<N>()->stringMeta();
     }
 
-    template <size_t N>
-    template <class... Ranges>
-    inline void RPackNum<N>::fillRangeDataVec(vector<char>& out,
-                                                     const std::tuple<std::shared_ptr<Ranges>...>& tp)
-    {
-        vector<char> part = std::get<sizeof...(Ranges)-N-1>(tp)->data();
-        out.insert(out.end(), part.begin(), part.end());
-        RPackNum<N-1>::fillRangeDataVec(out, tp);
-    }
-
     template <size_t N>
     template <size_t SIZE, class Range, class... Ranges>
     inline bool RPackNum<N>::compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec)
@@ -183,38 +119,12 @@ namespace MultiArrayHelper
         return std::get<0>(iPtrTup)->pos() * std::get<1>(blockSize);
     }
 
-    template <class Pack, class IndexType>
-    void RPackNum<0>::swapIndices(Pack& ipack, const std::shared_ptr<IndexType>& nind)
-    {
-        std::get<std::tuple_size<Pack>::value-1>(ipack) = nind;
-    }
-
-    template <class Pack, class... Indices>
-    void RPackNum<0>::swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds)
-    {
-        std::get<0>(ipack) = std::get<0>(ninds);
-    }
-
     template <class... Indices>
     size_t RPackNum<0>::blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
     {
         return 1;
     }
 
-    template <class... Ranges>
-    inline void RPackNum<0>::RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-                                                vector<std::intptr_t>& v)
-    {
-        v[0] = reinterpret_cast<std::intptr_t>( std::get<0>(rst).get() );;
-    }
-	
-    template <class... Ranges>
-    inline void RPackNum<0>::RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-                                                vector<std::shared_ptr<RangeBase> >& v)
-    {
-        setRangeToVec(v, std::get<0>(rst));
-    }
-
     template <class Index>
     inline void RPackNum<0>::getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx)
     {
@@ -227,35 +137,12 @@ namespace MultiArrayHelper
         sx *= max;
     }
 
-    template <class RangeTuple, typename... SIZET>
-    inline void RPackNum<0>::resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
-                                                     RangeTuple& rtp, size_t off, size_t size)
-    {
-        constexpr size_t tps = std::tuple_size<RangeTuple>::value;
-        resolveSetRange(std::get<tps-1>(rtp), orig, off, size);
-    }
-
-    template <class... Ranges>
-    inline bool RPackNum<0>::checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& p,
-                                                   const vector<std::intptr_t>& a)
-    {
-        return reinterpret_cast<std::intptr_t>( std::get<0>(p).get() ) == a[0];
-    }
-
     template <class MIndex>
     inline std::string RPackNum<0>::getStringMeta(const MIndex& mi)
     {
         return mi.template getPtr<0>()->stringMeta();
     }
 
-    template <class... Ranges>
-    inline void RPackNum<0>::fillRangeDataVec(vector<char>& out,
-                                                     const std::tuple<std::shared_ptr<Ranges>...>& tp)
-    {
-        vector<char> part = std::get<sizeof...(Ranges)-1>(tp)->data();
-        out.insert(out.end(), part.begin(), part.end());
-    }
-
     template <size_t SIZE, class Range>
     inline bool RPackNum<0>::compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec)
     {

src/include/ranges/rpack_num.h

@@ -106,43 +106,16 @@ namespace MultiArrayHelper
 	static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
 				     const std::array<size_t,sizeof...(Indices)+1>& blockSize);
 
-	template <class Pack, class IndexType, class... Indices>
-	static void swapIndices(Pack& ipack, const std::shared_ptr<IndexType>& nind,
-				const std::shared_ptr<Indices>&... ninds);
-
-        template <class Pack, class... Indices>
-	static void swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds);
-
 	template <class... Indices>
 	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack);
 
 
-	template <class... Ranges>
-	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-				       vector<std::shared_ptr<RangeBase> >& v);
-
-	template <class... Ranges>
-	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-				       vector<std::intptr_t>& v);
-
 	template <class Index>
 	static inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx);
 
-	template <class RangeTuple, typename... SIZET>
-	static inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
-					    RangeTuple& rtp, size_t off, size_t size, SIZET... sizes);
-
-	template <class... Ranges>
-	static inline bool checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& p,
-					  const vector<std::intptr_t>& a);
-
 	template <class MIndex>
 	static inline std::string getStringMeta(const MIndex& mi);
 
-	template <class... Ranges>
-	static inline void fillRangeDataVec(vector<char>& out,
-					    const std::tuple<std::shared_ptr<Ranges>...>& tp);
-
 	template <size_t SIZE, class Range, class... Ranges>
 	static inline bool compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec);
 
@@ -168,41 +141,15 @@ namespace MultiArrayHelper
 	static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
 				     const std::array<size_t,sizeof...(Indices)+1>& blockSize);
 
-	template <class Pack, class IndexType>
-	static void swapIndices(Pack& ipack, const std::shared_ptr<IndexType>& nind);
-
-        template <class Pack, class... Indices>
-	static void swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds);
-
 	template <class... Indices>
 	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack);
 
-	template <class... Ranges>
-	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-				       vector<std::intptr_t>& v);
-	
-	template <class... Ranges>
-	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-				       vector<std::shared_ptr<RangeBase> >& v);
-
 	template <class Index>
 	static inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx);
 
-	template <class RangeTuple, typename... SIZET>
-	static inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
-					    RangeTuple& rtp, size_t off, size_t size);
-
-	template <class... Ranges>
-	static inline bool checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& p,
-					  const vector<std::intptr_t>& a);
-
         template <class MIndex>
 	static inline std::string getStringMeta(const MIndex& mi);
 
-	template <class... Ranges>
-	static inline void fillRangeDataVec(vector<char>& out,
-					    const std::tuple<std::shared_ptr<Ranges>...>& tp);
-
 	template <size_t SIZE, class Range>
 	static inline bool compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec);