operation creation for functional multi_arrays

src/include/functional_multi_array.h

@@ -3,6 +3,7 @@
 #define __functional_multi_array__
 
 #include "multi_array_base.h"
+#include "slice.h"
 
 namespace MultiArrayTools
 {
@@ -16,6 +17,13 @@ namespace MultiArrayTools
 	typedef MultiArrayBase<T,CRange> MAB;
 	typedef typename MultiArrayBase<T,CRange>::const_iterator const_iterator;
 	typedef typename CRange::IndexType IndexType;
+
+
+    private:
+	mutable T mVal;
+	Function mFunc;
+
+    public:
 	
 	DEFAULT_MEMBERS(FunctionalMultiArray);
 	FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges, const Function& func);
@@ -26,13 +34,10 @@ namespace MultiArrayTools
 	virtual bool isSlice() const override;
 
 	// EVALUTAION CLASS ??!!!!
+
+	auto operator()(std::shared_ptr<typename SRanges::IndexType>&... inds) const
+	    -> decltype( mkOperation( mFunc, ConstOperationRoot<T,SRanges...>(inds.metaPtr(), inds), ... ) )
 	
-	//virtual ConstOperationRoot<T,SRanges...>
-	//operator()(std::shared_ptr<typename SRanges::IndexType>&... inds) const override;
-	
-    private:
-	mutable T mVal;
-	Function mFunc;
     };
 
     
@@ -78,6 +83,15 @@ namespace MultiArrayTools
 	return false;
     }
 
+    template <typename T, class Function, class... SRanges>
+    auto FunctionalMultiArray<T,Function,SRanges...>::
+    operator()(std::shared_ptr<typename SRanges::IndexType>&... inds) const
+	-> decltype( mkOperation( mFunc, ConstOperationRoot<T,SRanges...>(inds.metaPtr(), inds), ... ) )
+    {
+ 	return mkOperation( mFunc, ConstOperationRoot<T,SRanges...>(inds.metaPtr(), inds), ... );
+    }
+
+    
 } // namespace MultiArrayTools
 
 #endif

src/include/multi_array_operation.h

@@ -259,6 +259,12 @@ namespace MultiArrayTools
 	
     };
 
+    template <class OpFunction, class... Ops>
+    auto mkOperation(const OpFunction& f, const Ops&... ops)
+	-> Operation<OpFunction::value_type,OpFunction,Ops...>
+    {
+	return Operation<OpFunction::value_type,OpFunction,Ops...>(ops...);
+    }
     
     template <typename T, class Op, class IndexType>
     class Contraction : public OperationTemplate<T,Contraction<T,Op,IndexType> >

src/include/ranges/index_base.h

@@ -60,6 +60,7 @@ namespace MultiArrayTools
 	std::string id() const { return THIS().id(); }
 
 	MetaType meta() const { return THIS().meta(); }
+	MetaType metaPtr() const { return THIS().metaPtr(); }
 	I& at(const MetaType& meta) { return THIS().at(meta); }
 
 	void print(size_t offset = 0) const { THIS().print(offset); }

src/include/ranges/range_types/classic_range.h

@@ -45,6 +45,7 @@ namespace MultiArrayTools
 	static constexpr bool defaultable = true;
 	static constexpr size_t ISSTATIC = 0;
 	static constexpr size_t SIZE = -1;
+	static constexpr bool HASMETACONT = false;
 	
 	static SingleRangeFactory<size_t, SpaceType::NONE> factory(size_t size = 0)
 	{ return SingleRangeFactory<size_t, SpaceType::NONE>(size); }

src/include/ranges/range_types/spin_range.h

@@ -51,6 +51,7 @@ namespace MultiArrayTools
 
 	static constexpr size_t ISSTATIC = 1;
 	static constexpr size_t SIZE = mSpinNum;
+	static constexpr bool HASMETACONT = false;
 	
 	static SingleRangeFactory<size_t, SpaceType::SPIN> factory()
 	{ return SingleRangeFactory<size_t, SpaceType::SPIN>(); }

src/include/ranges/single_range.h

@@ -137,10 +137,30 @@ namespace MultiArrayTools
      *  SingleIndex   *	     
      ******************/
 
+    template <bool HASMETACONT>
+    struct MetaPtrSetter
+    {
+	template <typename U, class Range>
+	U* set(Range* r)
+	{
+	    return &r->get(0);
+	}
+    };
+
+    template <>
+    struct MetaPtrSetter<false>
+    {
+	template <typename U, class Range>
+	U* set(Range* r)
+	{
+	    return nullptr;
+	}
+    };
+
     template <typename U, SpaceType TYPE>
     SingleIndex<U,TYPE>::SingleIndex(const std::shared_ptr<SingleRange<U,TYPE> >& range) :
 	IndexInterface<SingleIndex<U,TYPE>,U>(range, 0),
-	mMetaPtr(&IB::mRangePtr->get(0)) {}
+	mMetaPtr(MetaPtrSetter<SingleIndex<U,TYPE>::HASMETACONT>::set(IB::mRangePtr)) {}
 
     template <typename U, SpaceType TYPE>
     IndexType SingleIndex<U,TYPE>::type() const