#ifndef __STRING_AMV
	#define __STRING_AMV

#include <iostream>
#include <cctype>
#include "algorithm.h"
#include "vector.h"
#include "deque.h"
#include "amvdefs.h"

namespace amv	{

class string: public vector<char>	{
	public:
		string();
		string(const char *pSourceString);
		string &operator=(const char *pSourceString);
		string &operator+=(const string &op2);
		string &operator+=(const char *pSourceString);
		string operator+(const string &op2) const;
		string operator+(const char *pSourceString) const;
		bool operator<(const string &op2) const;
		char *str() const;
		friend istream &operator>>(istream &is, string &s);

};

string::string():
vector<char>()
{
}

string::string(const char *pSourceString):
vector<char>(pSourceString,pSourceString+strlen(pSourceString))
{
}

string &string::operator=(const char *pSourceString)
{
int Size=strlen(pSourceString);
clear();
resize(Size);
copy(pSourceString,pSourceString+Size,ptr);

return *this;
}

string &string::operator+=(const string &op2)
{
resize(m_size+op2.m_size);
copy(op2.ptr,op2.ptr+op2.m_size,ptr+m_size-op2.m_size);

return *this;
}

string &string::operator+=(const char *pSourceString)
{
int Size=strlen(pSourceString);
resize(m_size+Size);
copy(pSourceString,pSourceString+Size,ptr+m_size-Size);

return *this;
}

string string::operator+(const string &op2) const
{
string temp(*this);
temp+=op2;

return temp;
}

string string::operator+(const char *pSourceString) const
{
string temp(*this);
temp+=pSourceString;

return temp;
}

bool string::operator<(const string &op2) const
{
size_type i,j;
for(i=0, j=0; i<m_size && j<op2.m_size; ++i, ++j)
	{
	if(ptr[i]>op2.ptr[j])
		return false;
	else if(ptr[i]<op2.ptr[j])
		return true;
	}

if(i==m_size && j==op2.m_size)
	return false;
if(i==m_size)
	return true;
else
	return false;
}

char *string::str() const
{
char *p=new char[m_size+1];
copy(ptr,ptr+m_size,p);
*(p+m_size)=0;

return p;
}

ostream &operator<<(ostream &os,const string &s)
{
vector<char>::const_iterator it(s.begin());
for(; it!=s.end(); ++it)
	os<<*it;

return os;
}

istream &operator>>(istream &is, string &s)
{
char c;
if(is>>c)
	{
	deque<char> d;
	d.push_back(c);
	while(is.get(c))
		{
		if(isspace(c))
			{
			is.putback(c);
			break;
			}
		d.push_back(c);
		if(is.peek()==EOF)
			break;
		}
	if(d.size())
		{
		s.resize(d.size());
		copy(d.begin(),d.end(),s.begin());
		}
	else
		is.clear(ios_base::failbit);

	}

return is;
}

}

#endif