// Programmer:  Aaron Shbeeb
// File:  Student.h
// Created:  10-20-02
// Updated:  10-25-02

#ifndef STUDENT_H
#define STUDENT_H

#include <assert.h>
#include <iostream.h>
#include <memory.h>
#include "../Keywords.h"
#include "../String/String.h"

int Compare_cString(preserves String<char>& a, preserves String<char>& b);

class Student_Rep
{
public:
	String<char> FName,LName,Login,Alias;
};

class Student
{
public:
	//Basic Operations
	String<char>& FName();
	String<char>& LName();
	String<char>& Login();
	String<char>& Alias();

	bool operator==(preserves Student& s);

	//Get functions are deep copy
	void Get_FName(produces String<char>& FN);
	void Get_LName(produces String<char>& LN);
	void Get_Login(produces String<char>& Log);
	void Get_Alias(produces String<char>& Aka);
	
	void Get(produces String<char>& FN,
			produces String<char>& LN,
			produces String<char>& Log,
			produces String<char>& Aka);
	
	void Swap_FName(alters String<char>& FN);
	void Swap_LName(alters String<char>& LN);
	void Swap_Login(alters String<char>& Log);
	void Swap_Alias(alters String<char>& Aka);
	
	void Set(consumes String<char>& FN,
			consumes String<char>& LN,
			consumes String<char>& Log,
			consumes String<char>& Aka);

	//Constructor/Destructor
	Student();
	~Student();

	//Standard Operations
	void Clear();
	void operator&=(alters Student& s);

private:
	Student_Rep *rep;

protected:
	void Initialize();
	void Finalize();
};

//Basic Operations
String<char>& Student::
FName()
{
	return rep->FName;
}

String<char>& Student::
LName()
{
	return rep->LName;
}

String<char>& Student::
Login()
{
	return rep->Login;
}

String<char>& Student::
Alias()
{
	return rep->Alias;
}

bool Student::operator==(preserves Student& s)
{
	if(Compare_cString(s.rep->Login,rep->Login) == 0) return true;
	return false;
}

void Student::Get_FName(produces String<char>& FN)
{
	FN = rep->FName;
}

void Student::Get_LName(produces String<char>& LN)
{
	LN = rep->LName;
}

void Student::Get_Login(produces String<char>& Log)
{
	Log = rep->Login;
}


void Student::Get_Alias(produces String<char>& Aka)
{
	Aka = rep->Alias;
}

void Student::Get(produces String<char>& FN,
			produces String<char>& LN,
			produces String<char>& Log,
			produces String<char>& Aka)
{
	FN &= rep->FName;
	LN &= rep->LName;
	Log &= rep->Login;
	Aka &= rep->Alias;
}

void Student::Swap_FName(alters String<char>& FN)
{
	FN &= rep->FName;
}

void Student::Swap_LName(alters String<char>& LN)
{
	LN &= rep->LName;
}

void Student::Swap_Login(alters String<char>& Log)
{
	Log &= rep->Login;
}

void Student::Swap_Alias(alters String<char>& Aka)
{
	Aka &= rep->Alias;
}

void Student::Set(consumes String<char>& FN,
			consumes String<char>& LN,
			consumes String<char>& Log,
			consumes String<char>& Aka)
{
	rep->FName &= FN;
	rep->LName &= LN;
	rep->Login &= Log;
	rep->Alias &= Aka;	
}

//Constructor/Destructor

Student::Student()
{
	Initialize();
}


Student::~Student()
{
	Finalize();
}

//Standard Operations

void Student::Clear()
{
	Finalize();
	Initialize();
}


void Student::operator &=(alters Student& s)
{
	Student_Rep *tmp;

	tmp = rep;
	rep = s.rep;
	s.rep = tmp;
}

//Protected Operations

void Student::Initialize()
{
	rep = new Student_Rep;
	assert(rep != 0);
}


void Student::Finalize()
{
	delete rep;
}

int Compare_cString(preserves String<char>& a, preserves String<char>& b)
{

	int min_len = a.Length();	//assume lhs is smaller
	int i;

	if(b.Length() < min_len)	//then assumption wrong
	{
		min_len = b.Length();
	}

	for(i = 0; i < min_len; i++)
	{
		if(a[i] < b[i])
		{
			return -1;	//lhs is smaller
		}else if(a[i] > b[i])
		{
			return 1;	//rhs is smaller
		}
	}

	//if we got here, then they're equal up to the minimum length
	if(a.Length() < b.Length())
	{
		return -1;	//lhs is smaller
	}else if(a.Length() > b.Length())
	{
		return 1;
	}else{
		return 0;	//they must be equal
	}
}

#endif