#include <iostream>
#include <assert.h>
#include <string.h>

using namespace std;


template <typename DataType>
struct box
{
	DataType data;
	box<DataType> *next;

	box (DataType d, box<DataType> *n):data(d), next (n){}
	//{data = d; next = n}
};

template <typename DataType>
class LList
{
public:
	box<DataType> *first;

	void print ()
	{
		box<DataType> *crr = first;

		while (crr != NULL)
		{
			cout << crr->data << endl;
			crr = crr->next;
		}

		//current==?
	}



	void removeAll ()
	{
		while (first != NULL)
			pop();
	}

	~LList ()
	{
		removeAll ();
	}

	LList<DataType>& operator = (const LList<DataType> &l)
	{
		
		if (&l != this)
		{
			this->removeAll();
			this->copy (l);
		}
		return *this;
	}

	void copy (const LList<DataType> &l)
	{
		
		box<DataType> *otherCrr = l.first;

		int i =0;

		while (otherCrr != NULL)
		{
			this->insertAt (otherCrr->data,i);
			otherCrr = otherCrr->next;
			i++;
		}	
	}

	LList (const LList &l)
	{
		this->first = NULL;

		copy (l);
		

	}

	LList ():first(NULL) {}//{first = NULL;}

	void push (DataType newData)
	{

		box<DataType> *newBox = new box<DataType> (newData,NULL);

		newBox->next = first;

		first = newBox;
	}


	void insertAt (DataType newData, int ix)
	{
		
		if (ix == 0)
		{
			push (newData);
			return;
		}

		box<DataType> *crr = findElementAt (ix-1);

		assert (crr != NULL);

		box<DataType> *newBox = new box<DataType> (newData,crr->next);
		crr->next = newBox;		

	}

	box<DataType> *findElementAt (int ix)
	{
		box<DataType> *crr = first;
		for (int i = 0; i < ix && crr != NULL; i++)
			crr = crr->next;

		return crr;
	}

	void pop ()
	{

		assert (first != NULL);

		box<DataType> *save = first;
		first = first->next;
		delete save;
	}

	void removeAt ( int ix)
	{
		if (ix == 0)
		{
			pop();
			return;
		}

		box<DataType> *crr = findElementAt (ix-1);

		assert (crr != NULL);
		assert (crr->next != NULL);

		box<DataType> *save = crr->next;

		crr->next = crr->next->next;
		delete save;

	}

//зад. Да се реализира метод, която намира броя на 
//четните числа в ЛЕС

	int countEvens ()
	{

		int count = 0;

		box<DataType> *crr = first;

		while (crr != NULL)
		{
			if (crr->data % 2 ==0)
				count++;
			crr = crr->next;
		}

		return count;

	}

//зад. да се да напише метод, който проверяева дали
//елементите на ЛЕС образуват монотонно растяща редица

	bool isSortedAsc ()
	{
		box<DataType> *crr = first;

		if (crr == NULL)
			return true;

		while (crr->next != NULL && crr->next->data > crr->data)
		{
			crr = crr->next;
		}

		return crr->next == NULL;

	}

	bool isSortedAscRec (box<DataType> *crr)
	//Методът проверява дали списъка ОТ CRR НАТАТЪК е
	//подреден
	{
		if (crr == NULL || crr->next == NULL)
			return true;

		return 	crr->next->data > crr->data 
		        && 
		        isSortedAscRec (crr->next);

	}

	bool isSortedAscRec ()
	{
		return isSortedAscRec (first);
	}

	//зад. Да се напише метод, който проверява дали
	//съществува стойност K, такава че всеки елемент
	//на ЛЕС се получава чрез добавяне на K към предишния

	bool isProgression ()
	{
		if (first == NULL || first->next == NULL)
			return true;

		box<DataType> *crr = first;

		DataType K = crr->next->data - crr->data;

		while (crr->next != NULL)
		{
			if (crr->next->data - crr->data != K)
				return false;
			crr = crr->next;
		}

		return true;
	}

	//по желание:
	//оператор []

	DataType& operator[] (int index)
	{
		box<DataType> *crr = first;

		int count = 0;

		while (crr != NULL && count != index)
		{
			crr = crr->next;
			count++;
		}

		assert (crr != NULL);

		return crr->data;

	}

	//оператор ==

	bool operator == (LList<DataType> other)
	{
		box<DataType> *crr1 = first;
		box<DataType> *crr2 = other.first;

		while (crr1 != NULL && crr2 != NULL)
		{
			if (crr1->data != crr2->data)
				return false;

			crr1 = crr1->next;
			crr2 = crr2->next;
		}

		return crr1 == NULL && crr2 == NULL;
	}

	//if (l1.equals (l2))
	//if (l1 == l2)

	//зад. Да се дефинира оператор += за ЛЕС

	//зад. Нека даден ЛЕС е подреден в нарастващ ред. Да
	//     се дефнира оператор insertSorted (x), който
	//     вмъква x в ЛЕС така, че той остава подреден
	//     l.IS (3); ls.IS (5); l.IS (1); .print()->1,3,5


};


void f (LList<int> l2)
{
	l2.pop();
	l2.print();
}


//зад. Да се напише клас Превозно Средство (Vehicle) със следните
//атрибути
// - Рег. Номер (до 10 символа)
// - Марка и моде (симв. низ с произволна големина)
// - Година на произв (ест число)
// - Име на собственик (симв. низ с големина до 40 симв)
// За Прев. ср-во да се дефинират следните операции, както и 
// всички необходими служебни методи, свързани с управлението на ДП
// - подходящ конструктор, с който да може лесно да се 
//   инициализарат обекти //Vehicle kalinsCar (1451, "Peugeout X", "CA1111AC",...)
// - read, print
// - оператор >, който дефнира кога един автомобил е по-добър от 
//   друг по следния начин
//     -- по-новите автомобили са винаги по-добри
//     -- ако два автомобила са произведени в една и съща година,
//        то пежото е по-добро
// - оператор ==

class Vehicle
{
public:
	char reg[11];
	char *model;
	int year;
	char driver[41];

	Vehicle (char *_reg,char *_model, int _year, char *driver)
	{
		init (_reg,_model,_year,driver);
	}

	Vehicle (const Vehicle &v)
	{
		init (v.reg,v.model,v.year,v.driver);
	}

	void init (char *_reg,char *_model, int _year, char *driver)
	{
		strncpy (reg,_reg,10);

		model = new char[strlen(_model)+1];
		strcpy (model,_model);

		year = _year;

		strncpy (driver,_driver,40);		
	}

	Vehicle ()
	{
		model = NULL;

	}

	~Vehicle ()
	{
		delete model; //delete NULL;
	}

	void print ()
	{
		//..
	}

	bool operator > (const Vehicle &v)
	// if (kalinCar > petyrsCar)
	{
		if (year < v.year)
			return true;

		if (year == v.year)
		{

			//"2006 Peugeot 307"
			return strstr (model,"Peugeot") != NULL &&
			       strstr (v.model,"Peugeot") == NULL;
		}

		return false;
	}


};




int main ()
{

	LList <int> l, l1;

	l.push (0);
	l.push (1);
	l1.push (2);
	l1.push (3);
	
	l = l;

	l.print();

	cout << "------\n";




	
}