...

src/multi_range.h

@@ -96,11 +96,6 @@ namespace MultiArrayTools
 	typedef typename RangeBase<MultiIndex<typename Ranges::IndexType...> >::IndexType
 	IndexType;
 
-	DEFAULT_MEMBERS(MultiRange);
-
-	MultiRange(const std::shared_ptr<Ranges>&... rs);
-	MultiRange(const SpaceType& space);
-	
 	static const size_t dim = sizeof...(Ranges);
 	
 	template <size_t N> // !!! return ref to range, not the corresp. shared ptr
@@ -122,6 +117,14 @@ namespace MultiArrayTools
 	virtual std::shared_ptr<IndefinitIndexBase> indexInstance() const override;
 	
     protected:
+
+	MultiRange() = delete;
+	MultiRange(const MultiRange& in) = delete;
+	MultiRange& operator=(const MultiRange& in) = delete;
+	
+	MultiRange(const std::shared_ptr<Ranges>&... rs);
+	MultiRange(const SpaceType& space);
+	
 	SpaceType mSpace;
     };
     

src/range_base.cc

@@ -87,6 +87,7 @@ namespace MultiArrayTools
 	mType = RangeType::NIL;
     }
 
+    
     /******************
      *   RangeBase    *
      ******************/

src/range_base.h

@@ -61,12 +61,17 @@ namespace MultiArrayTools
 
 	virtual ~IndefinitRangeBase() = default;
 
-	static std::shared_ptr<IndefinitRangeBase> makeInstance(const MultiRangeType& mrt); // !!!
-	
 	virtual size_t size() const = 0;
 	virtual bool isSubRange() const = 0;
 	virtual MultiRangeType type() const = 0;
 	virtual std::shared_ptr<IndefinitIndexBase> indexInstance() const = 0;
+
+    protected:
+	// only constructable via Factory
+	
+	IndefinitRangeBase() = default;
+	IndefinitRangeBase(const IndefinitRangeBase& in) = delete;
+	IndefinitRangeBase& operator=(const IndefinitRangeBase& in) = delete;
     };
     
     template <class Index>
@@ -81,6 +86,11 @@ namespace MultiArrayTools
 	virtual bool isSubRange() const override;
 
 	virtual std::shared_ptr<IndefinitIndexBase> indexInstance() const override;
+
+    protected:
+	RangeBase() = default;
+	RangeBase(const RangeBase& in) = delete;
+	RangeBase& operator=(const RangeBase& in) = delete;
     };
   
     //template <class Range>

src/range_factory.cc

@@ -0,0 +1,8 @@
+// -*- C++ -*-
+
+#include "range_factory.h"
+
+namespace MultiArrayTools
+{
+    
+} //namespace MultiArrayTools

src/range_factory.h

@@ -0,0 +1,26 @@
+// -*- C++ -*-
+
+#ifndef __range_factory_h__
+#define __range_factory_h__
+
+#include <cstdlib>
+#include <memory>
+#include "base_def.h"
+
+namespace MultiArrayTools
+{
+    
+    class RangeFactoryBase
+    {
+    public:
+	DEFAULT_MEMBERS(RangeFactoryBase);
+	virtual std::shared_ptr<IndefinitRangeBase> create() const = 0;
+	
+    };
+
+    
+} //namespace MultiArrayTools
+
+#include "range_factory.cc"
+
+#endif

src/single_range.cc

@@ -3,6 +3,134 @@
 
 namespace MultiArrayTools
 {
+    /******************
+     *  SingleIndex   *	     
+     ******************/
+
+    template <typename U, RangeType TYPE>
+    SingleIndex<U,TYPE>::SingleIndex(const U& upos,
+				     std::shared_ptr<const RangeBase<SingleIndex<U,TYPE> > >& rangePtr) :
+	IndexBase<SingleIndex<U,TYPE> >(rangePtr)
+    {
+	IIB::setPos( dynamic_pointer_cast<const SingleRange<U,TYPE> >( IB::mRangePtr )->get(upos) );
+    }
+
+    template <typename U, RangeType TYPE>
+    SingleIndex<U,TYPE>::SingleIndex(std::shared_ptr<const RangeBase<SingleIndex<U,TYPE> > >& rangePtr,
+				     size_t pos) : IndexBase<SingleIndex<U,TYPE> >(range)
+    {
+	IIB::setPos( pos );
+    }
+
+    template <typename U, RangeType TYPE>
+    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator=(size_t pos)
+    {
+	IIB::setPos( pos );
+	return *this;
+    }
+    
+    template <typename U, RangeType TYPE>
+    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator++()
+    {
+	IIB::setPos( IIB::pos() + 1 );
+	return *this;
+    }
+
+    template <typename U, RangeType TYPE>
+    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator--()
+    {
+	IIB::setPos( IIB::pos() - 1 );
+	return *this;
+    }
+
+    template <typename U, RangeType TYPE>
+    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator+=(int n)
+    {
+	IIB::setPos( IIB::pos() + n );
+	return *this;
+    }
+
+    template <typename U, RangeType TYPE>
+    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator-=(int n)
+    {
+	IIB::setPos( IIB::pos() - n );
+	return *this;
+    }
+
+    template <typename U, RangeType TYPE>
+    bool SingleIndex<U,TYPE>::operator==(const SingleIndex<U,TYPE>& i)
+    {
+	return IB::mRange == i.mRange and IIB::pos() == static_cast<size_t>( i.mPos );
+    }
+
+    template <typename U, RangeType TYPE>
+    bool SingleIndex<U,TYPE>::operator!=(const SingleIndex<U,TYPE>& i)
+    {
+	return IB::mRange != i.mRange or IIB::pos() != static_cast<size_t>( i.mPos );
+    }
+
+    template <typename U, RangeType TYPE>
+    MultiRangeType SingleIndex<U,TYPE>::rangeType() const
+    {
+	return MultiRangeType(TYPE);
+    }
+    
+    template <typename U, RangeType TYPE>
+    U SingleIndex<U,TYPE>::getMetaPos() const
+    {
+	return dynamic_cast<SingleRange<U,TYPE> const*>( IB::mRange )->get(IIB::pos());
+    }
+
+    template <typename U, RangeType TYPE>
+    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::atMeta(const U& metaPos)
+    {
+	operator=( dynamic_cast<SingleRange<U,TYPE> const*>( IB::mRange )->getMeta(metaPos) );
+	return *this;
+    }
+
+    template <typename U, RangeType TYPE>
+    size_t SingleIndex<U,TYPE>::dim() const
+    {
+	return 1;
+    }
+    
+    template <typename U, RangeType TYPE>
+    size_t SingleIndex<U,TYPE>::evaluate(const SingleIndex<U,TYPE>& in) const
+    {
+	return in.pos();
+    }
+
+    template <typename U, RangeType TYPE>
+    void SingleIndex<U,TYPE>::copyPos(const SingleIndex<U,TYPE>& in)
+    {
+	IIB::setPos(in.pos());
+    }
+
+    template <typename U, RangeType TYPE>
+    size_t SingleIndex<U,TYPE>::giveSubStepSize(IndefinitIndexBase* subIndex)
+    {
+	if(subIndex == this){
+	    return 1;
+	}
+	else {
+	    return 0;
+	}
+    }
+    
+    std::ostream& operator<<(std::ostream& os, VET vet)
+    {
+	os << ( (vet == VET::VALUE) ? std::string("VALUE") : std::string("ERROR") );
+	return os;
+    }
+    
+    /*
+    template <typename U, RangeType TYPE>
+    void SingleIndex<U,TYPE>::eval()
+    {
+	IIB::setPos( evaluate( *this ) );
+    }
+    */
+
     /********************
      *   SingleRange    *
      ********************/
@@ -251,130 +379,4 @@ namespace MultiArrayTools
 	return SingleIndex<size_t,RangeType::LORENTZ>(this, size());
     }
     
-    /******************
-     *  SingleIndex   *	     
-     ******************/
-
-    template <typename U, RangeType TYPE>
-    SingleIndex<U,TYPE>::SingleIndex(RangeBase<SingleIndex<U,TYPE> > const* range,
-				     const U& upos, size_t disambig) : IndexBase<SingleIndex<U,TYPE> >(range)
-    {
-	IIB::setPos( dynamic_cast<SingleRange<U,TYPE> const*>( IB::mRange )->get(upos) );
-    }
-
-    template <typename U, RangeType TYPE>
-    SingleIndex<U,TYPE>::SingleIndex(RangeBase<SingleIndex<U,TYPE> > const* range,
-				     size_t pos) : IndexBase<SingleIndex<U,TYPE> >(range)
-    {
-	IIB::setPos( pos );
-    }
-
-    template <typename U, RangeType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator=(size_t pos)
-    {
-	IIB::setPos( pos );
-	return *this;
-    }
-    
-    template <typename U, RangeType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator++()
-    {
-	IIB::setPos( IIB::pos() + 1 );
-	return *this;
-    }
-
-    template <typename U, RangeType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator--()
-    {
-	IIB::setPos( IIB::pos() - 1 );
-	return *this;
-    }
-
-    template <typename U, RangeType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator+=(int n)
-    {
-	IIB::setPos( IIB::pos() + n );
-	return *this;
-    }
-
-    template <typename U, RangeType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator-=(int n)
-    {
-	IIB::setPos( IIB::pos() - n );
-	return *this;
-    }
-
-    template <typename U, RangeType TYPE>
-    bool SingleIndex<U,TYPE>::operator==(const SingleIndex<U,TYPE>& i)
-    {
-	return IB::mRange == i.mRange and IIB::pos() == static_cast<size_t>( i.mPos );
-    }
-
-    template <typename U, RangeType TYPE>
-    bool SingleIndex<U,TYPE>::operator!=(const SingleIndex<U,TYPE>& i)
-    {
-	return IB::mRange != i.mRange or IIB::pos() != static_cast<size_t>( i.mPos );
-    }
-
-    template <typename U, RangeType TYPE>
-    MultiRangeType SingleIndex<U,TYPE>::rangeType() const
-    {
-	return MultiRangeType(TYPE);
-    }
-    
-    template <typename U, RangeType TYPE>
-    U SingleIndex<U,TYPE>::getMetaPos() const
-    {
-	return dynamic_cast<SingleRange<U,TYPE> const*>( IB::mRange )->get(IIB::pos());
-    }
-
-    template <typename U, RangeType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::atMeta(const U& metaPos)
-    {
-	operator=( dynamic_cast<SingleRange<U,TYPE> const*>( IB::mRange )->getMeta(metaPos) );
-	return *this;
-    }
-
-    template <typename U, RangeType TYPE>
-    size_t SingleIndex<U,TYPE>::dim() const
-    {
-	return 1;
-    }
-    
-    template <typename U, RangeType TYPE>
-    size_t SingleIndex<U,TYPE>::evaluate(const SingleIndex<U,TYPE>& in) const
-    {
-	return in.pos();
-    }
-
-    template <typename U, RangeType TYPE>
-    void SingleIndex<U,TYPE>::copyPos(const SingleIndex<U,TYPE>& in)
-    {
-	IIB::setPos(in.pos());
-    }
-
-    template <typename U, RangeType TYPE>
-    size_t SingleIndex<U,TYPE>::giveSubStepSize(IndefinitIndexBase* subIndex)
-    {
-	if(subIndex == this){
-	    return 1;
-	}
-	else {
-	    return 0;
-	}
-    }
-    
-    std::ostream& operator<<(std::ostream& os, VET vet)
-    {
-	os << ( (vet == VET::VALUE) ? std::string("VALUE") : std::string("ERROR") );
-	return os;
-    }
-    
-    /*
-    template <typename U, RangeType TYPE>
-    void SingleIndex<U,TYPE>::eval()
-    {
-	IIB::setPos( evaluate( *this ) );
-    }
-    */
 }

src/single_range.h

@@ -5,6 +5,7 @@
 
 #include <cstdlib>
 #include <vector>
+#include <memory>
 
 #include "base_def.h"
 #include "index_base.h"
@@ -23,12 +24,10 @@ namespace MultiArrayTools
 	
 	DEFAULT_MEMBERS(SingleIndex);
 
-	// find better solution !!!
+	SingleIndex(const U& upos, std::shared_ptr<const RangeBase<SingleIndex<U,TYPE> > >& rangePtr);
-	SingleIndex(RangeBase<SingleIndex<U,TYPE> > const* range,
-		    const U& upos, size_t disambig);
 
-	SingleIndex(RangeBase<SingleIndex<U,TYPE> > const* range,
+	SingleIndex(std::shared_ptr<const RangeBase<SingleIndex<U,TYPE> > >& rangePtr,
-		    size_t pos);
+		    size_t pos = 0);
 
 	//virtual SingleIndex& operator=(const U& upos);
 
@@ -64,10 +63,6 @@ namespace MultiArrayTools
     public:
 	typedef typename RangeBase<SingleIndex<U,TYPE> >::IndexType IndexType;
 
-	DEFAULT_MEMBERS(SingleRange);
-
-	SingleRange(const std::vector<U>& space);
-
 	static SingleRange<U,TYPE> oType() { return SingleRange<U,TYPE>(); }
 	
 	virtual size_t size() const override;
@@ -82,6 +77,9 @@ namespace MultiArrayTools
 	SingleIndex<U,TYPE> end() const override;
 	
     protected:
+	
+	SingleRange(const std::vector<U>& space);
+
 	std::vector<U> mSpace;
     };
 
@@ -93,10 +91,6 @@ namespace MultiArrayTools
     public:
 	typedef typename RangeBase<SingleIndex<int,RangeType::SPACE> >::IndexType IndexType;
 
-	DEFAULT_MEMBERS(SingleRange);
-
-	SingleRange(size_t ext);
-
 	static SingleRange<int,RangeType::SPACE> oType() { return SingleRange<int,RangeType::SPACE>(); }
 	
 	virtual size_t size() const override;
@@ -110,6 +104,9 @@ namespace MultiArrayTools
 	SingleIndex<int,RangeType::SPACE> end() const override;
 	
     protected:
+	
+	SingleRange(size_t ext);
+
 	size_t mExt;
     };
 
@@ -119,10 +116,6 @@ namespace MultiArrayTools
     public:
 	typedef typename RangeBase<SingleIndex<size_t,RangeType::DISTANCE> >::IndexType IndexType;
 
-	DEFAULT_MEMBERS(SingleRange);
-
-	SingleRange(size_t ext);
-
 	static SingleRange<size_t,RangeType::DISTANCE> oType() { return SingleRange<size_t,RangeType::DISTANCE>(); }
 	
 	virtual size_t size() const override;
@@ -136,6 +129,9 @@ namespace MultiArrayTools
 	SingleIndex<size_t,RangeType::DISTANCE> end() const override;
 	
     protected:
+	
+	SingleRange(size_t ext);
+
 	size_t mExt;
     };
 
@@ -145,10 +141,6 @@ namespace MultiArrayTools
     public:
 	typedef typename RangeBase<SingleIndex<size_t,RangeType::ENSEMBLE> >::IndexType IndexType;
 
-	DEFAULT_MEMBERS(SingleRange);
-
-	SingleRange(size_t num);
-
 	static SingleRange<size_t,RangeType::ENSEMBLE> oType() { return SingleRange<size_t,RangeType::ENSEMBLE>(); }
 	
 	virtual size_t size() const override;
@@ -162,6 +154,9 @@ namespace MultiArrayTools
 	SingleIndex<size_t,RangeType::ENSEMBLE> end() const override;
 	
     protected:
+	
+	SingleRange(size_t num);
+
 	size_t mNum;
     };
 
@@ -179,8 +174,6 @@ namespace MultiArrayTools
     public:
 	typedef typename RangeBase<SingleIndex<VET,RangeType::VALUE_ERROR> >::IndexType IndexType;
 
-	DEFAULT_MEMBERS(SingleRange);
-
 	static SingleRange<VET,RangeType::VALUE_ERROR> oType()
 	{ return SingleRange<VET,RangeType::VALUE_ERROR>(); }
 	
@@ -201,8 +194,6 @@ namespace MultiArrayTools
     public:
 	typedef typename RangeBase<SingleIndex<size_t,RangeType::LORENTZ> >::IndexType IndexType;
 
-	DEFAULT_MEMBERS(SingleRange);
-
 	static SingleRange<size_t,RangeType::LORENTZ> oType() { return SingleRange<size_t,RangeType::LORENTZ>(); }
 	
 	virtual size_t size() const override;