#include "set.h"
//********prototype
long * expand(long * ar, int oldSize, int newSize); //expand set

//constructors
Set::Set(){  // the default constructor 
	nelements=0;
	size=100;
	data=new long[size];
}

Set::Set(long a, long b, long c){ 
	nelements=0;
	size=100;
	data=new long[size];

	int result=a;
	for(int i=1; result <=b; i++){
		operator<<(result);
		result=a+i*c;
	}
}

// initializes the set to elements
// contained in the array list; the size should be size of the array
// (note: you cannot assume that elements in list are all distinct)
Set::Set(long list[],long size2) 
 {
	 nelements=0;
	 size=100;
	 data= new long[size];
	 for (int i=0; i<size2; i++)
		 operator<< (list[i]);
 }

Set::Set(const Set &s){ //the copy constructor
	nelements=s.nelements;
	size=s.size;
	data=new long[size];
	for (int i=0; i<nelements; i++)
		data[i]=s.data[i];
}

//deconstructor
Set::~Set(){  
	delete [] data;
}

//Other methods
Set & Set::operator=(const Set &s) // the assignment operator
{
	if (this == &s) //if assigning the set to itself
		return *this;  //do nothing
	delete[] data;
	nelements=s.nelements;
	size=s.size;
	data=new long[size];
	for (int i=0; i<nelements; i++)
		data[i]=s.data[i];

	return *this;
}

Set::operator long() const{ // return the number of elements
	return nelements;
}

bool Set::operator()(long x) const{ // return true if x is an element of the set
	for (int i=0; i<nelements; i++){
		if (data[i]==x)
			return true;//x exists in the set
	}
	return false;//x does not exist in the set

}

bool Set::operator==(const Set &s) const{  // return true if s contains the same elements
	if (nelements!=s.nelements)
		return false; 
	for(int i=0; i<nelements; i++){
		if(operator()(s.data[i])==false)//not the same element
			return false;
	}
	return true;
}


bool Set::operator<=(const Set &s) const{     // return true if this object is subset of s
	if(nelements>s.nelements)
		return false;
	for (int i=0; i<nelements; i++){
		if(s.operator ()(data[i])==false)
			return false;
	}
	return true;
}

bool Set::operator>=(const Set &s) const{ // return true if s is subset of this object
	if(s.nelements>nelements)
		return false;
	for (int i=0; i<s.nelements; i++){
		if (operator()(s.data[i]) == false)
			return false;
	}
	return true;
}

long * expand(long * ar, int oldSize, int newSize){ //Expand Set
	long * temp=new long[newSize];

	for (int i=0; i<oldSize; i++)
		temp[i]=ar[i];
	delete[] ar;
	return temp;
}

Set & Set::operator<<(long x){// add x to the set
	if (operator()(x))
		return *this;

	if (nelements ==size){ //expand method here
		data=expand(data, size, size*2);
		size=2*size;
	}
	int index;
	for (index=0;index<nelements;index++) {
		if (data[index]>x)
			break;
	}

	int j;
	for (j=nelements-1; j>=index; j--)//shift elements to make room for the new x
		data[j+1]=data[j];
	data[index]=x;
	nelements++;
	return *this;
}



Set & Set::operator>>(long x) // remove x from the set 
{	
	if (operator()(x)==false) //x does not exist
		return *this; //do nth

	int index;
	for (index=0;index<nelements;index++)
	{
		if (data[index]==x) //found x
			break;
	}
	int j;
	for (j=index; j<nelements-1; j++)
		data[j]=data[j+1]; 
	nelements--;
	return *this;

}

Set Set::operator+(const Set &s) const{
	Set temp=*this; //use copy constructor
	for (int i=0; i<s.nelements; i++)
		temp << s.data[i];
	return temp;
}


Set & Set::operator+=(const Set &s) {
	for (int i=0; i<s.nelements; i++)
		operator << (s.data[i]);
	return *this;
}


Set Set::operator*(const Set &s) const{  // return the intersection with the set s
	Set temp;
	for (int i=0; i<nelements; i++){
		if (s.operator ()(data[i]) == true){
			temp << data[i];
		}	
	}
	return temp;
}

Set & Set::operator*=(const Set &s){    // keep only those elements which are also in s
	for (int i=0; i<nelements; i++){
		if (s.operator ()(data[i]) == false){
			operator >> (data[i]);
			i--;
		}	
	}
	return *this;
}


Set Set::operator-(const Set &s) const{ // return the set difference with the set s

	Set temp;
	for (int i=0; i<nelements; i++){
		if (s.operator ()(data[i]) == false){
			temp << data[i];
		}	
	}
	return temp;
}

Set & Set::operator-=(const Set &s){ // remove those elements which are also in s
	for (int i=0; i<nelements; i++){
		if (s.operator ()(data[i]) == true){
			operator >> (data[i]);
			i--;
		}	
	}
	return *this;
}

ostream & operator<<(ostream &os, const Set &s)// print the content of the set s
{
	os << "{";

	for (int i=0; i<s.nelements; i++)
	{
		if(i>0)
			os << ",";
		os<< s.data[i];
	}

	os << "}";
	return os;
}