im com (block type scanning routines...)

src/container_range.cc

@@ -41,6 +41,12 @@ namespace MultiArrayTools
 	IB::mPos = PackNum<sizeof...(Indices)-1>::makePos(mIPack);
     }
 
+    template <class... Indices>
+    IndexType ContainerIndex<Indices...>::type() const
+    {
+	return IndexType::CONT;
+    }
+    
     template <class... Indices>
     ContainerIndex<Indices...>& ContainerIndex<Indices...>::operator++()
     {
@@ -117,6 +123,17 @@ namespace MultiArrayTools
 	return std::get<N>( mIPack );
     }
 
+    template <class... Indices>
+    std::shared_ptr<const IndexBase> ContainerIndex<Indices...>::getPtr(size_t n) const
+    {
+	if(n >= sizeof...(Indices)){
+	    assert(0);
+	    // throw !!
+	}
+	ContainerIndex<Indices...> const* t = this;
+	return PackNum<sizeof...(Indices)-1>::getIndexPtr(*t, n);
+    }
+    
     template <class... Indices>
     bool ContainerIndex<Indices...>::first() const
     {

src/container_range.h

@@ -38,6 +38,8 @@ namespace MultiArrayTools
 	template <class MRange>
 	ContainerIndex(const std::shared_ptr<MRange>& range);
 
+	virtual IndexType type() const override;
+	
 	virtual ContainerIndex& operator++() override;
 	virtual ContainerIndex& operator--() override;
 	virtual ContainerIndex& operator=(size_t pos) override;
@@ -58,6 +60,8 @@ namespace MultiArrayTools
 	template <size_t N>
 	auto getPtr() const -> decltype( std::get<N>( mIPack ) )&;
 
+	virtual std::shared_ptr<const IndexBase> getPtr(size_t n) const override;
+	
 	ContainerIndex& operator()(const std::shared_ptr<Indices>&... inds); // control via external indices
 
 	ContainerIndex& operator()(); // -> sync; just to shorten the code

src/index_base.h

@@ -20,6 +20,12 @@ namespace MultiArrayTools
 	return id;
     }
 
+    enum class IndexType{
+	SINGLE = 0,
+	MULTI = 1,
+	CONT = 2	
+    };    
+    
     class IndexBase
     {
     public:
@@ -32,6 +38,8 @@ namespace MultiArrayTools
 	IndexBase(const std::shared_ptr<RangeBase>& range, size_t pos);
 	virtual ~IndexBase() = default; 
 
+	virtual IndexType type() const = 0;
+	
 	virtual IndexBase& operator=(size_t pos) = 0;
 	virtual IndexBase& operator++() = 0;
 	virtual IndexBase& operator--() = 0;
@@ -46,6 +54,8 @@ namespace MultiArrayTools
 	virtual bool last() const = 0;
 	virtual bool first() const = 0;
 
+	virtual std::shared_ptr<const IndexBase> getPtr(size_t n) const = 0;
+	
 	virtual operator size_t() const;
 
 	virtual std::string id() const { return std::to_string( mId ); }

src/multi_array_operation.cc

@@ -9,6 +9,42 @@ namespace MultiArrayTools
 	using namespace MultiArrayHelper;
     }
 
+    void seekIndexInst(std::shared_ptr<const IndexBase> i, std::vector<std::shared_ptr<const IndexBase> >& ivec)
+    {
+	for(size_t inum = 0; inum != i->range()->dim(); ++inum){
+	    auto ii = i->getPtr(inum);
+	    if(ii->type() == IndexType::MULTI){
+		seekIndexInst(ii, ivec);
+	    }
+	    ivec.push_back(ii);
+	}
+    }
+    
+    BlockType getBlockType(std::shared_ptr<const IndexBase> i,
+			   std::shared_ptr<const IndexBase> j, bool first)
+    {
+	BlockType out = BlockType::VALUE;
+	for(size_t inum = 0; inum != i->range()->dim(); ++inum){
+	    if(ii == j){
+		if(inum == 0){
+		    out = BlockType::BLOCK;
+		}
+		else {
+		    out = BlockType::SPLIT;
+		}
+		continue;
+	    }
+	    
+	    if(ii->type() == IndexType::MULTI){		
+		BlockType tmp = getBlockType(ii, j, ivec);
+		if(tmp != BlockType::VALUE){
+		    out = tmp;
+		}
+	    }
+	}
+	return out;
+    }
+    
     /*********************************
      *   MultiArrayOperationBase     *
      *********************************/
@@ -87,6 +123,20 @@ namespace MultiArrayTools
 	return mArrayRef.data()[ mIndex->pos() ];
     }
 
+    template <typename T, class... Ranges>
+    std::vector<BlockType> OperationMaster<T,Ranges...>::block(const std::shared_ptr<IndexBase>& blockIndex) const
+    {
+	// seek index with smallest number of SPLITs !!!
+	
+    }
+
+    template <typename T, class... Ranges>
+    OperationMaster<T,Ranges...>& OperationMaster<T,Ranges...>::block() const
+    {
+	mBlockPtr->set( &mArrayRef[ (*mIndex) ] );
+	return *this;
+    }
+    
     /****************************
      *   ConstOperationRoot     *
      ****************************/
@@ -104,7 +154,21 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     const BlockBase<T>& ConstOperationRoot<T,Ranges...>::get() const
     {
-	return mArrayRef[ (*mIndex)() ];
+	block();
+	return *mBlockPtr;
+    }
+
+    template <typename T, class... Ranges>
+    std::vector<BlockType> ConstOperationRoot<T,Ranges...>::block(const std::shared_ptr<IndexBase>& blockIndex) const
+    {
+	// !!!
+    }
+
+    template <typename T, class... Ranges>
+    ConstOperationRoot<T,Ranges...>& ConstOperationRoot<T,Ranges...>::block() const
+    {
+	mBlockPtr->set( &mArrayRef[ (*mIndex)() ] );
+	return *this;
     }
     
     /***********************
@@ -130,13 +194,28 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     const BlockBase<T>& OperationRoot<T,Ranges...>::get() const
     {
-	return mArrayRef[ (*mIndex)() ];
+	block();
+	return *mBlockPtr;
     }
 
     template <typename T, class... Ranges>
     BlockBase<T>& OperationRoot<T,Ranges...>::get()
     {
-	return mArrayRef[ (*mIndex)() ];
+	block();
+	return *mBlockPtr; // issue: const !!!
+    }
+
+    template <typename T, class... Ranges>
+    std::vector<BlockType> OperationRoot<T,Ranges...>::block(const std::shared_ptr<IndexBase>& blockIndex) const
+    {
+	// !!!
+    }
+
+    template <typename T, class... Ranges>
+    OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::block() const
+    {
+	mBlockPtr->set( &mArrayRef[ (*mIndex)() ] );
+	return *this;
     }
     
     /***********************
@@ -154,4 +233,18 @@ namespace MultiArrayTools
 	mRes = PackNum<sizeof...(Ops)-1>::template unpackArgs<T,OpFunction>(mOps);
 	return mRes;
     }
+
+    template <typename T, class... Ranges>
+    std::vector<BlockType> Operation<T,Ranges...>::block(const std::shared_ptr<IndexBase>& blockIndex) const
+    {
+	// !!!
+    }
+
+    template <typename T, class... Ranges>
+    Operation<T,Ranges...>& Operation<T,Ranges...>::block() const
+    {
+	mBlockPtr->set( &mArrayRef[ (*mIndex)() ] );
+	return *this;
+    }
+
 }

src/multi_array_operation.h

@@ -30,6 +30,11 @@ namespace MultiArrayTools
      * 
      */
 
+    void seekIndexInst(std::shared_ptr<const IndexBase> i, std::vector<std::shared_ptr<const IndexBase> >& ivec);
+
+    BlockType getBlockType(std::shared_ptr<const IndexBase> i,
+			   std::shared_ptr<const IndexBase> j, bool first);
+    
     template <typename T>
     class OperationBase
     {
@@ -40,7 +45,9 @@ namespace MultiArrayTools
 	OperationBase() = default;
 	virtual ~OperationBase() = default;
 
-	virtual OperationBase& block(const std::shared_ptr<IndexBase>& blockIndex) = 0;
+	 // init block, return resulting type (BLOCK, VALUE, SPLIT)
+	virtual std::vector<BlockType> block(const std::shared_ptr<IndexBase>& blockIndex) const = 0;
+	virtual OperationBase& block() const = 0; // update block
 	
 	//virtual size_t argNum() const = 0;
 	virtual const BlockBase<T>& get() const = 0;
@@ -104,6 +111,9 @@ namespace MultiArrayTools
 	virtual BlockBase<T>& get() override;
 	virtual const BlockBase<T>& get() const override;
 
+	virtual std::vector<BlockType> block(const std::shared_ptr<IndexBase>& blockIndex) const override;
+	virtual OperationMaster& block() const override;
+	
     protected:
 
 	//void performAssignment(const OperationBase<T>& in);
@@ -130,6 +140,9 @@ namespace MultiArrayTools
 	
 	virtual const BlockBase<T>& get() const override;
 
+	virtual std::vector<BlockType> block(const std::shared_ptr<IndexBase>& blockIndex) const override;
+	virtual ConstOperationRoot& block() const override;
+	
     protected:
 	
 	MultiArrayBase<T,Ranges...> const& mArrayRef;
@@ -156,6 +169,9 @@ namespace MultiArrayTools
 	virtual const BlockBase<T>& get() const override;
 	virtual BlockBase<T>& get() override;
 
+	virtual std::vector<BlockType> block(const std::shared_ptr<IndexBase>& blockIndex) const override;
+	virtual OperationRoot& block() const override;
+	
     protected:
 	
 	MutableMultiArrayBase<T,Ranges...>& mArrayRef;
@@ -177,6 +193,9 @@ namespace MultiArrayTools
 	
 	virtual const BlockBase<T>& get() const override;
 
+	virtual std::vector<BlockType> block(const std::shared_ptr<IndexBase>& blockIndex) const override;
+	virtual Operation& block() const override;
+	
     protected:
 	std::tuple<Ops...> mOps;
 	mutable BlockResult<T> mRes;

src/multi_range.cc

@@ -49,6 +49,12 @@ namespace MultiArrayTools
 	IB::mPos = PackNum<sizeof...(Indices)-1>::makePos(mIPack);
     }
 
+    template <class... Indices>
+    IndexType MultiIndex<Indices...>::type() const
+    {
+	return IndexType::MULTI;
+    }
+    
     template <class... Indices>
     MultiIndex<Indices...>& MultiIndex<Indices...>::operator++()
     {
@@ -124,6 +130,17 @@ namespace MultiArrayTools
 	return PackNum<sizeof...(Indices)-1>::getIndex(*t, n);
     }
 
+    template <class... Indices>
+    std::shared_ptr<const IndexBase> MultiIndex<Indices...>::getPtr(size_t n) const
+    {
+	if(n >= sizeof...(Indices)){
+	    assert(0);
+	    // throw !!
+	}
+	MultiIndex<Indices...> const* t = this;
+	return PackNum<sizeof...(Indices)-1>::getIndexPtr(*t, n);
+    }
+
     template <class... Indices>
     typename MultiIndex<Indices...>::MetaType MultiIndex<Indices...>::meta() const
     {

src/multi_range.h

@@ -39,6 +39,8 @@ namespace MultiArrayTools
 	template <class MRange>
 	MultiIndex(const std::shared_ptr<MRange>& range);
 
+	virtual IndexType type() const override;
+	
 	virtual MultiIndex& operator++() override;
 	virtual MultiIndex& operator--() override;
 	virtual MultiIndex& operator=(size_t pos) override;
@@ -56,6 +58,7 @@ namespace MultiArrayTools
 	auto getPtr() const -> decltype( std::get<N>( mIPack ) )&;
 	
 	const IndexBase& get(size_t n) const;
+	virtual std::shared_ptr<const IndexBase> getPtr(size_t n) const override;
 	
         virtual MetaType meta() const override;
 	virtual MultiIndex& at(const MetaType& metaPos) override;

src/pack_num.h

@@ -21,7 +21,7 @@ namespace MultiArrayHelper
 	static IndexBase& getIndex(IndexType& in, size_t n)
 	{
 	    if(n == N){
-		return in.getIndex<N>();
+		return in.template get<N>();
 	    }
 	    else {
 		return PackNum<N-1>::getIndex(in, n);
@@ -32,13 +32,24 @@ namespace MultiArrayHelper
 	static const IndexBase& getIndex(const IndexType& in, size_t n)
 	{
 	    if(n == N){
-		return in.getIndex<N>();
+		return in.template get<N>();
 	    }
 	    else {
 		return PackNum<N-1>::getIndex(in, n);
 	    }
 	}
 
+	template <class IndexType>
+	static std::shared_ptr<const IndexBase> getIndexPtr(const IndexType& in, size_t n)
+	{
+	    if(n == N){
+		return in.template getPtr<N>();
+	    }
+	    else {
+		return PackNum<N-1>::getIndexPtr(in, n);
+	    }
+	}
+	
 	template <class... Indices>
 	static inline void pp(std::tuple<std::shared_ptr<Indices>...>& ip)
 	{
@@ -163,13 +174,19 @@ namespace MultiArrayHelper
 	template <class MultiIndex>
 	static IndexBase& getIndex(MultiIndex& in, size_t n)
 	{
-	    return in.getIndex<0>();
+	    return in.template get<0>();
 	}
 	
 	template <class MultiIndex>
 	static const IndexBase& getIndex(const MultiIndex& in, size_t n)
 	{
-	    return in.getIndex<0>();
+	    return in.template get<0>();
+	}
+
+	template <class IndexType>
+	static std::shared_ptr<const IndexBase> getIndexPtr(const IndexType& in, size_t n)
+	{
+	    return in.template getPtr<0>();
 	}
 	
 	template <class... Indices>

src/single_range.cc

@@ -11,6 +11,12 @@ namespace MultiArrayTools
     SingleIndex<U,TYPE>::SingleIndex(const std::shared_ptr<SingleRange<U,TYPE> >& range) :
 	IndexInterface<U>(range, 0) {}
 
+    template <typename U, RangeType TYPE>
+    IndexType SingleIndex<U,TYPE>::type() const
+    {
+	return IndexType::SINGLE;
+    }
+	
     template <typename U, RangeType TYPE>
     SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator=(size_t pos)
     {
@@ -63,6 +69,12 @@ namespace MultiArrayTools
 	return IB::mPos == 0;
     }
 
+    template <typename U, RangeType TYPE>
+    std::shared_ptr<const IndexBase> SingleIndex<U,TYPE>::getPtr(size_t n) const
+    {
+	return std::shared_ptr<const IndexBase>();
+    }
+    
     /********************
      *   SingleRange    *
      ********************/

src/single_range.h

@@ -27,6 +27,8 @@ namespace MultiArrayTools
 	
 	SingleIndex(const std::shared_ptr<SingleRange<U,TYPE> >& range);
 
+	virtual IndexType type() const override;
+	
 	virtual SingleIndex& operator=(size_t pos) override;
 	virtual SingleIndex& operator++() override;
 	virtual SingleIndex& operator--() override;
@@ -38,6 +40,8 @@ namespace MultiArrayTools
 	virtual bool last() const override;
 	virtual bool first() const override;
 
+	virtual std::shared_ptr<const IndexBase> getPtr(size_t n) const override;
+	
 	virtual std::string id() const override { return std::string("sin") + std::to_string(IB::mId); }
     };