// My string class
// Matthew Morse

#include <stdio.h>
#include <iostream.h>
#include <ctype.h>
#include <stdlib.h>

void outOfMemory(int x);

static char garbage = '\0';

void outOfMemory(int x)
	{
	cerr << "ERROR: Out of Memory ";
	switch(x)
		{
		case 1: cerr<< "in string allocation.\n";
		}
	exit(-1);
	}
	
class string
	{
	private:
	 unsigned   size;
	 char     *array;

	public:
	      	  string    (void);
	      	  string    (char[]);
	      	  string    (char);
		  	  string    (long double);
		  	  string    (int);
		  	  string    (long);
		 	  string    (unsigned);
		 	  string    (unsigned long);
		  	  string    (float);
		  	  string    (double);
		  	  string    (const string&);
		 	 ~string    (void);
	 unsigned length    (void);
	 char    &operator[](int);
	 string   operator()(int,int);
	 char    *contents  (void);
	 long	  integer   (void);
	 float	  decimal   (void);
	 string   uppercase (void);
	 string   lowercase (void);
	 bool     isNumber  (void);
	 int      inStr     (string,int); // not yet implemented
	 void     empty     (void);

	 string   operator= (string);
	 string   operator= (char []);
	 string   operator= (char); 
	 string   operator= (int); 
	 string   operator= (long); 
	 string   operator= (unsigned); 
	 string   operator= (unsigned long); 
	 string   operator= (float); 
	 string   operator= (double); 
	 string   operator= (long double); 

	 string   operator+ (string);
 	 string   operator+ (char []);
  friend string   operator+ (char [], string);	
 	 string   operator+ (char);
  friend string   operator+ (char, string);	

 	 void     operator+=(string);
 	 void     operator+=(char []);
 	 void     operator+=(char);

	 bool     operator==(string);
	 bool     operator==(char []);
	 bool     operator==(char);
  friend bool     operator==(char [], string);
  friend bool     operator==(char, string);

	 bool     operator>=(string);
	 bool     operator>=(char []);
	 bool     operator>=(char);
  friend bool     operator>=(char [], string);
  friend bool     operator>=(char, string);

	 bool     operator<=(string);
	 bool     operator<=(char []);
	 bool     operator<=(char);
  friend bool     operator<=(char [], string);
  friend bool     operator<=(char, string);

	 bool     operator> (string);
	 bool     operator> (char []);
	 bool     operator> (char);
  friend bool     operator> (char [], string);
  friend bool     operator> (char, string);

	 bool     operator< (string);
	 bool     operator< (char []);
	 bool     operator< (char);
  friend bool     operator< (char [], string);
  friend bool     operator< (char, string);

	 bool	  operator!=(string);
	 bool	  operator!=(char []);
	 bool	  operator!=(char);
  friend bool     operator!=(char [], string);
  friend bool     operator!=(char, string);

  friend ostream  &operator<< (ostream  &a,  string  b);
  friend istream  &operator>> (istream  &a,  string &b);

	};

//======================================
// 		CONSTRUCTORS
//======================================

// makes a string of size 0
string::string()
	{
	size  = 0;
	array = NULL;
	}

// makes string from an array of chars
string::string (char input[])
	{
	int inputsize =0;

	while (input[inputsize]!='\0')
		inputsize++;

	array = new char[inputsize];
	if (!array) ::outOfMemory(1);
	else        // copy string
		{
		size = inputsize;
		for (int x=0;x<size;x++)
			array[x]=input[x];
		}
	}

// makes string from a single char
string::string (char input)
	{
	array = new char[1];
	if (!array) ::outOfMemory(1);
	else        // copy string
		{
		size = 1;
		array[0]=input;
		}
	}

// string = number
string::string (int input)
	{
	char inputs[20];
	sprintf(inputs,"%d", input);
	int inputsize =0;
	while (inputs[inputsize]!='\0')
		inputsize++;
	array = new char[inputsize];
	if (!array) ::outOfMemory(1);
	else        // copy string
		{
		size = inputsize;
		for (int x=0;x<size;x++)
			array[x]=inputs[x];
		}
	}

string::string (long input)
	{
	char temp[20];
	sprintf(temp,"%d", input);
	string feh(temp);
	*this = feh;
	}

string::string (unsigned input)
	{
	char temp[20];
	sprintf(temp,"%u", input);
	string feh(temp);
	*this = feh;
	}

string::string (unsigned long input)
	{
	char temp[20];
	sprintf(temp,"%u", input);
	string feh(temp);
	*this = feh;
	}

string::string (float input)
	{
	char temp[20];
	sprintf(temp,"%f", input);
	string feh(temp);
	*this = feh;
	}

string::string (double input)
	{
	char temp[20];
	sprintf(temp,"%f", input);
	string feh(temp);
	*this = feh;
	}

string::string (long double input)
	{
	char temp[20];
	sprintf(temp,"%f", input);
	string feh(temp);
	*this = feh;
	}

// copy constructor
string::string (const string& original)
	{
	size=original.size;

	array = new char[size];
	if (!array) ::outOfMemory(1);
	for(int x=0;x<size;x++)
		array[x]=original.array[x];
	}

// destructor
string::~string()
	{delete [] array;}

// int Length() =========================================
// returns size of string

unsigned string::length()
	{return size;}

// string [] ===========================================
// grabs character  

inline char &string::operator[](int a)
	{
	::garbage = '\0';
	if ((a>-1)&&(a<size)) return array[a]; 
	else return garbage;
	}

// string (int, int) ===========================
// grabs all characters from a to b

string string::operator()(int a, int b)
	{
	string uyar;
	int  inputsize = (b-a+2);
	char *temp;

	if  (!((b<a)||(a<0)||(b<0)||(a>size-1)||(b>size-1)))
		{
		temp = new char[inputsize];
		if (!temp) ::outOfMemory(1);
		else        // copy string
			{
			int count =0;
			for (int x=a; x<=b; x++)
				{
				temp[count]=array[x];
				count++;
				}
			temp[inputsize-1]='\0';
			}
		uyar = temp;
		}
	return uyar;
	}	

// char *contents() ==================================
// returns string as a null terminated C string

char *string::contents()
	{
	char *temp;

	temp = new char[size+1];
	if (!temp) ::outOfMemory(1);
		
	for (int x=0;x<size;x++)
		temp[x] = array[x];
	temp[size] = '\0';
	return temp;
	}	

// int Integer() =====================================
// returns integer value of string

long string::integer()
	{return atol(contents());}

// decimal () ========================================
// returns integer value of string

float string::decimal()
	{return atof(contents());}
		
// empty () ===============================================
// clear contents of the string

void string::empty()
	{
	delete [] array;
	size   = 0;
	}

// uppercase  =============================================
// Changes all characters to uppercase

string string::uppercase()
	{
	string temp = *this;

	for(int x=0;x<size;x++)
		temp.array[x] = toupper(temp.array[x]);
	return temp;
	}

// lowercase  ==============================================
// Changes all characters to lowercase

string string::lowercase()
	{
	string temp = *this;

	for(int x=0;x<size;x++)
		temp.array[x] = tolower(temp.array[x]);
	return temp;
	}

// IsNumber ===============================================
// Sees if this string is a number

bool string::isNumber()
	{
	bool IsNumber=1;
	int  count=1,dec=0;	

	if (array[0]=='.')
		dec++;
	else if (!((array[0]==' ')||(array[0]=='+')||(array[0]=='-')||(isdigit(array[0]))))
		IsNumber=0;

	while  ( (IsNumber)&&(dec<2)&&(count<size) )
		{
		if (array[count]=='.')
			dec++;
		else if (!isdigit(array[count]))
			IsNumber=0;
		count++;
		}
	if (dec>1)
		IsNumber=0;
	return IsNumber;
	}

// operator= (string) ======================================
// assignment

string string::operator= (string a)
	{
	size = a.size;
	delete [] array;

	array = new char[size];
	if (!array) ::outOfMemory(1);
		
	for(int x=0;x<size;x++)
		array[x] = a.array[x];
	return *this;
	}

// operator= (char []) =====================================
// assignment

string string::operator= (char a[])
	{
	string temp(a);
	return (*this = temp);
	}

// operator= (char) ========================================
// assignment

string string::operator= (char a)
	{
	string temp(a);
	return (*this = temp);
	}

string string::operator= (int a)
	{
	string temp(a);
	return (*this = temp);
	}

string string::operator= (long a)
	{
	string temp(a);
	return (*this = temp);
	}
 
string string::operator= (unsigned a)
	{
	string temp(a);
	return (*this = temp);
	}
 
string string::operator= (unsigned long a)
	{
	string temp(a);
	return (*this = temp);
	}
 
string string::operator= (float a)
	{
	string temp(a);
	return (*this = temp);
	}
 
string string::operator= (double a)
	{
	string temp(a);
	return (*this = temp);
	}
 
string string::operator= (long double a) 
	{
	string temp(a);
	return (*this = temp);
	}

// operator+ (string) =====================================
// string concatonation

string string::operator+(string add)
	{
	string temp;
	
	if ((size+add.size)>size)
		{
		temp.size = size + add.size;
	
		temp.array = new char[temp.size];
		if (!(temp.array)) ::outOfMemory(1);
			else               // copy string
			{
			int feh=size;
			for (int x=0; x<size; x++)
				temp.array[x]=array[x];
			for (int x=0; x<add.size; x++)
				{
				temp.array[feh]=add.array[x];
				feh++;
				}	
			}
		}
	return temp;
	}

// operator+ (char []) =====================================
// string concatonation

string string::operator+(char add[])
	{
	string temp(add);
	return (*this + temp);
	}

// operator+ ===============================================
// used to concat string = char[] + string

string operator+ (char a[], string b)
	{
	string temp(a);
	return (temp+b);
	}	

// operator+ (char) ========================================
// string concatonation

string string::operator+(char add)
	{
	string temp(add);
	return (*this + temp);
	}

// operator+ ===============================================
// used to concat string = char + string

string operator+ (char a, string b)
	{
	string temp(a);
	return (temp+b);
	}	

// operator+=(string) =====================================
// string concatonation

void string::operator+=(string a)
	{(*this)=((*this)+a);}

// operator+=(char []) =====================================
// string concatonation

void string::operator+=(char a[])
	{*this=(*this+a);}

// operator+=(char) ========================================
// string concatonation

void string::operator+=(char a)
	{*this=(*this+a);}

// RELATIONAL OPERATORS ====================================

bool string::operator==(string a)
	{
	bool same=1;
	
	if (size==a.size)
		{
		int x=0;
		while ( (x<size) && same )
			{
			same = (array[x] == a.array[x]);
			x++;
			}
		} 
	else same=0;
	return same;
	}

bool string::operator==(char a[])
	{
	string temp(a);
	return (*this==temp);
	}

bool string::operator==(char a)
	{
	string temp(a);
	return (*this==temp);
	}

bool operator==(char a[], string b)
	{
	string temp(a);
	return (b==temp);
	}

bool operator==(char a, string b)
	{
	string temp(a);
	return (b==temp);
	}

bool string::operator>=(string a)
	{return !(*this<a);}

bool string::operator>=(char a[])
	{return !(*this<a);}

bool string::operator>=(char a)
	{return !(*this<a);}

bool operator>=(char a[], string b)
	{
	string temp(a);
	return (b<temp);
	}

bool operator>=(char a, string b)
	{
	string temp(a);
	return (b<temp);
	}

bool string::operator<=(string a)
	{return !(*this>a);}

bool string::operator<=(char a[])
	{return !(*this>a);}

bool string::operator<=(char a)
	{return !(*this>a);}

bool operator<=(char a[], string b)
	{
	string temp(a);
	return (b>temp);
	}

bool operator<=(char a, string b)
	{
	string temp(a);
	return (b>temp);
	}

bool string::operator> (string a)
	{
	int thisIsBigger=-1;
	
	if (!array) 
		thisIsBigger=0;
	else if(!a.array) thisIsBigger=1;
			
	if (thisIsBigger==-1)
		{
		int x=0;
		while ( (x<size) && (x<a.size) && (thisIsBigger==-1) )
			{
			if (array[x]>a.array[x])
				thisIsBigger=1;
			else if (array[x]<a.array[x])
				thisIsBigger=0;
			x++;
			}
		if (thisIsBigger==-1)
			thisIsBigger = (size>a.size);
		}
	return thisIsBigger;
	}

bool string::operator> (char a[])
	{
	string temp(a);
	return (*this>temp);
	}
	
bool string::operator> (char a)
	{
	string temp(a);
	return (*this>temp);
	}

bool operator>(char a[], string b)
	{
	string temp(a);
	return !(b>=temp);
	}

bool operator>(char a, string b)
	{
	string temp(a);
	return !(b>=temp);
	}

bool string::operator< (string a)
	{
	int thisIsSmaller=-1;
	
	if (!a.array) 
		thisIsSmaller=0;
	else if(!array) thisIsSmaller=1;
			
	if (thisIsSmaller==-1)
		{
		int x=0;
		while ( (x<size) && (x<a.size) && (thisIsSmaller==-1) )
			{
			if (array[x]>a.array[x])
				thisIsSmaller=0;
			else if (array[x]<a.array[x])
				thisIsSmaller=1;
			x++;
			}
		if (thisIsSmaller==-1)
			thisIsSmaller = (size<a.size);
		}
	return thisIsSmaller;
	}

bool string::operator< (char a[])
	{
	string temp(a);
	return (*this<temp);
	}

bool string::operator< (char a)
	{
	string temp(a);
	return (*this<temp);
	}

bool operator<(char a[], string b)
	{
	string temp(a);
	return !(b<=temp);
	}

bool operator<(char a, string b)
	{
	string temp(a);
	return !(b<=temp);
	}

bool string::operator!=(string a)
	{return !(*this==a);}
	
bool string::operator!=(char a[])
	{return !(*this==a);}

bool string::operator!=(char a)
	{return !(*this==a);}

bool operator!=(char a[], string b)
	{
	string temp(a);
	return !(b==temp);
	}

bool operator!=(char a, string b)
	{
	string temp(a);
	return !(b==temp);
	}

// =================================================
//               INPUT AND OUTPUT
// =================================================
ostream &operator<< (ostream &stream, string a)
	{
	if (a.array)
		for (int x=0;x<a.size;x++)
			stream << a.array[x];
	return stream;
	}

istream &operator>> (istream &stream, string &a)
	{
	char q;
	bool done=0;
	string New;

	while (!done)
		{
		stream.get(q);
		if ( (!isspace(q))&&((a.size+1)!=0) )
			New+=q;
		else done=1;
		}
	a=New;
	return stream;
	}