#include <string_lib.h>
#include <stdio.h>

String::String() {
  texto = NULL;
  Muda_Texto("");
}

String::String(const char *texto) {
  this->texto = NULL;
  Muda_Texto(texto);
}

String::String(const String& texto) {
  this->texto = NULL;
  Muda_Texto(texto.texto);
}

String::String(char texto) {
  this->texto = NULL;
  Muda_Texto(texto);
}

String::String(int texto) {
  this->texto = NULL;
  Muda_Texto(texto);
}

String::String(double texto) {
  this->texto = NULL;
  Muda_Texto(texto);
}

String::String(float texto) {
  this->texto = NULL;
  Muda_Texto(texto);
}

String::String(long texto) {
  this->texto = NULL;
  Muda_Texto(texto);
}


String::~String() {
  if (texto != NULL) {
    delete texto;
  }
}

void String::Muda_Texto(const char* texto) {
  if (this->texto != NULL) {
    delete this->texto;
    this->texto = NULL;
  }
  if (texto != NULL) {
    Concatena(texto);
  }
}

void String::Muda_Texto(String texto) {
  Muda_Texto(texto.Texto());
}


void String::Muda_Texto(char texto) {
  char *txt = new char[2];
  sprintf(txt,"%c",texto);
  Muda_Texto(txt);
  delete txt;
}

void String::Muda_Texto(int texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  Muda_Texto(txt);
  delete txt;
}

void String::Muda_Texto(int texto) {
  Muda_Texto(texto,"%d");
}


void String::Muda_Texto(double texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  Muda_Texto(txt);
  delete txt;
}

void String::Muda_Texto(double texto) {
  Muda_Texto(texto,"%f");
}


void String::Muda_Texto(float texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  Muda_Texto(txt);
  delete txt;
}

void String::Muda_Texto(float texto) {
  Muda_Texto(texto,"%f");
}


void String::Muda_Texto(long texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  Muda_Texto(txt);
  delete txt;
}

void String::Muda_Texto(long texto) {
  Muda_Texto(texto,"%li");
}


char *String::Texto() {
  return texto;
}


void String::Concatena(const char *texto) {
  char *temporario=NULL;
  if (Texto() == NULL) {
    if (texto != NULL) {
      this->texto = new char[strlen(texto)+1];
      strcpy(this->texto,texto);
    }
  } else {
    if (texto != NULL) {
      temporario = new char[strlen(Texto())+1];

      strcpy(temporario,Texto());

      delete this->texto;
      this->texto = NULL;
      
      this->texto = new char[strlen(temporario) + strlen(texto)+1];
	    
      strcpy(this->texto,temporario);
      strcat(this->texto,texto);

      delete temporario;
      temporario = NULL;
    }
  }

}

void String::Concatena(String &texto) {
  String txt;
  txt.Muda_Texto(texto.Texto());
  Concatena(txt.Texto());
}

void String::Concatena(char texto) {
  char *txt = new char[2];
  sprintf(txt,"%c",texto);
  Concatena(txt);
  delete txt;
}

void String::Concatena(int texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  Concatena(txt);
  delete txt;
}

void String::Concatena(int texto) {
  Concatena(texto,"%d");
}


void String::Concatena(double texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  Concatena(txt);
  delete txt;
}

void String::Concatena(double texto) {
  Concatena(texto,"%f");
}


void String::Concatena(float texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  Concatena(txt);
  delete txt;
}

void String::Concatena(float texto) {
  Concatena(texto,"%f");
}


void String::Concatena(long texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  Concatena(txt);
  delete txt;
}

void String::Concatena(long texto) {
  Concatena(texto,"%li");
}


void String::PreConcatena(const char *texto) {
  String str(texto);
  
  str.Concatena(this->Texto());

  Muda_Texto(str.Texto());

}


void String::PreConcatena(String &texto) {
  PreConcatena(texto.Texto());
}

void String::PreConcatena(char texto) {
  char *txt = new char[2];
  sprintf(txt,"%c",texto);
  PreConcatena(txt);
  delete txt;
}

void String::PreConcatena(int texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  PreConcatena(txt);
  delete txt;
}

void String::PreConcatena(int texto) {
  PreConcatena(texto,"%d");
}


void String::PreConcatena(double texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  PreConcatena(txt);
  delete txt;
}

void String::PreConcatena(double texto) {
  PreConcatena(texto,"%f");
}


void String::PreConcatena(float texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  PreConcatena(txt);
  delete txt;
}

void String::PreConcatena(float texto) {
  PreConcatena(texto,"%f");
}


void String::PreConcatena(long texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  PreConcatena(txt);
  delete txt;
}

void String::PreConcatena(long texto) {
  PreConcatena(texto,"%li");
}


void String::Para_Maiuscula() {
  unsigned int i;
  if (Texto() != NULL) {
    for (i=0; i < strlen(Texto()); i++) {
      this->texto[i] = toupper(Texto()[i]);
    }
  }
}


void String::Para_Minuscula() {
  unsigned int i;
  if (Texto() != NULL) {
    for (i=0; i < strlen(Texto()); i++) {
      this->texto[i] = tolower(Texto()[i]);
    }
  }
}


int String::Compara(const char *texto) {
  return strcoll(texto,Texto());
}

int String::Compara(String &texto) {
  return Compara(texto.Texto());
}

int String::Compara(char texto) {
  char *txt = new char[2];
  sprintf(txt,"%c",texto);
  bool retorno = Compara(txt);
  delete txt;
  return retorno;
}

int String::Compara(int texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = Compara(txt);
  delete txt;
  return retorno;
}

int String::Compara(int texto) {
  return Compara(texto,"%d");
}


int String::Compara(double texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = Compara(txt);
  delete txt;
  return retorno;
}

int String::Compara(double texto) {
  return Compara(texto,"%f");
}


int String::Compara(float texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = Compara(txt);
  delete txt;
  return retorno;
}

int String::Compara(float texto) {
  return Compara(texto,"%f");
}


int String::Compara(long texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = Compara(txt);
  delete txt;
  return retorno;
}

int String::Compara(long texto) {
  return Compara(texto,"%li");
}




int String::ComparaIgnoreCase(const char *texto) {
  String txt1, txt2;
  txt1 = Texto();
  txt2 = texto;
  txt1.Para_Minuscula();
  txt2.Para_Minuscula();
  return txt1.Compara(txt2.Texto());
}

int String::ComparaIgnoreCase(String &texto) {
  return ComparaIgnoreCase(texto);
}

int String::ComparaIgnoreCase(char texto) {
  char *txt = new char[2];
  sprintf(txt,"%c",texto);
  bool retorno = ComparaIgnoreCase(txt);
  delete txt;
  return retorno;
}

int String::ComparaIgnoreCase(int texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = ComparaIgnoreCase(txt);
  delete txt;
  return retorno;
}

int String::ComparaIgnoreCase(int texto) {
  return ComparaIgnoreCase(texto,"%d");
}


int String::ComparaIgnoreCase(double texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = ComparaIgnoreCase(txt);
  delete txt;
  return retorno;
}

int String::ComparaIgnoreCase(double texto) {
  return ComparaIgnoreCase(texto,"%f");
}


int String::ComparaIgnoreCase(float texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = ComparaIgnoreCase(txt);
  delete txt;
  return retorno;
}

int String::ComparaIgnoreCase(float texto) {
  return ComparaIgnoreCase(texto,"%f");
}


int String::ComparaIgnoreCase(long texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = ComparaIgnoreCase(txt);
  delete txt;
  return retorno;
}

int String::ComparaIgnoreCase(long texto) {
  return ComparaIgnoreCase(texto,"%li");
}


bool String::Igual(const char *texto) {
  return (Compara(texto) == 0) ? true : false;
}

bool String::Igual(String &texto) {
  return Igual(texto.Texto());
}

bool String::Igual(char texto) {
  char *txt = new char[2];
  sprintf(txt,"%c",texto);
  bool retorno = Igual(txt);
  delete txt;
  return retorno;
}

bool String::Igual(int texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = Igual(txt);
  delete txt;
  return retorno;
}

bool String::Igual(int texto) {
  return Igual(texto,"%d");
}


bool String::Igual(double texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = Igual(txt);
  delete txt;
  return retorno;
}

bool String::Igual(double texto) {
  return Igual(texto,"%f");
}


bool String::Igual(float texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = Igual(txt);
  delete txt;
  return retorno;
}

bool String::Igual(float texto) {
  return Igual(texto,"%f");
}


bool String::Igual(long texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = Igual(txt);
  delete txt;
  return retorno;
}

bool String::Igual(long texto) {
  return Igual(texto,"%li");
}



bool String::IgualIgnoreCase(const char *texto) {
  return (ComparaIgnoreCase(texto) == 0) ? true : false;
}

bool String::IgualIgnoreCase(String &texto) {
  return IgualIgnoreCase(texto.Texto());
}

bool String::IgualIgnoreCase(char texto) {
  char *txt = new char[2];
  sprintf(txt,"%c",texto);
  bool retorno = IgualIgnoreCase(txt);
  delete txt;
  return retorno;
}

bool String::IgualIgnoreCase(int texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = IgualIgnoreCase(txt);
  delete txt;
  return retorno;
}

bool String::IgualIgnoreCase(int texto) {
  return IgualIgnoreCase(texto,"%d");
}


bool String::IgualIgnoreCase(double texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = IgualIgnoreCase(txt);
  delete txt;
  return retorno;
}

bool String::IgualIgnoreCase(double texto) {
  return IgualIgnoreCase(texto,"%f");
}


bool String::IgualIgnoreCase(float texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = IgualIgnoreCase(txt);
  delete txt;
  return retorno;
}

bool String::IgualIgnoreCase(float texto) {
  return IgualIgnoreCase(texto,"%f");
}


bool String::IgualIgnoreCase(long texto, const char* formato) {
  char *txt = new char[50];
  sprintf(txt,formato,texto);
  bool retorno = IgualIgnoreCase(txt);
  delete txt;
  return retorno;
}

bool String::IgualIgnoreCase(long texto) {
  return IgualIgnoreCase(texto,"%li");
}


bool String::Vazia() {
  return Igual("");
}

void String::Localizacao(const char* locale) {
  if (locale == NULL) {
    setlocale(LC_ALL,"");
  } else {
    setlocale(LC_ALL,locale); // pega do ambiente
  }
}



String &String::operator=(const char *texto) { 
  Muda_Texto(texto);
  return *this;
}

String &String::operator=(const String &texto) {
  Muda_Texto(texto);
  return *this;
}

String &String::operator=(char texto) { 
  Muda_Texto(texto);
  return *this;
}

String &String::operator=(int texto) { 
  Muda_Texto(texto);
  return *this;
}

String &String::operator=(double texto) { 
  Muda_Texto(texto);
  return *this;
}

String &String::operator=(float  texto) { 
  Muda_Texto(texto);
  return *this;
}

String &String::operator=(long texto) { 
  Muda_Texto(texto);
  return *this;
}



String String::operator+(const char *texto) {
  String str(this->Texto());
  str.Concatena(texto);
  return str;
}

String String::operator+(String texto) { 
  String str(this->Texto());
  str.Concatena(texto);
  return str;
}

String String::operator+(char texto) { 
  String str(this->Texto());
  str.Concatena(texto);
  return str;
}

String String::operator+(int texto) { 
  String str(this->Texto());
  str.Concatena(texto);
  return str;
}

String String::operator+(double texto) { 
  String str(this->Texto());
  str.Concatena(texto);
  return str;
}

String String::operator+(float  texto) { 
  String str(this->Texto());
  str.Concatena(texto);
  return str;
}

String String::operator+(long texto) { 
  String str(this->Texto());
  str.Concatena(texto);
  return str;
}


String &String::operator+=(const char *texto) { 
  Concatena(texto);
  return *this;
}

String &String::operator+=(String texto) { 
  Concatena(texto);
  return *this;
}

String &String::operator+=(char texto) { 
  Concatena(texto);
  return *this;
}

String &String::operator+=(int texto) { 
  Concatena(texto);
  return *this;
}

String &String::operator+=(double texto) { 
  Concatena(texto);
  return *this;
}

String &String::operator+=(float  texto) { 
  Concatena(texto);
  return *this;
}

String &String::operator+=(long texto) { 
  Concatena(texto);
  return *this;
}



bool String::operator==(const char *texto) { 
  return (strcmp(Texto(),texto) == 0);
}

bool String::operator==(String texto) { 
  return (strcmp(Texto(),texto.Texto()) == 0);
}

bool String::operator==(char texto) {
  String tst(texto);
  return (*this == tst);
}

bool String::operator==(int texto) { 
  String tst(texto);
  return (*this == tst);
}

bool String::operator==(double texto) { 
  String tst(texto);
  return (*this == tst);
}

bool String::operator==(float  texto) { 
  String tst(texto);
  return (*this == tst);
}

bool String::operator==(long texto) { 
  String tst(texto);
  return (*this == tst);
}




bool String::operator<(const char *texto) { 
  return (strcmp(Texto(),texto) < 0);
}

bool String::operator<(String texto) { 
  return (strcmp(Texto(),texto.Texto()) < 0);
}

bool String::operator<(char texto) {
  String tst(texto);
  return (*this < tst);
}

bool String::operator<(int texto) { 
  String tst(texto);
  return (*this < tst);
}

bool String::operator<(double texto) { 
  String tst(texto);
  return (*this < tst);
}

bool String::operator<(float  texto) { 
  String tst(texto);
  return (*this < tst);
}

bool String::operator<(long texto) { 
  String tst(texto);
  return (*this < tst);
}



bool String::operator>(const char *texto) { 
  return (strcmp(Texto(),texto) > 0);
}

bool String::operator>(String texto) { 
  return (strcmp(Texto(),texto.Texto()) > 0);
}

bool String::operator>(char texto) {
  String tst(texto);
  return (*this > tst);
}

bool String::operator>(int texto) { 
  String tst(texto);
  return (*this > tst);
}

bool String::operator>(double texto) { 
  String tst(texto);
  return (*this > tst);
}

bool String::operator>(float  texto) { 
  String tst(texto);
  return (*this > tst);
}

bool String::operator>(long texto) { 
  String tst(texto);
  return (*this > tst);
}



bool String::operator<=(const char *texto) { 
  return (strcmp(Texto(),texto) <= 0);
}

bool String::operator<=(String texto) { 
  return (strcmp(Texto(),texto.Texto()) <= 0);
}

bool String::operator<=(char texto) {
  String tst(texto);
  return (*this <= tst);
}

bool String::operator<=(int texto) { 
  String tst(texto);
  return (*this <= tst);
}

bool String::operator<=(double texto) { 
  String tst(texto);
  return (*this <= tst);
}

bool String::operator<=(float  texto) { 
  String tst(texto);
  return (*this <= tst);
}

bool String::operator<=(long texto) { 
  String tst(texto);
  return (*this <= tst);
}



bool String::operator>=(const char *texto) { 
  return (strcmp(Texto(),texto) >= 0);
}

bool String::operator>=(String texto) { 
  return (strcmp(Texto(),texto.Texto()) >= 0);
}

bool String::operator>=(char texto) {
  String tst(texto);
  return (*this >= tst);
}

bool String::operator>=(int texto) { 
  String tst(texto);
  return (*this >= tst);
}

bool String::operator>=(double texto) { 
  String tst(texto);
  return (*this >= tst);
}

bool String::operator>=(float  texto) { 
  String tst(texto);
  return (*this >= tst);
}

bool String::operator>=(long texto) { 
  String tst(texto);
  return (*this >= tst);
}


bool String::operator!=(const char *texto) { 
  return (strcmp(Texto(),texto) != 0);
}

bool String::operator!=(String texto) { 
  return (strcmp(Texto(),texto.Texto()) != 0);
}

bool String::operator!=(char texto) {
  String tst(texto);
  return (*this != tst);
}

bool String::operator!=(int texto) { 
  String tst(texto);
  return (*this != tst);
}

bool String::operator!=(double texto) { 
  String tst(texto);
  return (*this != tst);
}

bool String::operator!=(float  texto) { 
  String tst(texto);
  return (*this != tst);
}

bool String::operator!=(long texto) { 
  String tst(texto);
  return (*this != tst);
}




int String::Para_Int() {
  return atoi(Texto());
}

double String::Para_Double() {
  return atof(Texto());
}

long String::Para_Long() {
  return atol(Texto());
}


Lista_Simples<String> *String::Quebra(char delimitador) {
  String vazio("");
  Lista_Simples<String> *lista = new Lista_Simples<String>(vazio);
  Lista_Simples<String> *laux;
  char *texto = Texto();
  String aux;
  bool primeiro=true;

  aux = "";
  laux = lista;

  while (*texto != '\0') {
    if (*texto != delimitador) {
      aux += *texto;
    } else {
      if (primeiro) {
	laux->Muda_Valor(aux);
	primeiro=false;
      } else {
	laux->Add_Depois(aux);
	laux = laux->Proximo();
      }
      aux = "";
    }
    texto++;
  }

  if (strlen(aux.Texto()) >0) {
    if (primeiro)
      laux->Muda_Valor(aux);
    else
      laux->Add_Depois(aux);
  }

  return lista;
}