#include <iostream>

#define SIZE_PVECTOR_TAB 50

#include "PBaseExpressionTemplateIterator.h"

struct PVector{
	// Définition des types iterateurs
	typedef double* Iterator;
	typedef const double* ConstIterator;

	// Fonctions de récupération des itérateurs de début et de fin
	Iterator begin(){return p_elements;}
	Iterator end(){return p_elements + SIZE_PVECTOR_TAB;}
	ConstIterator begin()const{return p_elements;}
	ConstIterator end()const{return p_elements + SIZE_PVECTOR_TAB;}
	
	void setValue(double val){
		for(Iterator it = begin(); it != end(); ++it){
			*it = val;
		}
	}
	
	template<class T>
	const PVector& operator = (T expr);
	
	// Et enfin les données
	double p_elements[SIZE_PVECTOR_TAB];
};

///Surcharge de l'opérateur d'affectation =
/**	@param expr : expression template ou le calcul est définit sou forme d'arbre par le compilateur
 * 	@return PVector calculé comme il faut
 * 	C'est un méthode qui permet de transformer une expression de calcul compliquée en une expression en C avec une boucle qui poura éventuellement vectorisée
 * 	si cela est possible ou parallèlisée avec OpenMP sans que le programmeur ne se soit cassé la tête
*/
template <class T>
const PVector& PVector::operator = (T expr){
	//je ne suis pas convaincu que l'on puisse faire du OpenMP avec une boucle for définie comme ça
	for(Iterator i = begin(); i != end(); ++i, ++expr){
		*i = *expr;
	}
	return *this;
}

//Surcharge des opérateurs pour le PVector
PSURCHAGE_IT_TYPE_ALL_OP(PVector,PVector::ConstIterator)
//cette macro est équivalente à toutes celles ci dessous

// PSURCHAGE_IT_TYPE_OP_ADD_LEFT(PVector,PVector::ConstIterator)
// PSURCHAGE_IT_TYPE_OP_ADD_RIGHT(PVector,PVector::ConstIterator)
// PSURCHAGE_IT_TYPE_OP_ADD_TYPE(PVector,PVector::ConstIterator)
// PSURCHAGE_IT_TYPE_OP_SUB_TYPE(PVector,PVector::ConstIterator)
// PSURCHAGE_IT_TYPE_OP_MULT_LEFT(PVector,PVector::ConstIterator)
// PSURCHAGE_IT_TYPE_OP_MULT_RIGHT(PVector,PVector::ConstIterator)
// PSURCHAGE_IT_TYPE_OP_DIV_SCAL(PVector,PVector::ConstIterator)
// PSURCHAGE_IT_TYPE_OP_MINUS(PVector,PVector::ConstIterator)

using namespace std;

int main(int argc, char **argv) {
	cout << "Hello, world!" << endl;
	
	PVector v1, v2, v3, v4;
	
	v1.setValue(1.0);
	v2.setValue(1.0);
	v3.setValue(1.0);
	
	v4 = 1.0 * (v1 / 2.0) - (v2 + v3) * 2.0;
	
	cout << "v4 = (" << v4.p_elements[0] << ", " << v4.p_elements[1] << ", " << v4.p_elements[2] << ")" << endl;
	cout << "On doit avoir (-3.5, -3.5, -3.5)" << endl;
	
	return 0;
}

//arbre générer par le compilateur
// BinaryOp<BinaryOp<PVector::const_iterator, UnaryOp<double,Const>,Div>,BinaryOp<BinaryOp<PVector::const_iterator,PVector::const_iterator,Add>,UnaryOp<double,Const>,Mult>,Minus>;