// String Function by: D_S (Alex Cottner)

const int MAX = 81;

class string
{
    private:
	char str[MAX];
    //Private Functions
	void tolower(void);

    public:
    //Constructors
	string();          	       	//Default
	string(const char[]);  	 	//Initialization
	string (const string&);		//Copy Constructor

    //Member functions
	void reverse();
	int length();
	int compare (const string &s);
	char get (int);
	void put (char, int);

    // Overloaded Operators
	string& operator = (const string&);
	string operator = (const char[]);
	string operator + (const string&);
	int operator > (const string);
	int operator < (const string);
	int operator == (const string);
	int operator >= (const string);
	int operator <= (const string);
	int operator != (const string);

    // Friend methods of the class
	friend ostream& operator << (ostream&, const string&);
	friend istream& operator >> (istream&, string&);

};

//Default constructor
string::string()
{
    str[0] = '\0';
}

//Initialize Construcor
string::string(const char s[])
{
    for (int i=0; s[i] != '\0'; i++)
		str[i] = s[i];
    str[i] = s[i];
}

string::string(const string &s)
{
    for (int i=0; s.str[i]!='\0'; i++)
       str[i]=s.str[i];
    str[i]=s.str[i];
}


//********************************************
//************* Member Functions *************
//********************************************

// Reverse function. Reverses the string a character at a time
void string::reverse()
{
    int l;
    string s2(str);

    l = length();
    for (int j = 0; l>=0; j++, l--)
	str[j] = s2.str[l];
    str[j] = '\0';
}

// Finds the string length by counting until it reaches the null character
int string::length()
{
    for (int i=0; str[i]!='\0'; i++);

    return i-1;
}

// Uppercases all lowercase letters for compare function
void string::tolower(void)
{
   for (int i=0; str[i]!='\0'; i++)
   {
      if ((str[i]>='a')&&(str[i]<='z'))
	 str[i]-=32;
   }
}

// Compares two strings, regardless of case type
int string::compare(const string &s)
{
   string temp1 = str;
   string temp2 = s;
   int flag=1;

   temp1.tolower();
   temp2.tolower();

   for (int i=0; temp1.str[i]==temp2.str[i]; i++)
   {
      if ((temp1.str[i]=='\0')&&(temp2.str[i]=='\0'))
	 flag=0;
   }

   if (flag==0)
      return 0;
   else if ((temp1.str[i]>temp2.str[i])&&(flag==1))
      return 1;
   else
      return -1;
}

// Gets a speciefied character from within a string and outputs it
char string::get (int a)
{
   char ch = '\0';
   int i=length();
   if (a<=i)
      ch = str[a-1];
   return ch;
}

// Puts a new character into a specified place on the string
void string::put (char ch, int a)
{
   int i=length();
   if (a<=i)
      str[a-1]=ch;
}

//********************************************
//*********** Overloaded Operators ***********
//********************************************

// Equal Operator (string equals string)
string& string::operator = (const string &s)
{
    for (int i=0; s.str[i]!='\0'; i++)
       str[i]=s.str[i];
    str[i]='\0';

    return *this;
}

// Equal operator (string equals character array)
string string::operator = (const char s[])
{
   for (int i=0; s[i]!='\0'; i++)
      str[i]=s[i];
   str[i]='\0';
   return *this;
}

// Plus operator
string string::operator + (const string &s)
{
   string temp;
   int b = length()+1;
   temp = *this;

   for (int a=0; s.str[a]!='\0', b<MAX; a++, b++)
      temp.str[b]=s.str[a];
   temp.str[b]='\0';

   return temp;
}

// Greater than operator. just reads from compare
int string::operator > (const string s)
{
   int value = compare(s);

   if (value == 1)
      return 1;
   else
      return 0;
}

// less than operater. just reads from compare
int string::operator < (const string s)
{
   int value = compare(s);

   if (value == -1)
      return 1;
   else
      return 0;
}

// equal too operator. just reads from compare
int string::operator == (const string s)
{
   int value = compare(s);

   if (value == 0)
      return 1;
   else
      return 0;
}

// greater than or equal to operator
int string::operator >= (const string s)
{
   int value = compare(s);

   if (value >= 0)
      return 1;
   else
      return 0;
}

// less than or equal to operator
int string::operator <= (const string s)
{
   int value = compare(s);

   if (value <= 0)
      return 1;
   else
      return 0;
}

// not equal to operator
int string::operator != (const string s)
{
   int value = compare(s);

   if (value != 0)
      return 1;
   else
      return 0;
}

// << Operator. Outputs the string a character at a time until it reaches
// the null character.
ostream& operator << (ostream &out, const string &s)
{
   out << s.str;
   return out;
}

// >> Operator. Recieves until it finds whitespace
istream& operator >> (istream &in, string &s)
{
   in >> s.str;
   return in;
}

// line operator. gets data from a full line.
//istream& operator line (istream &in, string&s)
//{
//   in.getline(s.str, 81, '\n');
//   return in;
//}