// string.cpp
// implements c++ string object for HOS
// Author: Josh Holtrop
// Date: 06/01/04
// Modified: 06/07/04

#include "string.h"	//string class declaration
#include "asmfuncs.h"	//memcpy(void *dest, void *src, int n), strlen(char *str)

string::string()
{
	myLength = 0;
	myChars = new char;	//myChars must be a valid pointer at all times
	*myChars = 0;
}

string::~string()
{
	delete[] myChars;
}

string::string(const string & orig)
{
	myLength = orig.myLength;
	myChars = new char[myLength + 1];
	memcpy(myChars, orig.myChars, myLength + 1);
}

string::string(const char *cstring)
{
	myLength = strlen(cstring);
	myChars = new char[myLength + 1];
	memcpy(myChars, cstring, myLength + 1);
}

string & string::operator=(const string & orig)
{
	if (this != &orig)
	{
		delete[] myChars;
		myLength = orig.myLength;
		myChars = new char[myLength + 1];
		memcpy(myChars, orig.myChars, myLength + 1);
	}
	return *this;
}

string & string::operator=(const char *cstring)
{
	if (myChars != cstring)
	{
		delete[] myChars;
		myLength = strlen(cstring);
		myChars = new char[myLength + 1];
		memcpy(myChars, cstring, myLength + 1);
	}
	return *this;
}

char * string::data() const { return myChars; }

int string::size() const { return myLength; }

string & string::operator+=(const string & str)
{
	char *newStr = new char[myLength + str.myLength + 1];
	memcpy(newStr, myChars, myLength);
	memcpy(newStr + myLength, str.myChars, str.myLength + 1);
	delete[] myChars;
	myChars = newStr;
	myLength += str.myLength;
	return *this;
}

string & string::operator+=(const char *cstring)
{
	char *newStr = new char[myLength + strlen(cstring) + 1];
	memcpy(newStr, myChars, myLength);
	memcpy(newStr + myLength, cstring, strlen(cstring) + 1);
	delete[] myChars;
	myChars = newStr;
	myLength += strlen(cstring);
	return *this;
}

string & string::operator-=(const string & str)
{
	char *newStr = new char[myLength + str.myLength + 1];
	memcpy(newStr, str.myChars, str.myLength);
	memcpy(newStr + str.myLength, myChars, myLength + 1);
	delete[] myChars;
	myChars = newStr;
	myLength += str.myLength;
	return *this;
}

string & string::operator-=(const char *cstring)
{
	char *newStr = new char[myLength + strlen(cstring) + 1];
	memcpy(newStr, cstring, strlen(cstring));
	memcpy(newStr + strlen(cstring), myChars, myLength + 1);
	delete[] myChars;
	myChars = newStr;
	myLength += strlen(cstring);
	return *this;
}

string & string::operator+=(char chr)
{
	myLength++;
	char *newStr = new char[myLength + 1];
	memcpy(newStr, myChars, myLength);
	newStr[myLength - 1] = chr;
	newStr[myLength] = 0;
	delete[] myChars;
	myChars = newStr;
	return *this;
}

string & string::operator-=(char chr)
{
	myLength++;
	char *newStr = new char[myLength + 1];
	memcpy(newStr + 1, myChars, myLength);
	*newStr = chr;
	delete[] myChars;
	myChars = newStr;
	return *this;
}



string::string(const string & str1, const string & str2)
{
	myLength = str1.myLength + str2.myLength;
	myChars = new char[myLength + 1];
	memcpy(myChars, str1.myChars, str1.myLength);
	memcpy(myChars + str1.myLength, str2.myChars, str2.myLength + 1);
}

string::string(const string & str1, const char *cstring)
{
	myLength = str1.myLength + strlen(cstring);
	myChars = new char[myLength + 1];
	memcpy(myChars, str1.myChars, str1.myLength);
	memcpy(myChars + str1.myLength, cstring, strlen(cstring) + 1);
}

string::string(const char *cstring, const string & str)
{
	myLength = str.myLength + strlen(cstring);
	myChars = new char[myLength + 1];
	memcpy(myChars, cstring, strlen(cstring));
	memcpy(myChars + strlen(cstring), str.myChars, str.myLength + 1);
}

string::string(const string & str1, char chr)
{
	myLength = str1.myLength + 1;
	myChars = new char[myLength + 1];
	memcpy(myChars, str1.myChars, myLength);
	myChars[myLength - 1] = chr;
	myChars[myLength] = 0;
}

string::string(char chr, const string & str1)
{
	myLength = str1.myLength + 1;
	myChars = new char[myLength + 1];
	memcpy(myChars  + 1, str1.myChars, myLength + 1);
	*myChars = chr;
}

const char & string::operator[](unsigned int index) const
{
	if (index < myLength)
		return myChars[index];
	return *myChars;		//if index is invalid, return a pointer to the trailing 0
}

char & string::operator[](unsigned int index)
{
	if (index < myLength)
		return myChars[index];
	return *myChars;		//if index is invalid, return a pointer to the trailing 0
}



bool string::operator==(const string & second) const
{
	if (myLength != second.myLength)
		return false;
	for (unsigned int i = 0; i < myLength; i++)
	{
		if (myChars[i] != second.myChars[i])
			return false;
	}
	return true;
}

bool string::operator==(const char *cstring) const
{
	if (myLength != strlen(cstring))
		return false;
	for (unsigned int i = 0; i < myLength; i++)
	{
		if (myChars[i] != cstring[i])
			return false;
	}
	return true;
}

bool string::operator!=(const string & second) const
{ return !operator==(second); }

bool string::operator!=(const char *cstring) const
{ return !operator==(cstring); }

bool string::operator<(const string & second) const
{
	char *c1 = myChars, *c2 = second.myChars;
	while (*c1 == *c2 && *c1)
	{
		c1++;
		c2++;
	}
	return *c1 < *c2;
}

bool string::operator>(const string & second) const
{
	char *c1 = myChars, *c2 = second.myChars;
	while (*c1 == *c2 && *c1)
	{
		c1++;
		c2++;
	}
	return *c1 > *c2;
}

bool string::operator<(const char *cstring) const
{
	char *c1 = myChars;
	while (*c1 == *cstring && *c1)
	{
		c1++;
		cstring++;
	}
	return *c1 < *cstring;
}

bool string::operator>(const char *cstring) const
{
	char *c1 = myChars;
	while (*c1 == *cstring && *c1)
	{
		c1++;
		cstring++;
	}
	return *c1 > *cstring;
}

bool string::operator<=(const string & second) const
{ return !operator>(second); }

bool string::operator>=(const string & second) const
{ return !operator<(second); }

bool string::operator<=(const char *cstring) const
{ return operator<(cstring) || operator==(cstring); }

bool string::operator>=(const char *cstring) const
{ return operator>(cstring) || operator==(cstring); }