/**
 * Copyright 1999, 2000 by PC Drew
 *
 * All rights reserved.
 *
 * This file is a part of the gstring class - a string class for
 * C++ programs.
 *
 * The gstring class, including all files distributed with it,
 * is free software; you can redistribute it and/or use it and/or modify it
 * under the terms of the Python License (http://www.python.org/doc/Copyright.html)
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 */

#include "gstring.h"

/**
 * Precondition: none.
 * Postcondition: a new gstring is created, with an empty  string.
 */
gstring::gstring(void)
{
    create("");
}

/**
 * Precondition: _s is a char.
 * Postcondition: a new gstring is returned, with the value of _s.
 */
/*gstring::gstring(char _s)
{
    create((char*)_s);
}*/

/**
 * Precondition: _str is a char*.
 * Postcondition: a new gstring is returned, with the value of _str.
 */
gstring::gstring(char* _str)
{
    create(_str);
}

/**
 * Precondition: _x is an integer.
 * Postcondition: a new gstring is returned, with the string value of _x.
 */
gstring::gstring(int _x)
{
    char* str = new char;

    sprintf(str, "%i", _x);
    create(str);

    delete [] str;
}

/**
 * Precondition: _y is an double.
 * Postcondition: a new gstring is returned, with the string value of _y.
 */
gstring::gstring(double _y)
{
    char* str = new char;

    sprintf(str, "%f", _y);
    create(str);

    delete [] str;
}

/**
 * Precondition: _gstr is a gstring.
 * Postcondition: a copy of the existing gstring is returned.
 */
gstring::gstring(const gstring& _gstr)
{
    create((char*)_gstr);
}

/**
 * Precondition: none.
 * Postcondition: the current gstring is destroyed.
 */
gstring::~gstring(void)
{
    destroy();
}

/**
 * Precondition: _str is a char*.
 * Postcondition: _str is copied into the new gstring.
 */
int gstring::create(char* _str)
{
    assert(_str != NULL);

    // We want to create our own char*, instead of using
    // strdup() because new will never return NULL, and
    // malloc() (used by strdup()) might.
    str = new char[strlen(_str)];
    strcpy(str, _str);

    return 0;
}

/**
 * Precondition: none.
 * Postcondition: the current gstring is deleted.
 */
int gstring::destroy(void)
{
    delete [] str;

    return 0;
}

/**
 * Precondition: _index is the first char in the substring, starting at 0,
 *   _num is the number of chars in the substring.
 * Postcondition: the substring starting at _index and going _num chars
 *   in length is returned, as a gstring.
 */
gstring gstring::at(int _index, int _num)
{
    int len = length();

    assert(_index >= 0 && _num >= 1 && _index <= len - _num);

    char* temp_str = new char[len - _index];
    char* begin = str;
    char* end = temp_str;

    // Go to the character that is at _index and copy the
    // rest of the char* to temp_str.
    begin += _index;
    strcpy(temp_str, begin);

    // Go to the character that is at _index + _num and set
    // it equal to the null terminator.
    end += _num;
    *end = '\0';

    // Create a new gstring from the substring that we extracted.
    gstring gstr(temp_str);

    // Clean up.
    delete [] temp_str;

    return gstr;
}

/**
 * Precondition: _num is either an integer >= 1 or it is not specified.
 *   If the function is called without any args (i.e. first()), then
 *   _num = 1 by default.
 * Postcondition: the substring from the beginning of the string, going
 *   _num chars in length is returned.
 */
gstring gstring::first(int _num)
{
    return (at(0, _num));
}

/**
 * Precondition: _num is either an integer >= 1 or it is not specified.
 *   If the function is called without any args (i.e. first()), then
 *   _num = 1 by default.
 * Postcondition: the substring _num chars from the end of the string, going
 *   to the end of the string is to returned.
 */
gstring gstring::last(int _num)
{
    return (at(length() - _num, _num));
}

/**
 * Precondition: _num is the number of times you want the string repeated.
 * Postcondition: the current string is changed to be the current string,
 *   repeated _num times.
 */
gstring& gstring::repeatme(int _num)
{
    assert(str != NULL && _num >= 1);

    char* temp_str = new char[length() * _num];

    // Tack str onto the end of temp_str, _num times.
    for (int i = 0; i < _num; i++) {
        strcat(temp_str, str);
    }

    destroy();
    create(temp_str);

    delete [] temp_str;

    return *this;
}

/**
 * Precondition: _token is a char*.
 * Postcondition: returns the number of occurences of _token in the string.
 */
int gstring::ntokens(char* _token)
{
  char* temp_str = str;
  int len = strlen(_token);
  int i = 0;

  assert(_token != NULL && len >= 1);

  // Iterate through the string...
  for ( ; *temp_str != '\0'; temp_str++) {
    if (*temp_str == *_token && strncmp(_token, temp_str, len) == 0) {
      i++;
    }
  }

  return i;
}

/**
 * Precondition: _token is a char*.
 * Postcondition: an array of gstrings is returned.  The contents of each
 *   gstring in the array is the value either from the beginning of the
 *   original string to the first occurance of _token or from one occurance
 *   of _token to the next.  _token will not be returned in any of the strings.
 *
 * **NOTE**
 * Don't initialize you're array (i.e. call "new") before calling
 * this function...this function will do that for you.  You do, however,
 * need to call "delete [] array" in your own code.
 */
gstring* gstring::explode(char* _token)
{
    assert(_token != NULL && strlen(_token) >= 1);

    int i;
    int n = nfields(_token);
    char* ptr;
    char* temp_str = new char[length()];
    gstring* arr = new gstring[n];

    strcpy(temp_str, str);
    for (i = 0, ptr = strtok(temp_str, _token); ptr != NULL;
            i++, ptr = strtok(NULL, _token)) {
        arr[i] = ptr;
    }

    delete [] temp_str;

    return arr;
}

/**
 * Precondition: _arr is an array of char*'s and _token is a char*, one or more characters
 *     in length.
 * Postcondition: value returned is each char* in the array joined
 *     together by _token.
 */
gstring implode(char** _arr, char* _token, int _num)
{
    assert(_arr != NULL && _token != NULL && strlen(_token) >= 1);

    gstring s = _arr[0];

    for (int i = 1; i < _num; i++) {
        s.append(_token);
        s.append(_arr[i]);
    }

    return s;
}

/**
 * Precondition: _arr is an array of gstrings and _token is a char*, one or more characters
 *     in length.
 * Postcondition: value returned is each gstring in the array joined
 *     together by _token.
 */
gstring implode(gstring* _arr, char* _token, int _num)
{
    assert(_arr != NULL && _token != NULL);

    gstring s = _arr[0];

    for (int i = 1; i < _num; i++) {
        s.append(_token + _arr[i]);
    }

    return s;
}

/**
 * Precondition: _x is the number of characters to chop off the end of the string.
 *     The default value (chop called without any parameters) is 1 -- the last
 *     character will be removed.
 * Postcondition: the current gstring has the last _x characters removed from the string.
 *     together by _token.
 */
gstring& gstring::chop(int _x)
{
    int len = length() - _x;
    char* temp_str = new char[len];

    assert(_x >= 0);

    // This allows implode to join the strings together with a "" string (nothing).
    if (_x > 0) {
        strcpy(temp_str, str);
        temp_str[len] = '\0';

        destroy();
        create(temp_str);
    }

    delete [] temp_str;

    return *this;
}

/**
 * Precondition: _str is not NULL.
 * Postcondition: _str is appended to current gstring.
 */
gstring& gstring::append(char* _str)
{
    assert(_str != NULL);

    char* temp_str = new char[length() + strlen(_str)];

    strcpy(temp_str, str);
    strcat(temp_str, _str);

    destroy();
    create(temp_str);

    delete [] temp_str;

    return *this;
}

/**
 * Precondition: _str is not NULL.
 * Postcondition: _str is prepended to current gstring.
 */
gstring& gstring::prepend(char* _str)
{
    assert(_str != NULL);

    char* temp_str = new char[strlen(_str) + length()];

    strcpy(temp_str, _str);
    strcat(temp_str, str);

    destroy();
    create(temp_str);

    delete [] temp_str;

    return *this;
}

/**
 * Precondition: current gstring is not NULL.
 * Postcondition: current gstring is converted to uppercase.
 */
gstring& gstring::upcaseme(void)
{
    char* ptr = str;
    int len = length();

    assert(str != NULL);

    for (int i = 0; i < len; i++, ptr++) {
        *ptr = (char)toupper((int) * ptr);
    }

    return *this;
}

/**
 * Precondition: current gstring is not equal to NULL.
 * Postcondition: current gstring is converted to lowercase.
 */
gstring& gstring::downcaseme(void)
{
    char* ptr = str;
    int len = length();

    assert(str != NULL);

    for (int i = 0; i < len; i++, ptr++) {
        *ptr = (char)tolower((int) * ptr);
    }

    return *this;
}

/**
 * Precondition: _gstrarr is an array of gstrings and _num is the number of
 *   gstrings in the array.
 * Postcondition: the value returned is an exact copy of _gstrarr, only it
 *   it is an array of char*'s instead.
 */
char** tochararray(gstring* _gstrarr, int _num)
{
    char** strarr = new char * [_num];

    for (int i = 0; i < _num; i++) {
        strarr[i] = (char*)_gstrarr[i];
    }

    return strarr;
}

/**
 * Precondition: _strarr is an array of char*s and _num is the number of
 *   char*'s in the array.
 * Postcondition: the value returned is an exact copy of _strarr, only it
 *   it is an array of gstrings instead.
 */
gstring* togstringarray(char** _strarr, int _num)
{
    gstring* gstrarr = new gstring[_num];

    for (int i = 0; i < _num; i++) {
        gstrarr[i] = _strarr[i];
    }

    return gstrarr;
}

/*gstring& gstring::operator =(char _s)
{
    assert(_s != NULL);

    if (str != NULL) {
        destroy();
    }
    create((char*)_s);
    return *this;
}*/

gstring& gstring::operator =(char* _str)
{
    assert(_str != NULL);

    if (str != NULL) {
        destroy();
    }
    create(_str);
    return *this;
}

gstring& gstring::operator =(int _x)
{
  assert(_x != 0/*NULL*/);

  char* temp_str = new char;

  if (str != NULL) {
    destroy();
  }

  sprintf(temp_str, "%i", _x);
  create(temp_str);

  delete [] temp_str;
  return *this;
}

gstring& gstring::operator =(double _y)
{
  assert(_y != 0/*NULL*/);

  char* temp_str = new char;

  if (str != NULL) {
    destroy();
  }

  sprintf(temp_str, "%f", _y);
  create(temp_str);

  delete [] temp_str;
  return *this;
}

gstring& gstring::operator =(const gstring& _gstr)
{
    assert((char*)_gstr != NULL);

    if (str != NULL) {
        destroy();
    }

    create((char*)_gstr);

    return *this;
}

/*istream& operator >>(istream& in, gstring& _gstr)
{
    char** temp_str = new char * [1];

    in.gets(temp_str);
    _gstr = temp_str[0];

    delete [] temp_str[0];
    delete [] temp_str;

    return in;
}*/