some awkward hacks reg const stuff... should refactor this

src/multi_array.cc

@@ -62,7 +62,7 @@ namespace MultiArrayTools
     template <class... NameTypes>
     ConstMultiArrayOperationRoot<T,Range> MultiArrayBase<T,Range>::operator()(const NameTypes&... str) const
     {
-	return MultiArrayOperationRoot<T,Range>(*this, Name("master", str...));
+	return ConstMultiArrayOperationRoot<T,Range>(*this, Name("master", str...));
     }
 
     template <typename T, class Range>
@@ -158,6 +158,12 @@ namespace MultiArrayTools
 	return mCont[ i.pos() ];
     }
 
+    template <typename T, class Range>
+    bool MultiArray<T,Range>::isConst() const
+    {
+	return false;
+    }
+    
     template <typename T, class Range>
     bool MultiArray<T,Range>::isSlice() const
     {

src/multi_array.h

@@ -38,6 +38,8 @@ namespace MultiArrayTools
 
 	virtual const Range& range() const;
 
+	virtual bool isConst() const = 0;
+	
 	template <class... NameTypes>
 	MultiArrayOperationRoot<T,Range> operator()(const NameTypes&... str);
 
@@ -79,6 +81,7 @@ namespace MultiArrayTools
 	T& operator[](const typename Range::IndexType& i) override;
 	const T& operator[](const typename Range::IndexType& i) const override;
 
+	virtual bool isConst() const override;	
 	virtual bool isSlice() const override;
 
 	//	virtual void manipulate(ManipulatorBase<T>& mb,

src/multi_array_operation.cc

@@ -40,7 +40,7 @@ namespace MultiArrayTools
 	IndexType& iref = dynamic_cast<IndexType&>(*MAOB::mIibPtr);
 	//CHECK;
 	const size_t endPos = mArrayRef.end().pos();
-	std::cout << "assignment: " << endPos << "elements" << std::endl;
+	std::cout << "assignment: " << endPos << " elements" << std::endl;
 	for(iref = mArrayRef.begin().pos(); iref != mArrayRef.end(); ++iref){
 	    std::cout << iref.pos() << '\r' << std::flush;
 	    get() = in.get();
@@ -59,13 +59,14 @@ namespace MultiArrayTools
 	return *this;
     }
 
+    
     template <typename T, class Range>
     template <class RangeX>
     const MultiArrayOperationRoot<T,Range>&
     MultiArrayOperationRoot<T,Range>::makeConstSlice(const MultiArrayOperationRoot<T,RangeX>& in)
     {
-	ConstSlice<T,Range,RangeX>& sl = dynamic_cast<ConstSlice<T,Range,RangeX>&>( mArrayRef );
+	Slice<T,Range,RangeX>& sl = dynamic_cast<Slice<T,Range,RangeX>&>( mArrayRef );
-	sl.set(in.mArrayRef, name(), dynamic_cast<const typename RangeX::IndexType&>( in.index() ), in.name());
+	sl.setConst(in.mArrayRef, name(), dynamic_cast<const typename RangeX::IndexType&>( in.index() ), in.name());
 	return *this;
     }
     
@@ -91,6 +92,7 @@ namespace MultiArrayTools
     MultiArrayOperationRoot<T,Range>::operator=(const MultiArrayOperationRoot<T,Range>& in)
     {
 	performAssignment(in);
+	freeIndex();
 	return *this;
     }
 
@@ -104,6 +106,7 @@ namespace MultiArrayTools
 	    return makeSlice(in);
 	}
 	performAssignment(in);
+	freeIndex();
 	return *this;
     }
 
@@ -117,9 +120,11 @@ namespace MultiArrayTools
 	    return makeSlice(in);
 	}
 	performAssignment(in);
+	freeIndex();
 	return *this;
     }
 
+    
     template <typename T, class Range>
     template <class Range2>
     const MultiArrayOperationRoot<T,Range>&
@@ -131,6 +136,7 @@ namespace MultiArrayTools
 	    return makeConstSlice(in);
 	}
 	performAssignment(in);
+	freeIndex();
 	return *this;
     }
     
@@ -146,6 +152,7 @@ namespace MultiArrayTools
 	    assert(0);
 	}
    	performAssignment(in);
+	freeIndex();
 	return *this;
     }
 
@@ -302,16 +309,27 @@ namespace MultiArrayTools
      *   ConstMultiArrayOperationBase     *
      **************************************/
 
+    /*
     template <typename T, class Range>
     template <class RangeX>
     const ConstMultiArrayOperationRoot<T,Range>&
-    ConstMultiArrayOperationRoot<T,Range>::makeConstSlice(const ConstMultiArrayOperationRoot<T,RangeX>& in) const
+    ConstMultiArrayOperationRoot<T,Range>::makeConstSlice(const ConstMultiArrayOperationRoot<T,RangeX>& in)
     {
 	ConstSlice<T,Range,RangeX>& sl = dynamic_cast<ConstSlice<T,Range,RangeX>&>( mArrayRef );
 	sl.set(in.mArrayRef, name(), dynamic_cast<const typename RangeX::IndexType&>( in.index() ), in.name());
 	return *this;
     }
 
+    template <typename T, class Range>
+    template <class RangeX>
+    const ConstMultiArrayOperationRoot<T,Range>&
+    ConstMultiArrayOperationRoot<T,Range>::makeConstSlice(const MultiArrayOperationRoot<T,RangeX>& in)
+    {
+	ConstSlice<T,Range,RangeX>& sl = dynamic_cast<ConstSlice<T,Range,RangeX>&>( mArrayRef );
+	sl.set(in.mArrayRef, name(), dynamic_cast<const typename RangeX::IndexType&>( in.index() ), in.name());
+	return *this;
+    }
+    */
     
     // CONST SLICE !!!!!
     
@@ -342,6 +360,7 @@ namespace MultiArrayTools
 	//mIndex.name(nm);
     }
 
+    /*
     template <typename T, class Range>
     const ConstMultiArrayOperationRoot<T,Range>&
     ConstMultiArrayOperationRoot<T,Range>::operator=(const ConstMultiArrayOperationRoot<T,Range>& in)
@@ -368,6 +387,20 @@ namespace MultiArrayTools
 	return *this;
     }
 
+    template <typename T, class Range>
+    template <class Range2>
+    const ConstMultiArrayOperationRoot<T,Range>&
+    ConstMultiArrayOperationRoot<T,Range>::operator=(const MultiArrayOperationRoot<T,Range2>& in)
+    {
+	//CHECK;
+	if(mArrayRef.isSlice() and not mArrayRef.isInit()){
+	    //CHECK;
+	    return makeConstSlice(in);
+	}
+	assert(0);
+	return *this;
+    }
+    */
     template <typename T, class Range>
     template <class Operation, class... MAOps>
     MultiArrayOperation<T,Operation,ConstMultiArrayOperationRoot<T,Range>, MAOps...>
@@ -444,7 +477,6 @@ namespace MultiArrayTools
     template <typename T, class Range>
     const T& ConstMultiArrayOperationRoot<T,Range>::get() const
     {
-	//return mArrayRef[mIndex];
 	return mArrayRef[*dynamic_cast<IndexType*>(MAOB::mIibPtr)];
     }
 

src/multi_array_operation.h

@@ -59,6 +59,7 @@ namespace MultiArrayTools
 	template <class Range2>
 	MultiArrayOperationRoot& operator=(MultiArrayOperationRoot<T,Range2>& in);
 
+	
 	template <class Range2>
 	const MultiArrayOperationRoot& operator=(const MultiArrayOperationRoot<T,Range2>& in);
 	
@@ -123,6 +124,9 @@ namespace MultiArrayTools
 	template <typename U, class RangeX>
 	friend class MultiArrayOperationRoot;
 
+	template <typename U, class RangeX>
+	friend class ConstMultiArrayOperationRoot;
+	
     protected:
 
 	void performAssignment(const MultiArrayOperationBase<T>& in);
@@ -130,6 +134,7 @@ namespace MultiArrayTools
 	template <class RangeX>
 	MultiArrayOperationRoot& makeSlice(MultiArrayOperationRoot<T,RangeX>& in);
 
+	
 	template <class RangeX>
 	const MultiArrayOperationRoot& makeConstSlice(const MultiArrayOperationRoot<T,RangeX>& in);
 	
@@ -150,11 +155,16 @@ namespace MultiArrayTools
 	ConstMultiArrayOperationRoot(const MultiArrayBase<T,Range>& ma, const Name& nm);
 	ConstMultiArrayOperationRoot(const MultiArrayOperationRoot<T,Range>& in);
 
+	/*
 	const ConstMultiArrayOperationRoot& operator=(const ConstMultiArrayOperationRoot& in);
 
 	template <class Range2>
 	const ConstMultiArrayOperationRoot& operator=(const ConstMultiArrayOperationRoot<T,Range2>& in);
 
+	template <class Range2>
+	const ConstMultiArrayOperationRoot& operator=(const MultiArrayOperationRoot<T,Range2>& in);
+	*/
+
 	//template <class Operation, class... MAOps>
 	//MultiArrayOperation<T,Operation,MultiArrayOperationRoot<T,Range>, MAOps...>
 	//operator()(Operation& op, const MAOps&... secs) const;
@@ -196,14 +206,22 @@ namespace MultiArrayTools
 
 	const MultiArrayBase<T,Range>& getCont() const { return mArrayRef; }
 	
+	template <typename U, class RangeX>
+	friend class ConstMultiArrayOperationRoot;
+	
 	template <typename U, class RangeX>
 	friend class MultiArrayOperationRoot;
 	
     protected:
 
+	/*
 	template <class RangeX>
-	const ConstMultiArrayOperationRoot& makeConstSlice(const ConstMultiArrayOperationRoot<T,RangeX>& in) const;
+	const ConstMultiArrayOperationRoot& makeConstSlice(const ConstMultiArrayOperationRoot<T,RangeX>& in);
 
+	template <class RangeX>
+	const ConstMultiArrayOperationRoot& makeConstSlice(const MultiArrayOperationRoot<T,RangeX>& in);
+	*/
+	// const
 	MultiArrayBase<T,Range> const& mArrayRef;
 	mutable IndexType mIndex;
 	Name mNm;

src/slice.cc

@@ -23,6 +23,8 @@ namespace MultiArrayTools
 				     const Name& MANm) // for correct linkage)
     {
 	MAB::mInit = true;
+	mOwnName = ownNm;
+	mMAName = MANm;
 	mMultiArrayPtr = &multiArrayRef;
 	mMAIdx = MAIdx;
 	mOwnIdx = MAB::mRange->begin();
@@ -31,6 +33,24 @@ namespace MultiArrayTools
 	mMAIdx.linkTo(&mOwnIdx);
     }
 
+    template <typename T, class Range, class MARange>
+    void Slice<T,Range,MARange>::setConst(const MultiArrayBase<T,MARange>& multiArrayRef,
+					  const Name& ownNm, // for correct linkage
+					  const typename MARange::IndexType& MAIdx, // for desired slice position
+					  const Name& MANm) // for correct linkage)
+    {
+	MAB::mInit = true;
+	mOwnName = ownNm;
+	mMAName = MANm;
+	mConstMultiArrayPtr = &multiArrayRef;
+	mMAIdx = MAIdx;
+	mOwnIdx = MAB::mRange->begin();
+	mMAIdx.name(MANm);
+	mOwnIdx.name(ownNm);
+	mMAIdx.linkTo(&mOwnIdx);
+    }
+
+    
     template <typename T, class Range, class MARange>
     auto Slice<T,Range,MARange>::begin() const -> decltype(Range().begin())
     {
@@ -59,22 +79,54 @@ namespace MultiArrayTools
 	return (*mMultiArrayPtr)[ mMAIdx ];
     }
     
+    template <typename T, class Range, class MARange>
+    bool Slice<T,Range,MARange>::isConst() const
+    {
+	return false;
+    }
+    
     template <typename T, class Range, class MARange>
     ConstSlice<T,Range,MARange>::
     ConstSlice(const Range& range) :
 	MultiArrayBase<T,Range>(range) {}
 
+    template <typename T, class Range, class MARange>
+    ConstSlice<T,Range,MARange>::
+    ConstSlice(const Slice<T,Range,MARange>& slice) :
+	MultiArrayBase<T,Range>(slice.range()),
+	mOwnIdx(slice.mOwnIdx),
+	mMAIdx(slice.mMAIdx)
+    {
+	if(slice.mInit){
+	    MAB::mInit = true;
+	    mMultiArrayPtr = slice.mConstMultiArrayPtr;
+	    mMAIdx = slice.mMAIdx;
+	    mOwnIdx = MAB::mRange->begin();
+	    mMAIdx.name(slice.mMAName);
+	    mOwnIdx.name(slice.mOwnName);
+	    mMAIdx.linkTo(&mOwnIdx);
+	}
+    }
+	
+    
     template <typename T, class Range, class MARange>
     bool ConstSlice<T,Range,MARange>::isSlice() const
     {
 	return true;
     }
 
+    template <typename T, class Range, class MARange>
+    bool ConstSlice<T,Range,MARange>::isConst() const
+    {
+	return true;
+    }
+    
+    /*
     template <typename T, class Range, class MARange>
     void ConstSlice<T,Range,MARange>::set(const MultiArrayBase<T,MARange>& multiArrayRef,
 					  const Name& ownNm, // for correct linkage
 					  const typename MARange::IndexType& MAIdx, // for desired slice position
-					  const Name& MANm) // for correct linkage)
+					  const Name& MANm) const // for correct linkage)
     {
 	MAB::mInit = true;
 	mMultiArrayPtr = &multiArrayRef;
@@ -84,7 +136,7 @@ namespace MultiArrayTools
 	mOwnIdx.name(ownNm);
 	mMAIdx.linkTo(&mOwnIdx);
     }
-
+    */
     template <typename T, class Range, class MARange>
     auto ConstSlice<T,Range,MARange>::begin() const -> decltype(Range().begin())
     {

src/slice.h

@@ -33,17 +33,29 @@ namespace MultiArrayTools
 	virtual auto end() const -> decltype(Range().end()) override;
 
 	virtual bool isSlice() const override;
+	virtual bool isConst() const override;
 	
 	void set(MultiArrayBase<T,MARange>& multiArrayRef,
 		 const Name& ownNm,
 		 const typename MARange::IndexType& MAIdx,
 		 const Name& MANm);
 
+	void setConst(const MultiArrayBase<T,MARange>& multiArrayRef,
+		      const Name& ownNm,
+		      const typename MARange::IndexType& MAIdx,
+		      const Name& MANm); 
+
+	template <typename U, class RangeX, class MARangeX>	
+	friend class ConstSlice;
+	
     private:
 
+	MultiArrayBase<T,MARange> const* mConstMultiArrayPtr = nullptr;
 	MultiArrayBase<T,MARange>* mMultiArrayPtr = nullptr;
 	mutable typename Range::IndexType mOwnIdx;
 	mutable typename MARange::IndexType mMAIdx;
+	Name mOwnName;
+	Name mMAName;
     };
 
     template <typename T, class Range, class MARange/*, class Index*/>
@@ -54,6 +66,7 @@ namespace MultiArrayTools
 	typedef MultiArrayBase<T,Range> MAB;
 
 	ConstSlice(const Range& range);
+	ConstSlice(const Slice<T,Range,MARange>& slice);
 
 	virtual T& operator[](const typename Range::IndexType& i) override;
 	virtual const T& operator[](const typename Range::IndexType& i) const override;
@@ -65,12 +78,14 @@ namespace MultiArrayTools
 	virtual auto end() const -> decltype(Range().end()) override;
 
 	virtual bool isSlice() const override;
+	virtual bool isConst() const override;
 	
+	/*
 	void set(const MultiArrayBase<T,MARange>& multiArrayRef,
 		 const Name& ownNm,
 		 const typename MARange::IndexType& MAIdx,
-		 const Name& MANm); 
+		 const Name& MANm) const; 
-	
+	*/
     private:
 
 	// !!!