/**********************************************************************************
 * Copyright 2010 Christoph Pflaum 
 * 		Department Informatik Lehrstuhl 10 - Systemsimulation
 *		Friedrich-Alexander Universität Erlangen-Nürnberg
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 **********************************************************************************/
 
// ------------------------------------------------------------
//
// functor.h
//
// ------------------------------------------------------------
#include "extemp2D.h"

#ifndef Functor2D_H
#define Functor2D_H

// 1 argument
template <class A, class DTyp_Result, class DTyp, class Func>
class Exp2D_Functor2D1;

template <class A, class DTyp_Result, class DTyp, class Func>
class Exp2D_Functor2D1 : public Expr2D< Exp2D_Functor2D1<A, DTyp_Result, DTyp, Func> > {
		const A& a_;
		Func* functor_;
		control_typ funCtrTyp_;
		
	public:
		inline Exp2D_Functor2D1 ( const A& a, Func* functor, control_typ funCtrTyp )
				: a_ ( a ), functor_ ( functor ), funCtrTyp_ ( funCtrTyp ) {}
				
		stencil_typ Give_stencil_typ() const { return no_stencil; }
		control_typ Give_control_typ() const { return funCtrTyp_; }
		
		
		typedef DTyp_Result Result;
		
		template <elementTyp TYP_EL>
		inline DTyp_Result Give_data ( params2D_in ) const;
		
		inline DTyp_Result Give_cell_hexahedra ( params2D_in_cell ) const;
		
		template <elementTyp TYP_EL>
		void Update ( int id ) const;
};

template <class A, class DTyp_Result, class DTyp, class Func>
template <elementTyp TYP_EL>
inline void
Exp2D_Functor2D1<A, DTyp_Result, DTyp, Func>::Update ( int id ) const {
  a_.template Update<TYP_EL> ( id );
}

template <class A, class DTyp_Result, class DTyp, class Func>
template <elementTyp TYP_EL>
inline DTyp_Result
Exp2D_Functor2D1<A, DTyp_Result, DTyp, Func>::Give_data ( params2D_in ) const {
	return functor_->evaluate ( a_.template Give_data<TYP_EL> ( params2D_out ) );
}

template <class A, class DTyp_Result, class DTyp, class Func>
inline DTyp_Result
Exp2D_Functor2D1<A, DTyp_Result, DTyp, Func>::Give_cell_hexahedra ( params2D_in_cell ) const {
	return functor_->evaluate ( a_.Give_cell_hexahedra ( params2D_out_cell ) );
}

/** \addtogroup ExpressionTemplates2D **/
/* @{ */  
template <class DTyp_Result, class DTyp, class Func>
class Functor2D1 {

	public:
		Functor2D1 ( Func* functor,  control_typ funCtrTyp = thread_save ) : functor_ ( functor ), funCtrTyp_ ( funCtrTyp ) {};
		
		template <class A>
		inline Exp2D_Functor2D1<A, DTyp_Result, DTyp, Func>
		operator() ( const Expr2D<A>& a ) const
		{ return Exp2D_Functor2D1<A, DTyp_Result, DTyp, Func> ( a, functor_, funCtrTyp_ ); }
		
	private:
		Func* functor_;
		control_typ funCtrTyp_;
};
/* @} */

//  2 arguments

template <class A, class B, class DTyp_Result, class DTyp, class Func>
class Exp2D_Functor2D2
			: public Expr2D<Exp2D_Functor2D2<A, B, DTyp_Result, DTyp, Func> > {
		const A& a_;
		const B& b_;
		Func* functor_;
		control_typ funCtrTyp_;
		
	public:
		inline Exp2D_Functor2D2 ( const A& a, const B& b, Func* functor, control_typ funCtrTyp ) :
				a_ ( a ), b_ ( b ), functor_ ( functor ), funCtrTyp_ ( funCtrTyp ) {}
				
		stencil_typ Give_stencil_typ() const { return no_stencil; }
		control_typ Give_control_typ() const { return funCtrTyp_; }
		
		typedef DTyp_Result Result;
		
		template <elementTyp TYP_EL>
		inline DTyp_Result Give_data ( params2D_in ) const;
		
		inline DTyp_Result Give_cell_hexahedra(params2D_in_cell) const;
		
		inline DTyp_Result Give_cell_rectangle(params2D_in_cell) const;		
		
		template <elementTyp TYP_EL>
		void Update ( int id ) const;
		
		Blockgrid2D* Give_blockgrid() const { return a_.Give_blockgrid(); };
};



template <class A, class B, class DTyp_Result, class DTyp, class Func>
template <elementTyp TYP_EL>
inline void
Exp2D_Functor2D2<A,B, DTyp_Result, DTyp, Func>::Update ( int id ) const {
  a_.template Update<TYP_EL> ( id );
  b_.template Update<TYP_EL> ( id );
}

template <class A, class B, class DTyp_Result, class DTyp, class Func>
template <elementTyp TYP_EL>
inline DTyp_Result
Exp2D_Functor2D2<A, B, DTyp_Result, DTyp, Func>::Give_data ( params2D_in ) const {
	return functor_->evaluate ( a_.template Give_data<TYP_EL> ( params2D_out ),
	                            b_.template Give_data<TYP_EL> ( params2D_out ) );
}

template <class A, class B, class DTyp_Result, class DTyp, class Func>
inline DTyp_Result
Exp2D_Functor2D2<A, B, DTyp_Result, DTyp, Func>::Give_cell_hexahedra ( params2D_in_cell ) const {
	return functor_->evaluate ( a_.Give_cell_hexahedra ( params2D_out_cell ),
	                           b_.Give_cell_hexahedra ( params2D_out_cell ) );
}

template <class A, class B, class DTyp_Result, class DTyp, class Func>
inline DTyp_Result
Exp2D_Functor2D2<A, B, DTyp_Result, DTyp, Func>::Give_cell_rectangle ( params2D_in_cell ) const {
	return functor_->evaluate ( a_.Give_cell_rectangle ( params2D_out_cell ),
	                           b_.Give_cell_rectangle ( params2D_out_cell ) );
}

/** \addtogroup ExpressionTemplates2D **/
/* @{ */   
template <class DTyp_Result, class DTyp, class Func>
class Functor2D2 {

	public:
		Functor2D2 ( Func* functor, control_typ funCtrTyp = thread_save) : functor_ ( functor ), funCtrTyp_ ( funCtrTyp )  {};
		
		template <class A, class B>
		inline Exp2D_Functor2D2<A, B, DTyp_Result, DTyp, Func>
		operator() ( const Expr2D<A>& a, const Expr2D<B>& b ) const
		{ return Exp2D_Functor2D2<A, B, DTyp_Result, DTyp, Func> ( a, b, functor_, funCtrTyp_ ); }
		
	private:
		Func* functor_;
		control_typ funCtrTyp_;
};
/* @} */

// 3 arguments

template < class A, class B, class C,

class DTyp_Result, class DTyp, class Func >

class Exp2D_Functor2D3
			: public Expr2D<Exp2D_Functor2D3<A, B, C, DTyp_Result, DTyp, Func> > {
		const A& a_;
		const B& b_;
		const C& c_;
		Func* functor_;
		control_typ funCtrTyp_;
		
	public:
		inline Exp2D_Functor2D3 ( const A& a,
		                      const B& b,
		                      const C& c,
		                      Func* functor,
		                      control_typ funCtrTyp ) :
				a_ ( a ), b_ ( b ), c_ ( c ), functor_ ( functor ), funCtrTyp_ ( funCtrTyp ) {}
				
		stencil_typ Give_stencil_typ() const { return no_stencil; }
		control_typ Give_control_typ() const { return funCtrTyp_; }
		
		typedef DTyp_Result Result;
		
		template <elementTyp TYP_EL>
		inline DTyp_Result Give_data ( params2D_in ) const;
		
		inline DTyp_Result Give_cell_hexahedra ( params2D_in_cell ) const;
		
		
		template <elementTyp TYP_EL>
		void Update ( int id ) const {
			a_.template Update<TYP_EL> ( id );
                        b_.template Update<TYP_EL> ( id );
                        c_.template Update<TYP_EL> ( id );
		}
};


template < class A, class B, class C,

class DTyp_Result, class DTyp, class Func >
template <elementTyp TYP_EL>
inline DTyp_Result
Exp2D_Functor2D3<A, B, C, DTyp_Result, DTyp, Func>::Give_data ( params2D_in ) const {
	return functor_->evaluate ( a_.template Give_data<TYP_EL> ( params2D_out ),
	                            b_.template Give_data<TYP_EL> ( params2D_out ),
	                            c_.template Give_data<TYP_EL> ( params2D_out ) );
}

template < class A, class B, class C,

class DTyp_Result, class DTyp, class Func >
inline DTyp_Result
Exp2D_Functor2D3<A, B, C, DTyp_Result, DTyp, Func>::Give_cell_hexahedra ( params2D_in_cell ) const {
	return functor_->evaluate ( a_.Give_cell_hexahedra ( params2D_out_cell ),
	                            b_.Give_cell_hexahedra ( params2D_out_cell ),
	                            c_.Give_cell_hexahedra ( params2D_out_cell ) );
	                            
}


/** \addtogroup ExpressionTemplates2D **/
/* @{ */   
template <class DTyp_Result, class DTyp, class Func>
class Functor2D3 {

	public:
		Functor2D3 ( Func* functor, control_typ funCtrTyp = thread_save) : functor_ ( functor ), funCtrTyp_ ( funCtrTyp ) {};
		
		template <class A, class B, class C>
		inline Exp2D_Functor2D3<A, B, C, DTyp_Result, DTyp, Func>
		operator() ( const Expr2D<A>& a,
		             const Expr2D<B>& b,
		             const Expr2D<C>& c ) const
		{ return Exp2D_Functor2D3<A, B, C, DTyp_Result, DTyp, Func> ( a, b, c, functor_, funCtrTyp_ ); }
		
		
	private:
		Func* functor_;
		control_typ funCtrTyp_;
};
/* @} */

// 4 arguments

template <class A, class B, class C, class D, class DTyp_Result, class DTyp, class Func>
class Exp2D_Functor2D4
			: public Expr2D<Exp2D_Functor2D4<A, B, C, D, DTyp_Result, DTyp, Func> > {
		const A& a_;
		const B& b_;
		const C& c_;
		const D& d_;
		const control_typ funCtrTyp_;
		Func* functor_;
		
	public:
		inline Exp2D_Functor2D4 ( const A& a,
		                      const B& b,
		                      const C& c,
		                      const D& d,
		                      Func* functor,
		                      control_typ funCtrTyp ) :
				a_ ( a ), b_ ( b ), c_ ( c ), d_ ( d ), functor_ ( functor ), funCtrTyp_ ( funCtrTyp ) {}
				
		stencil_typ Give_stencil_typ() const { return no_stencil; }
		
		control_typ Give_control_typ() const { return funCtrTyp_; }
		
		typedef DTyp_Result Result;
		
		template <elementTyp TYP_EL>
		inline DTyp_Result Give_data ( params2D_in ) const;
		
		inline DTyp_Result Give_cell_hexahedra ( params2D_in_cell ) const;
		
		
		template <elementTyp TYP_EL>
		void Update ( int id ) const {
			a_.template Update<TYP_EL> ( id );
                        b_.template Update<TYP_EL> ( id );
                        c_.template Update<TYP_EL> ( id );
                        d_.template Update<TYP_EL> ( id );
		}
};


template < class A, class B, class C, class D,
class DTyp_Result, class DTyp, class Func >
template <elementTyp TYP_EL>
inline DTyp_Result
Exp2D_Functor2D4<A, B, C, D, DTyp_Result, DTyp, Func>::Give_data ( params2D_in ) const {
	return functor_->evaluate ( a_.template Give_data<TYP_EL> ( params2D_out ),
	                            b_.template Give_data<TYP_EL> ( params2D_out ),
	                            c_.template Give_data<TYP_EL> ( params2D_out ),
	                            d_.template Give_data<TYP_EL> ( params2D_out ) );
}

template < class A, class B, class C, class D,
class DTyp_Result, class DTyp, class Func >
inline DTyp_Result
Exp2D_Functor2D4<A, B, C, D, DTyp_Result, DTyp, Func>::Give_cell_hexahedra ( params2D_in_cell ) const {
	return functor_->evaluate ( a_.Give_cell_hexahedra ( params2D_out_cell ),
	                            b_.Give_cell_hexahedra ( params2D_out_cell ),
	                            c_.Give_cell_hexahedra ( params2D_out_cell ),
	                            d_.Give_cell_hexahedra ( params2D_out_cell ) );
}



/** \addtogroup ExpressionTemplates2D **/
/* @{ */    
template <class DTyp_Result, class DTyp, class Func>
class Functor2D4 {

	public:
		//Functor2D4 ( Func* functor ) : functor_ ( functor ) {};
		
		Functor2D4 ( Func* functor, control_typ funCtrTyp = thread_save ) : functor_ ( functor ), funCtrTyp_ ( funCtrTyp ) {
		
		};
		
		template <class A, class B, class C, class D>
		inline Exp2D_Functor2D4<A, B, C, D, DTyp_Result, DTyp, Func>
		operator() ( const Expr2D<A>& a,
		             const Expr2D<B>& b,
		             const Expr2D<C>& c,
		             const Expr2D<D>& d ) const {
			return Exp2D_Functor2D4<A, B, C, D, DTyp_Result, DTyp, Func> ( a, b, c, d, functor_ ,
			        funCtrTyp_ );
		}
		
		
	private:
		Func* functor_;
		control_typ funCtrTyp_;
};
/* @} */

#endif /* FUNCTOR_H */