Page suivantePage précédenteTable des matières

16. Annexe C String.cpp

Vous pouvez récupérer tous les programmes en un seul tar.gz sur Telecharger String . Pour obtenir ce fichier, dans un butineur web, sauvez ce fichier en type 'texte'.


//
// Auteur : Al Dev
// Utilisez la classe string ou cette classe
//
// Pour prévenir les fuites de mémoire - une classe caractère qui gère les
// variables caractères.
// Préférez toujours l'utilisation de la classe string à char[] et char *.
//
//
// Pour compiler et tester ce programme, utilisez -
//              g++ String.cpp
#include "String.h"
//#include <sys/va_list.h> pour Format()
//#include <sys/varargs.h> pour Format()
// Variables globales....
//String *String::_global_String = NULL; // variable globale
list<String>                 String::explodeH;
String::String()
{
 debug_("In cstr()", "ok");
 sval = (char *) my_malloc(sizeof(char)* INITIAL_SIZE);
 _pString = NULL;
}
String::String(char *bb)
{
 unsigned long tmpii = strlen(bb);
 sval = (char *) my_malloc(sizeof(char)* tmpii);
 strncpy(sval, bb, tmpii);
 sval[tmpii] = '\0';
 //debug_("In cstr(char *bb) bb", bb);
 debug_("In cstr(char *bb) sval", sval);
 #ifdef DEBUG
 //fprintf(stderr, "\nAddress of sval=%x\n", & sval);
 //fprintf(stderr, "\nAddress of this-pointer=%x\n", this);
 #endif // DEBUG
 _pString = NULL;
}
String::String(char *bb, int start, int slength)
{
 unsigned long tmpii = strlen(bb);
 if (start> (int) tmpii || start < 0)
 {
 cerr << "\nString(char *, int, int) - start is  out of bounds!!\n" << endl;
 exit(1);
 }
 sval = (char *) my_malloc(sizeof(char)* slength);
 strncpy(sval, & bb[start], slength);
 sval[slength] = '\0';
 //debug_("In cstr(char *bb) bb", bb);
 debug_("In cstr(char *bb) sval", sval);
 #ifdef DEBUG
 //fprintf(stderr, "\nAddress of sval=%x\n", & sval);
 //fprintf(stderr, "\nAddress of this-pointer=%x\n", this);
 #endif // DEBUG
 _pString = NULL;
}
String::String(int bb)
{
 sval = (char *) my_malloc(NUMBER_LENGTH); // int avec 70 chiffres max
 sprintf(sval, "%d", bb);
 debug_("In cstr(int bb) sval", sval);
 _pString = NULL;
}
String::String(unsigned long bb)
{
 sval = (char *) my_malloc(NUMBER_LENGTH); // unsigned long avec 70 chiffres max
 sprintf(sval, "%lu", bb);
 debug_("In cstr(unsigned long bb) sval", sval);
 _pString = NULL;
}
String::String(long bb)
{
 sval = (char *) my_malloc(NUMBER_LENGTH); // long avec 70 chiffres max
 sprintf(sval, "%ld", bb);
 debug_("In cstr(long bb) sval", sval);
 _pString = NULL;
}
String::String(float bb)
{
 sval = (char *) my_malloc(NUMBER_LENGTH); // float avec 70 chiffres max
 sprintf(sval, "%f", bb);
 debug_("In cstr(float bb) sval", sval);
 _pString = NULL;
}
String::String(double bb)
{
 sval = (char *) my_malloc(NUMBER_LENGTH); // double avec 70 chiffres max
 sprintf(sval, "%f", bb);
 debug_("In cstr(double bb) sval", sval);
 _pString = NULL;
}
// Constructeur par recopie utilisé par l'opérateur +
String::String(const String & rhs)
{
 // Effectue une copie en profondeur à la place de la copie superficielle par défaut du compilateur
 debug_("In copy-cstr()", "ok");
 unsigned long tmpii = strlen(rhs.sval);
 sval = (char *) my_malloc(sizeof(char)* tmpii);
 strncpy(sval, rhs.sval, tmpii);
 sval[tmpii] = '\0';
 _pString = NULL;
}
// Cette fonction fournit une compatibilité avec le code Java
String::String(StringBuffer sb)
{
 debug_("In String(StringBuffer)", "ok");
 unsigned long tmpii = strlen(sb.sval);
 sval = (char *) my_malloc(sizeof(char)* tmpii);
 strncpy(sval, sb.sval, tmpii);
 sval[tmpii] = '\0';
 _pString = NULL;
}
// Utilisé par la classe StringBuffer. Utilise la variable dummy
// pour différentes signatures.
// La classe StringBuffer imite le StringBuffer de Java
String::String(int size, bool dummy)
{
 sval = (char *) my_malloc(sizeof(char)* size);
 debug_("In cstr(int size, bool dummy) sval", sval);
 #ifdef DEBUG
 //fprintf(stderr, "\nAddress of sval=%x\n", & sval);
 //fprintf(stderr, "\nAddress of this-pointer=%x\n", this);
 #endif // DEBUG
 _pString = NULL;
}
String::~String()
{
 debug_("In dstr sval", sval);
 #ifdef DEBUG
 //fprintf(stderr, "\nAddress of sval=%x\n", & sval);
 //fprintf(stderr, "\nAddress of this-pointer=%x\n", this);
 #endif // DEBUG
 my_free(sval);
 //delete [] sval;
 sval = NULL;
 delete _pString; _pString = NULL;
}
inline void String::_allocpString()
{
 // _pString will be deleted in destructor
 if (!_pString)  // if (_pString == NULL)
 _pString = new String(this->sval);
 else
 *_pString = this->sval;
}
// DOIT utiliser un pointeur-sur-pointeur **aa, sinon la mémoire utilisée
// par l'argument N'est PAS libérée !
/*
inline void String::_free_glob(String **aa)
{
 debug_("called _free_glob()", "ok" );
 if (*aa != NULL)  // (*aa != NULL)
 {
 debug_("*aa is not null", "ok");
 delete *aa;
 *aa = NULL;
 }
 //else
 debug_("*aa is null", "ok");
 //if (*aa == NULL)
 debug_("*aa set to null", "ok");
}
*/
// Imite le charAt de java.lang.String
char String::charAt(int where)
{
 verifyIndex(where);
 return (sval[where]);
}
// Imite la fonction getChars de java.lang.String
// sourceStart spécifie l'indice du début de la sous-chaîne
// et sourceEnd spécifie l'indice juste après la fin de la sous-chaîne désirée
// Ainsi la sous-chaîne contient les caractères de sourceStart jusqu'à
// (sourceEnd - 1). Le tableau qui va recevoir les caractères est target.
// targetStart est l'indice dans target à partir duquel la copie sera effectuée.
// Il convient de s'assurer que le tableau target est assez grand pour pouvoir contenir
// le nombre de caractères désiré.
// Par exemple  getChars(3, 6, aa, 0) sur "ABCDEFGHIJK" donne aa ="DEF"
void String::getChars(int sourceStart, int sourceEnd, char target[], int targetStart)
{
 verifyIndex(sourceStart);
 verifyIndex(sourceEnd);
 if (sourceEnd>= sourceStart)
 {
 strncpy(& target[targetStart], & sval[sourceStart], sourceEnd - sourceStart);
 target[targetStart + (sourceEnd - sourceStart)] = 0;
 }
 else
 {
 cerr << "\ngetChars() - SourceEnd is greater than SourceStart!!\n" << endl;
 exit(1);
 }
}
// Imite getChars de java.lang.String
// Retourne un tableau caractères contenant la chaîne entière
char* String::toCharArray()
{
 return (sval);
}
// Imite getBytes de java.lang.String
// Retourne un tableau caractères contenant la chaîne entière
char* String::getBytes()
{
 return (sval);
}
// Imite equals de java.lang.String
bool String::equals(String str2)  // voir aussi l'opérateur ==
{
 return ( _equalto(str2.sval));
}
// Imite equals de java.lang.String
bool String::equals(char *str2)  // voir aussi l'opérateur ==
{
 return ( _equalto(str2));
}
// Imite equalsIgnoreCase de java.lang.String
bool String::equalsIgnoreCase(String str2)
{
 String  aa, bb;
 aa = this->toLowerCase();
 bb = str2.toLowerCase();
 return ( aa._equalto(bb.sval) );
}
// Imite regionMatches de java.lang.String
// startIndex spécifie l'indice à partir duquel débute la région dans l'objet
// String invoquant la méthode. La chaîne est comparée à str2. L'indice à partir
// duquel la comparaison commencera dans str2 est spécifié par str2Index
// La longueur de la sous-chaîne comparée est numChars.
bool String::regionMatches(int startIndex, String str2, int str2StartIndex, int numChars)
{
 verifyIndex(startIndex);
 str2.verifyIndex(str2StartIndex);
 if (strncmp(& this->sval[startIndex], & str2.sval[str2StartIndex], numChars) == 0)
 return true;
 else
 return false;
}
// Imite regionMatches de java.lang.String
// Il s'agit de la version surchargée de regionMatches
// Si ignoreCase vaut true, la casse des caractères est ignorée, sinon
// la casse est significative (i.e. si ignoreCase vaut true alors ignore la
// casse et compare)
// startIndex spécifie l'indice à partir duquel débute la region dans l'objet
// String invoquant la méthode. La chaîne est comparée à str2. L'indice à partir
// duquel la comparaison commencera dans str2 est spécifié par str2Index
// La longueur de la sous-chaîne comparée est numChars.
bool String::regionMatches(bool ignoreCase, int startIndex, String str2, int str2StartIndex, int numChars)
{
 if (ignoreCase)  // if (ignoreCase == true)
 {
 verifyIndex(startIndex);
 str2.verifyIndex(str2StartIndex);
 String string1, string2;
 string1 = this->toLowerCase();
 string2 = str2.toLowerCase();
 if (strncmp(& string1.sval[startIndex], & string2.sval[str2StartIndex], numChars) == 0)
 return true;
 else
 return false;
 }
 else
 {
 return regionMatches(startIndex, str2, str2StartIndex, numChars);
 }
}
// Imite toLowerCase de java.lang.String
//       String  ss("sometest");
//       String  egg = ss.toLowerCase();
String String::toLowerCase()
{
 _allocpString();
 for (long tmpii = strlen(_pString->sval); tmpii>= 0; tmpii--)
 {
 _pString->sval[tmpii] = tolower(_pString->sval[tmpii]);
 }
 return *_pString;  // return the object now
}
// Imite toUpperCase de java.lang.String
//       String  ss("sometest");
//       String  egg = ss.toUpperCase();
String String::toUpperCase()
{
 _allocpString();
 for (long tmpii = strlen(_pString->sval); tmpii>= 0; tmpii--)
 {
 _pString->sval[tmpii] = toupper(_pString->sval[tmpii]);
 }
 return *_pString;  // return the object now
}
// Imite startsWith de java.lang.String
bool String::startsWith(String str2)
{
 if (!strncmp(this->sval, str2.sval, strlen(str2.sval) )) // if (strncmp() == 0)
 return true;
 else
 return false;
}
// Imite startsWith de java.lang.String
// Fonction surchargée
bool String::startsWith(char *str2)
{
 int lenstr2 = strlen(str2);
 if (!strncmp(this->sval, str2, lenstr2)) // if (strncmp() == 0)
 return true;
 else
 return false;
}
// Imite endsWith de java.lang.String
bool String::endsWith(String str2)
{
 // str2 doit être plus courte que la chaîne courante
 if (strlen(str2.sval)> strlen(sval))
 return false;
 if (!strncmp(& this->sval[strlen(sval) - strlen(str2.sval)], str2.sval, strlen(str2.sval) )) // if (strncmp() == 0)
 return true;
 else
 return false;
}
// Imite endsWith de java.lang.String
bool String::endsWith(char *str2)
{
 // str2 doit être plus courte que la chaîne courante
 if (strlen(str2)> strlen(sval))
 return false;
 if (!strncmp(& this->sval[strlen(sval) - strlen(str2)], str2, strlen(str2) ) ) // if (strncmp() == 0)
 return true;
 else
 return false;
}
// Imite compareTo de java.lang.String
// Pour les tris, vous devez savoir si l'un est plus petit, égal ou plus grand que l'autre.
// Une chaîne est plus petite qu'une autre si elle arrive avant l'autre dans l'ordre
// lexicographique. Un chaîne est plus grande qu'une autre si elle arrive après.
//  Négatif  --> la chaîne courante est plus petite que str2
//  Positif  --> la chaîne courante est plus grande que str2
//  Zero  --> les deux chaînes sont égales
int String::compareTo(String str2)
{
 int  flag = 0;
 // Compare les lettres dans la chaîne à chaque lettre de str2
 for (int tmpii = 0, tmpjj = strlen(sval), tmpkk = strlen(str2.sval); tmpii < tmpjj; tmpii++)
 {
 if (tmpii> tmpkk)
 break;
 if (sval[tmpii] == str2.sval[tmpii])
 flag = 0;
 else
 if (sval[tmpii]> str2.sval[tmpii])
 {
 flag = 1;
 break;
 }
 else // if (sval[tmpii] < str2.sval[tmpii])
 {
 flag = -1;
 break;
 }
 }
 return flag;
}
// Imite compareTo de java.lang.String
// Fonction surchargée de compareTo
int String::compareTo(char *str2)
{
 int  flag = 0;
 // Compare les lettres de la chaîne courante avec chaque lettre de str2
 for (int tmpii = 0, tmpjj = strlen(sval), tmpkk = strlen(str2); tmpii < tmpjj; tmpii++)
 {
 if (tmpii> tmpkk)
 break;
 if (sval[tmpii] == str2[tmpii])
 flag = 0;
 else
 if (sval[tmpii]> str2[tmpii])
 {
 flag = 1;
 break;
 }
 else // if (sval[tmpii] < str2[tmpii])
 {
 flag = -1;
 break;
 }
 }
 return flag;
}
// Imite compareToIgnoreCase de java.lang.String
int String::compareToIgnoreCase(String str2)
{
 String tmpaa = this->toLowerCase(),
 tmpbb = str2.toLowerCase();
 return tmpaa.compareTo(tmpbb);
}
// Imite compareToIgnoreCase de java.lang.String
// Version surchargée
int String::compareToIgnoreCase(char *str2)
{
 String tmpaa = this->toLowerCase(),
 tmpcc(str2), tmpbb = tmpcc.toLowerCase();
 return tmpaa.compareTo(tmpbb);
}
// Imite indexOf de java.lang.String
// Cherche la premiere occurrence d'un caractère ou d'une chaîne.
// Retourne l'indice à partir duquel le caractère ou la chaîne
// a été trouvé, ou -1 en cas d'échec.
int String::indexOf(char ch, int startIndex = 0)
{
 verifyIndex(startIndex);
 int ii = startIndex;
 for (; ii < (int) strlen(sval); ii++)
 {
 if (sval[ii] == ch)
 break;
 }
 if (ii == (int) strlen(sval))
 return -1;
 return ii;
}
// Imite indexOf de java.lang.String
// Version surchargée
int String::indexOf(char *str2, int startIndex = 0)
{
 verifyIndex(startIndex);
 char * tok;
 long res = -1;
 if ( !isNull() )
 {
 tok = strstr(sval + startIndex, str2);
 if (tok == NULL)
 res = -1;
 else
 res = (int) (tok - sval);
 }
 return res;
}
// Imite indexOf de java.lang.String
// Version surchargée
int String::indexOf(String str2, int startIndex = 0)
{
 verifyIndex(startIndex);
 char * tok;
 long res = -1;
 if ( !isNull() )
 {
 tok = strstr(sval + startIndex, str2.sval);
 if (tok == NULL)
 res = -1;
 else
 res = (int) (tok - sval);
 }
 return res;
}
// Imite lastIndexOf de java.lang.String
// Cherche pour la dernière occurrence d'un caractère ou d'une chaîne.
// Retourne l'indice à partir duquel le caractère ou la chaîne a été trouvé
// ou -1 en cas d'échec.
int String::lastIndexOf(char ch, int startIndex = 0)
{
 verifyIndex(startIndex);
 int ii;
 // Commence la recherche par le dernier caractère de la chaîne
 if (!startIndex) // if (startIndex == 0)
 ii = strlen(sval);
 else
 ii = startIndex;
 for (; ii> -1; ii--)
 {
 if (sval[ii] == ch)
 break;
 }
 if (!ii && sval[ii] != ch) // if (ii == 0)
 return -1;
 return ii;
}
// Imite lastIndexOf de java.lang.String
// Version surchargée
int String::lastIndexOf(char *str2, int startIndex = 0)
{
 verifyIndex(startIndex);
 char *tok = NULL;
 int res = -1;
 register char *tmpaa = strdup(sval);  // ici malloc
 if (!tmpaa) // tmpaa == NULL
 {
 cerr << "\nMemory alloc failed in strdup in lastIndexOf()\n" << endl;
 exit(-1);
 }
 if (!startIndex) // if (startIndex == 0)
 startIndex = strlen(sval);
 else
 tmpaa[startIndex+1] = 0;
 for (int ii = 0; ii <= startIndex; ii++)
 {
 tok = strstr(& tmpaa[ii], str2);
 if (tok == NULL)
 break;
 else
 {
 res = (int) (tok - tmpaa);
 debug_("res", res);
 ii = res; // saute vers l'endroit qui correspond (+1 dans la boucle for)
 }
 }
 free(tmpaa);
 debug_("res", res);
 debug_("indexOf", & sval[res]);
 return res;
}
// Imite lastIndexOf de java.lang.String
// Version surchargée
int String::lastIndexOf(String str2, int startIndex = 0)
{
 verifyIndex(startIndex);
 char *tok = NULL;
 int res = -1;
 register char *tmpaa = strdup(sval);  // ici malloc
 if (!tmpaa) // tmpaa == NULL
 {
 cerr << "\nMemory alloc failed in strdup in lastIndexOf()\n" << endl;
 exit(-1);
 }
 if (!startIndex) // if (startIndex == 0)
 startIndex = strlen(sval);
 else
 tmpaa[startIndex+1] = 0;
 for (int ii = 0; ii <= startIndex; ii++)
 {
 tok = strstr(& tmpaa[ii], str2.sval);
 if (tok == NULL)
 break;
 else
 {
 res = (int) (tok - tmpaa);
 debug_("res", res);
 ii = res; // saute vers l'endroit qui correspond (+1 dans la boucle for)
 }
 }
 free(tmpaa);
 debug_("res", res);
 debug_("indexOf", & sval[res]);
 return res;
}
// Imite substring de java.lang.String
// startIndex spécifie l'indice de début, et endIndex l'indice de fin.
// La chaîne retournée contient tous les caractères de l'indice de début
// jusqu'à l'indice de fin, mais sans l'inclure.
String String::substring(int startIndex, int endIndex = 0)
{
 String tmpstr = String(sval);
 tmpstr._substring(startIndex, endIndex);
 return tmpstr;
}
// Imite concat de java.lang.String
String String::concat(String str2)
{
 return (*this + str2);
}
// Imite concat de java.lang.String
// Version surchargée
String String::concat(char *str2)
{
 return (*this + str2);
}
// Imite replace de java.lang.String
// Remplace toutes les occurrences de la chaîne 'original' par
// 'replacement' dans 'sval'
String String::replace(char original, char replacement)
{
 // Par exemple -
 //              replace('A', 'B') dans sval = "des AAA et AAACC"
 //              retourne sval = "des BBB et BBBCC"
 //String *tmpstr = new String(sval); Utilise le constructeur de recopie par défaut
 String tmpstr(sval);
 for (int ii = 0, len = strlen(sval); ii < len; ii++)
 {
 if (tmpstr.sval[ii] == original)
 tmpstr.sval[ii] = replacement;
 }
 return tmpstr; // utilise le constructeur de recopie pour faire une copie
}
// Imite replace de java.lang.String
// Version surchargée
// Remplace toutes les occurrences de la chaîne 'original' par
// 'replacement' dans 'sval'
String String::replace(char *original, char *replacement)
{
 char *tok = NULL, *bb;
 register char *aa = strdup(sval);
 int lenrepl = strlen(replacement);
 // Alloue l'espace pour bb
 { // portée locale
 int tmpii = 0;
 for (int ii = 0; ;ii++)
 {
 tok = strstr(& aa[ii], original);
 if (tok == NULL)
 break;
 else
 {
 ii = ii + (int) (tok -aa);
 tmpii++;
 }
 }
 if (!tmpii) // tmpii == 0, pas de 'original' trouvé
 return (String(sval)); // retourne la chaîne originale
 tmpii = strlen(sval) + (tmpii * lenrepl) + 20;
 debug_("strstr tmpii", tmpii );
 bb = (char *) malloc(tmpii);
 memset(bb, 0, tmpii);
 }
 for (int res = -1; ;)
 {
 debug_("aa", aa);
 tok = strstr(aa, original);
 if (tok == NULL)
 {
 strcat(bb, aa);
 break;
 }
 else
 {
 res = (int) (tok - aa);
 strncat(bb, aa, res);
 strcat(bb, replacement);
 //bb[strlen(bb)] = 0;
 debug_("res", res );
 debug_("bb", bb );
 strcpy(aa, & aa[res+lenrepl]);
 }
 }
 debug_("bb", bb );
 free(aa);
 String tmpstr(bb);
 free(bb);
 return tmpstr;
}
/*
une autre méthode pour faire le remplacement mais lente...
String String::replace(char *original, char *replacement)
{
 // Par exemple -
 //              replace("AAA", "BB") avec sval = "des AAA et AAACC"
 //              retourne sval = "des BB et BBCC"
 String bb(this->before(original).sval);
 if (strlen(bb.sval) == 0)
 return String(sval); // retourne la chaîne originale
 bb += replacement;
 String tmpaa(this->sval), cc, dd;
 for (;;)
 {
 cc = tmpaa.after(original).sval;
 debug_("cc", cc.sval );
 if (!strlen(cc.sval)) // if (strlen(cc.sval) == 0)
 break;
 dd = cc.before(original).sval;
 if (strlen(dd.sval) == 0)
 {
 bb += cc;
 break;
 }
 else
 {
 bb += dd;
 bb += replacement;
 }
 tmpaa = cc;
 }
 debug_("bb.sval", bb.sval );
 return bb;
}
*/
// Imite replace de Java -  StringBuffer
String String::replace (int startIndex, int endIndex, String str)
{
 verifyIndex(startIndex);
 verifyIndex(endIndex);
 int tmpjj = strlen(str.sval);
 if (tmpjj == 0)
 return *this;
 int tmpii = endIndex-startIndex-1;
 if (tmpjj < tmpii) // la longueur de str est plus petite que les indices specifies.
 tmpii = tmpjj;
 debug_("sval", sval);
 debug_("str.sval", str.sval);
 strncpy(& sval[startIndex], str.sval, tmpii);
 sval[startIndex+tmpii] = 0;
 debug_("sval", sval);
 return *this;
}
// Imite trim de java.lang.String
String String::trim()
{
 //String *tmpstr = new String(sval);
 String tmpstr(sval);
 tmpstr._trim();
 debug_("tmpstr.sval", tmpstr.sval);
 return tmpstr; // utilise le constructeur par recopie pour faire une copie
}
// Imite insert de java.lang.String
String String::insert(int index, String str2)
{
 String tmpstr(this->insert(str2.sval, index).sval);
 debug_("tmpstr.sval", tmpstr.sval);
 return tmpstr;
}
// Imite insert de java.lang.String
String String::insert(int index, char ch)
{
 char aa[2];
 aa[0] = ch;
 aa[1] = 0;
 String tmpstr(this->insert(aa, index).sval);
 debug_("tmpstr.sval", tmpstr.sval);
 return tmpstr;
}
// Imite deleteCharAt de java.lang.String
String String::deleteCharAt(int loc)
{
 String tmpstr(sval);
 tmpstr._deleteCharAt(loc);
 return tmpstr;
}
// Imite delete de java.lang.String
// Note : -->le nom Java est "delete()", mais c'est un mot résérvé inutilisable en C++
// startIndex spécifie l'indice du premier caractère à enlever,
// et endIndex l'indice juste après le dernier caractère à supprimer.
// Ainsi, la sous-chaîne supprimée s'etend de startIndex à (endIndex - 1).
String String::deleteStr(int startIndex, int endIndex)
{
 // Par exemple -
 //      deleteStr(3,3) avec val = 'pokemon' retourne 'poon'
 String tmpstr(sval);
 tmpstr._deleteStr(startIndex, endIndex);
 return tmpstr;
}
// Imite reverse de java.lang.String
String String::reverse()
{
 // Par exemple :
 //              reverse() sur "12345" retourne "54321"
 String tmpstr(sval);
 tmpstr._reverse();
 return tmpstr;
}
// Imite valueOf de java.lang.String
String String::valueOf(char chars[], int startIndex, int numChars)
{
 verifyIndex(startIndex);
 int ii = strlen(chars);
 if (startIndex> ii)
 {
 cerr << "\nvalueOf() - startIndex greater than string length of"
 << "string passed" << endl;
 exit(0);
 }
 if ( (numChars+startIndex)> ii)
 {
 cerr << "\nvalueOf() - numChars exceeds the string length of"
 << "string passed" << endl;
 exit(0);
 }
 char *aa = strdup(chars);
 aa[startIndex + numChars] = 0;
 String tmpstr(& aa[startIndex]);
 free(aa);
 return tmpstr;
}
// Imite ensureCapacity de java.lang.String
// Utilisé par la classe StringBuffer.
// Pré-alloue la place pour un certain nombre de caractères.
// Utile si vous savez à l'avance que vous allez rajouter un grand nombre
// de petites chaînes à un StringBuffer
void String::ensureCapacity(int capacity)
{
 sval = (char *) my_realloc(sval, capacity);
 sval[0] = '\0';
 debug_("In ensureCapacity(int capacity) sval", sval);
}
// Imite setLength de java.lang.String
// Utilise par la classe StringBuffer.
void String::setLength(int len)
{
 sval = (char *) my_realloc(sval, len);
 sval[0] = '\0';
 debug_("In ensureCapacity(int len) sval", sval);
}
// Imite setCharAt de StringBuffer
void String::setCharAt(int where, char ch)
{
 verifyIndex(where);
 sval[where] = ch;
 debug_("in StringBuffer dstr()", "ok");
}
// ---- Fin des fonctions imitant java.lang.String -----
// Version surchargée, modifie directement l'objet
// La variable dummy donne une signature différente à la fonction.
void String::substring(int startIndex, int endIndex, bool dummy)
{
 this->_substring(startIndex, endIndex);
}
inline void String::_substring(int startIndex, int endIndex)
{
 verifyIndex(startIndex);
 verifyIndex(endIndex);
 if (!endIndex) // endIndex == 0
 strcpy(sval, & sval[startIndex] ) ;
 else
 {
 if (endIndex> startIndex)
 {
 strcpy(sval, & sval[startIndex] ) ;
 sval[endIndex -startIndex] = 0;
 }
 else
 {
 cerr << "\n_substring() - startIndex is greater than endIndex!!\n"
 << endl;
 exit(-1);
 }
 }
}
// Version surchargée, modifie directement l'objet
String String::deleteStr(int startIndex, int endIndex, bool dummy)
{
 this->_deleteStr(startIndex, endIndex);
 return *this;
}
inline void String::_deleteStr(int startIndex, int endIndex)
{
 verifyIndex(startIndex);
 verifyIndex(endIndex);
 // Par exemple -
 //      deleteStr(3,3) avec val = 'pokemon' retourne 'poon'
 char *tmpaa = strdup(sval); // ici malloc
 strcpy(& tmpaa[startIndex], & tmpaa[endIndex]);
 *this = tmpaa;
 free(tmpaa);
}
// Version surchargée, modifie directement l'objet
String String::deleteCharAt(int loc, bool dummy)
{
 this->_deleteCharAt(loc);
 return *this;
}
inline void String::_deleteCharAt(int loc)
{
 char *tmpaa = strdup(sval); // ici malloc
 strcpy(& tmpaa[loc], & tmpaa[loc+1]);
 *this = tmpaa;
 free(tmpaa);
}
// Retourne la chaîne avant regx. Trouve la première occurrence de regx.
String String::at(char *regx)
{
 char *tok = NULL;
 tok = strstr(sval, regx);
 if (tok == NULL)
 return(String(""));
 else
 {
 int res = (int) (tok - sval);
 char *lefttok = strdup(sval);
 memset(lefttok, 0, strlen(sval));
 strcpy(lefttok, & sval[res]);
 String tmpstr(lefttok);
 free(lefttok);
 return(tmpstr);
 }
}
// Retourne la chaîne avant regx. Trouve la première occurrence de regx.
String String::before(char *regx)
{
 char *tok = NULL;
 tok = strstr(sval, regx);
 if (tok == NULL)
 return(String(""));
 else
 {
 int res = (int) (tok - sval);
 char *lefttok = strdup(sval);
 lefttok[res] = 0;
 String tmpstr(lefttok);
 free(lefttok);
 return(tmpstr);
 }
}
// Retourne la chaîne après regx. Trouve la première occurrence de regx.
String String::after(char *regx)
{
 char *tok = NULL;
 tok = strstr(sval, regx);
 if (tok == NULL)
 return(String(""));
 else
 {
 int res = (int) (tok - sval);
 char *lefttok = strdup(sval);
 memset(lefttok, 0, strlen(sval));
 strcpy(lefttok, & sval[res + strlen(regx)]);
 String tmpstr(lefttok);
 free(lefttok);
 return(tmpstr);
 }
}
// Divise la chaîne et retourne une liste via le pointeur de tête
// de liste explodeH.
// Voir aussi token().
void String::explode(char *seperator)
{
 char *aa = NULL, *bb = NULL;
 aa = (char *) my_malloc(strlen(sval));
 for (bb = strtok(aa, seperator); bb != NULL; bb = strtok(NULL, seperator) )
 {
 String *tmp = new String(bb);
 String::explodeH.insert(String::explodeH.end(), *tmp);
 }
 my_free(aa);
 list<String>::iterator iter1; // voir include/g++/stl_list.h
 debug_("Before checking explode..", "ok");
 if (String::explodeH.empty() == true )
 {
 debug_("List is empty!!", "ok");
 }
 for (iter1 = String::explodeH.begin(); iter1 != String::explodeH.end(); iter1++)
 {
 if (iter1 == NULL)
 {
 debug_("Iterator iter1 is NULL!!", "ok" );
 break;
 }
 debug_("(*iter1).sval", (*iter1).sval);
 }
}
// Version surchargée de explode(). Retourne un tableau
// de chaînes et le nombre total dans la référence strcount
// Voir aussi token().
String *String::explode(int & strcount, char seperator = ' ')
{
 String aa(sval);
 aa.trim(true);
 strcount = 0;
 for (int ii = 0, jj = strlen(aa.sval); ii < jj; ii++)
 {
 if (aa.sval[ii] == seperator)
 strcount++;
 }
 String *tmpstr = new String[strcount+1];
 if (!strcount) // strcount == 0
 tmpstr[0] = aa.sval;
 else
 {
 for (int ii = 0; ii <= strcount; ii++)
 tmpstr[ii] = aa.token();
 }
 return tmpstr;
}
// Agrège les chaînes pointées par la tête de liste
// explodeH et retourne la classe String.
void String::implode(char *glue)
{
}
// Agrège les chaînes pointées par la tête de liste
// explodeH et retourne la classe String.
void String::join(char *glue)
{
 implode(glue);
}
// Répète la chaîne input n fois.
String String::repeat(char *input, unsigned int multiplier)
{
 // Pour exemple -
 // repeat("k", 4) retourne "kkkk"
 if (!input) // input == NULL
 {
 return (String(""));
 }
 char *aa = (char *) my_malloc(strlen(input) * multiplier);
 for (unsigned int tmpii = 0; tmpii < multiplier; tmpii++)
 {
 strcat(aa, input);
 }
 String tmpstr(aa);
 my_free(aa);
 return tmpstr;
}
// Renverse la chaîne.
// Version surchargée de reverse(). Modifie directement l'objet.
void String::reverse(bool dummy)
{
 this->_reverse();
}
inline void String::_reverse()
{
 // Par exemple -
 //              reverse() sur "12345" retourne "54321"
 char aa;
 unsigned long tot_len = strlen(sval);
 unsigned long midpoint = tot_len / 2;
 for (unsigned long tmpjj = 0; tmpjj < midpoint; tmpjj++)
 {
 aa = sval[tmpjj];  // variable temporaire de stockage
 sval[tmpjj] = sval[tot_len - tmpjj - 1];  // permute les valeurs
 sval[tot_len - tmpjj - 1] = aa; // permute les valeurs
 }
}
// Change certain caractères.
// Par exemple ("abcd", "ABC") change toutes les occurrences de chaque
// caractère de 'from' en le caractère correspondant dans 'to'
String String::tr(char *from, char *to)
{
 int lenfrom = strlen(from), lento = strlen(to);
 if (lento> lenfrom)
 lento = lenfrom; // choisit le min
 else
 if (lento < lenfrom)
 lenfrom = lento; // choisit le min
 debug_("lento", lento);
 register char *aa = strdup(sval);
 for (int ii = 0, jj = strlen(sval); ii < jj; ii++) // pour chaque caractère dans val
 {
 for (int kk = 0; kk < lento; kk++) // pour chaque caractère dans "from"
 {
 if (aa[ii] == from[kk])
 aa[ii] = to[kk];
 }
 }
 String tmpstr(aa);
 free(aa);
 return tmpstr;
}
// Centre le texte
String String::center(int padlength, char padchar = ' ')
{
 // Par exemple -
 //              center(10, '*') avec sval="aa" retourne "****aa****"
 //              center(10) avec sval="aa" retourne "    aa    "
 // Le résultat est une chaîne contenant 'padlength' caractères avec sval au milieu.
 int tmpii = sizeof(char) * (padlength + strlen(sval) + 10);
 char *aa = (char *) malloc(tmpii);
 memset(aa, 0, tmpii);
 for (int jj = 0, kk = (int) padlength/2; jj < kk; jj++)
 {
 aa[jj] = padchar;
 }
 strcat(aa, sval);
 for (int jj = strlen(aa), kk = jj + (int) padlength/2; jj < kk; jj++)
 {
 aa[jj] = padchar;
 }
 String tmpstr(aa);
 free(aa);
 return tmpstr;
}
// Formate la chaîne originale en plaçant <number> caractères <padchar>
// entre chaque ensemble de mots délimités par des blancs. Les blancs en début et
// en fin sont toujours supprimés. Si <number> est omis ou vaut 0, alors tous les
// espaces de la chaîne sont supprimés. Par défaut, <number> vaut 0 et padchar ' '.
String String::space(int number, char padchar = ' ')
{
 // Par exemple -
 //              space(3) avec sval = "Je ne sais pas"
 //                              retournera "Je   ne   sais   pas"
 //              space(1, '_') avec sval = "Un lieu profondement obscur"
 //                              retournera "Un_lieu_profondement_obscur"
 //              space() avec sval = "Je   sais     cela"
 //                              retournera "Jesaiscela"
 debug_("this->sval", this->sval );
 String tmpstr = this->trim().sval;
 debug_("tmpstr.sval", tmpstr.sval );
 // compte les espaces
 int spacecount = 0;
 for (int ii = 0, jj = strlen(tmpstr.sval); ii < jj; ii++)
 {
 if (tmpstr.sval[ii] == ' ')
 spacecount++;
 }
 debug_("spacecount", spacecount);
 char ee[2];
 ee[0] = padchar;
 ee[1] = 0;
 String bb = tmpstr.repeat(ee, spacecount);
 int tmpii = sizeof(char) * (strlen(tmpstr.sval) + (number * spacecount) + 20);
 char *aa = (char *) malloc(tmpii);
 memset(aa, 0, tmpii);
 for (int ii = 0, jj = strlen(tmpstr.sval); ii < jj; ii++)
 {
 if (tmpstr.sval[ii] == ' ')
 strcat(aa, bb.sval);
 else
 {
 ee[0] = sval[ii];
 strcat(aa, ee);
 }
 }
 tmpstr = aa;
 free(aa);
 return tmpstr;
}
// Le résultat est une chaîne comprenant tous les caractères compris
// entre <start> et <end> (inclus).
String String::xrange(char start, char end)
{
 // Par exemple -
 //      xrange('a', 'j') retourne val = "abcdefghij"
 //      xrange(1, 8) retourne val = "12345678"
 if (end < start)
 {
 cerr << "\nThe 'end' character is less than 'start' !!" << endl;
 return String("");
 }
 // Note : 'end' est plus grand que 'start' ! Et ajoute +1
 int tmpii = sizeof(char) * (end - start + 11);
 char *aa = (char *) malloc(tmpii);
 memset(aa, 0, tmpii);
 debug_("xrange tmpii", tmpii);
 for (int ii = start, jj = 0; ii <= end; ii++, jj++)
 {
 aa[jj] = ii;
 debug_("xrange aa[jj]", aa[jj] );
 }
 String tmpstr(aa);
 free(aa);
 return tmpstr;
}
// Supprime tous les caractères contenus dans <list>. Le caractère par défaut pour
// <list> est l'espace ' '.
String String::compress(char *list = " ")
{
 // Par exemple -
 //      compress("$,%") avec sval = "$1,934" retourne "1934"
 //      compress() avec sval = "appelez moi alavoor vasudevan" returns "appelezmoialavoorvasudevan"
 int lenlist = strlen(list);
 register char *aa = strdup(sval);
 for (int ii = 0, jj = strlen(sval); ii < jj; ii++) // pour chaque caractère de sval
 {
 for (int kk = 0; kk < lenlist; kk++) // pour chaque caractère de "from"
 {
 if (aa[ii] == list[kk])
 {
 strcpy(& aa[ii], & aa[ii+1]);
 }
 }
 }
 String tmpstr(aa);
 free(aa);
 return tmpstr;
}
// <newstr> est insérée dans sval à partir de <start>. <newstr> est
// complétée ou tronquée à <length> caractères. <length> est par défaut la
// longueur de la chaîne <newstr>
String String::insert(char *newstr, int start = 0, int lengthstr = 0, char padchar = ' ')
{
 // Par exemple -
 //      insert("quelquechose de nouveau", 8, 30, '*') avec sval = "vieille chose"
 //              retourne "vieille quelquechose de nouveau*******chose"
 int tmplen = sizeof(char) * strlen(sval) + strlen(newstr) + lengthstr + 10;
 char *tmpaa = (char *) malloc (tmplen);
 memset(tmpaa, 0, tmplen);
 if (!start) // start == 0
 {
 strcpy(tmpaa, newstr);
 strcat(tmpaa, this->sval);
 }
 else
 {
 strncpy(tmpaa, this->sval, start);
 strcat(tmpaa, newstr);
 strcat(tmpaa, & this->sval[start]);
 }
 String tmpstr(tmpaa);
 free(tmpaa);
 return tmpstr;
}
// Fonction insert surchargée
String String::insert(int index, String str2, bool dummy)
{
 *this =  this->insert(str2.sval, index).sval;
 //debug_("tmpstr.sval", tmpstr.sval);
 return *this;
}
// Fonction insert surchargée
String String::insert(int index, char ch, bool dummy)
{
 char aa[2];
 aa[0] = ch;
 aa[1] = 0;
 *this = this->insert(aa, index).sval;
 //debug_("tmpstr.sval", tmpstr.sval);
 return *this;
}
// Le résultat est une chaîne de <length> caractères composée des caractères les plus à gauches de sval.
// Méthode rapide pour justifier à gauche une chaîne.
String String::left(int slength = 0, char padchar = ' ')
{
 // Par exemple -
 //      left(15) avec sval = "Wig"       retourne "Wig            "
 //      left(4) avec  sval = "Wighat"    retourne "Wigh"
 //      left() avec   sval = "   Wighat" retourne "Wighat   "
 if (!slength) // slength == 0
 slength = strlen(sval);
 debug_("left() slength", slength);
 int tmpii = slength + 20;
 char *aa = (char *) malloc(tmpii);
 memset(aa, 0, tmpii);
 debug_("this->ltrim().sval ", this->ltrim().sval);
 strcpy(aa, this->ltrim().sval);
 debug_("left() aa", aa );
 int currlen = strlen(aa);
 if (currlen < slength)
 {
 // pad the string now
 char ee[2];
 ee[0] = padchar;
 ee[1] = 0;
 strcat(aa, this->repeat(ee, (unsigned int) (slength-currlen) ).sval);
 }
 else
 {
 aa[slength] = 0;
 }
 debug_("left() aa", aa );
 String tmpstr(aa);
 free(aa);
 return tmpstr;
}
// Le résultat est une chaîne de <length> caractères composée des caractères les plus à droite de sval.
// Méthode rapide pour justifier à droite un chaîne.
String String::right(int slength = 0, char padchar = ' ')
{
 // Par exemple -
 //      right(10) avec sval = "never to saying   " retourne " to saying"
 //      right(4) avec  sval = "Wighat"             retourne "ghat"
 //      right(8) avec  sval = "4.50"               retourne "    4.50"
 //      right() avec   sval = "  4.50     "        retourne "       4.50"
 if (!slength) // slength == 0
 slength = strlen(sval);
 debug_("right() slength", slength);
 int tmpii = slength + 20;
 char *aa = (char *) malloc(tmpii);
 memset(aa, 0, tmpii);
 int currlen = strlen(this->rtrim().sval);
 debug_("right() currlen", currlen );
 if (currlen < slength)
 {
 // pad the string now
 char ee[2];
 ee[0] = padchar;
 ee[1] = 0;
 strcpy(aa, this->repeat(ee, (unsigned int) (slength-currlen) ).sval);
 strcat(aa, this->rtrim().sval);
 debug_("right() aa", aa );
 }
 else
 {
 strcpy(aa, this->rtrim().sval);
 strcpy(aa, & aa[currlen-slength]);
 aa[slength] = 0;
 }
 debug_("right() aa", aa );
 String tmpstr(aa);
 free(aa);
 return tmpstr;
}
// <newstr> est superposée à sval en commençant à <start>. <newstr> est complétée
// ou tronquée à <length> caractères. Par défaut, la longueur <length> est la
// longueur de la chaîne newstr.
String String::overlay(char *newstr, int start = 0, int slength = 0, char padchar = ' ')
{
 // Par exemple -
 //      overlay("12345678", 4, 10, '*') sur sval = "oldthing is very bad"
 //              retourne "old12345678**ery bad"
 //      overlay("12345678", 4, 5, '*') sur sval = "oldthing is very bad"
 //              retourne "old12345ery bad"
 int len_newstr = strlen(newstr);
 if (!slength) // slength == 0
 slength = len_newstr;
 char *aa = (char *) malloc(slength + len_newstr + 10);
 aa[0] = 0;
 char ee[2];
 ee[0] = padchar;
 ee[1] = 0;
 if (len_newstr < slength)
 {
 // remplire maintenant
 strcpy(aa, newstr);
 strcat(aa, this->repeat(ee, (slength-len_newstr)).sval );
 }
 else
 {
 strcpy(aa, newstr);
 aa[slength] = 0;
 }
 // Maintenant recouvrir la chaîne
 String tmpstr(sval);
 debug_("tmpstr.sval", tmpstr.sval);
 for (int ii=start, jj=strlen(tmpstr.sval), kk=start+slength, mm=0;
 ii < jj; ii++, mm++)
 {
 if (ii == kk)
 break;
 if (mm == slength)
 break;
 tmpstr.sval[ii] = aa[mm];
 }
 free(aa);
 debug_("tmpstr.sval", tmpstr.sval);
 return tmpstr;
}
// Si la chaîne est littéralement égale à ou non égale à
// Si type vaut false alors ==
bool String::_equalto(const String & rhs, bool type = false)
{
 if (type == false) // test ==
 {
 if (strlen(rhs.sval) == strlen(sval))
 {
 if (!strncmp(rhs.sval, sval, strlen(sval))) //  == 0
 return true;
 else
 return false;
 }
 else
 return false;
 }
 else // test !=
 {
 if (strlen(rhs.sval) != strlen(sval))
 {
 if (!strncmp(rhs.sval, sval, strlen(sval))) //  == 0
 return true;
 else
 return false;
 }
 else
 return false;
 }
}
// Si la chaîne est littéralement égale à ou non égale à
// Si type vaut false alors ==
bool String::_equalto(const char *rhs, bool type = false)
{
 if (type == false) // test ==
 {
 if (strlen(rhs) == strlen(sval))
 {
 if (!strncmp(rhs, sval, strlen(sval))) //  == 0
 return true;
 else
 return false;
 }
 else
 return false;
 }
 else // test !=
 {
 if (strlen(rhs) != strlen(sval))
 {
 if (!strncmp(rhs, sval, strlen(sval))) //  == 0
 return true;
 else
 return false;
 }
 else
 return false;
 }
}
// Fonction synonyme de vacuum()
void String::clear()
{
 sval = (char *) my_realloc(sval, 10);
 sval[0] = '\0';
}
// Supprime tous les caractères 'ch' en fin de chaîne - voir aussi chop()
// Par exemple :
//      sval = "abcdef\n\n\n" alors chopall() = "abcdef"
//      sval = "abcdefffff" alors chopall('f') = "abcde"
void String::chopall(char ch='\n')
{
 unsigned long tmpii = strlen(sval) - 1 ;
 for (; tmpii>= 0; tmpii--)
 {
 if (sval[tmpii] == ch)
 sval[tmpii] = 0;
 else
 break;
 }
}
// Supprime le caractère de fin de la chaîne - voir aussi chopall()
// chop() est souvent utilisé pour supprimer le caractère de fin de ligne
void String::chop()
{
 sval[strlen(sval)-1] = 0;
}
// Version surchargée de trim(). Modifie directement l'objet.
void String::trim(bool dummy)
{
 this->_trim();
}
inline void String::_trim()
{
 this->rtrim(true);
 this->ltrim(true);
 debug_("this->sval", this->sval);
}
// Version surchargée de ltrim(). Modifie directement l'objet.
void String::ltrim(bool dummy)
{
 this->_ltrim();
}
inline void String::_ltrim()
{
 // Peut causer des problèmes dans my_realloc car
 // l'emplacement de bb peut être détruit !
 char *bb = sval;
 if (bb == NULL)
 return;
 while (isspace(*bb))
 bb++;
 debug_("bb", bb);
 if (bb != NULL && bb != sval)
 {
 debug_("doing string copy", "done");
 _str_cpy(bb); // cause des problèmes dans my_realloc et bb va être détruit !
 }
 else
 debug_("Not doing string copy", "done");
}
String String::ltrim()
{
 String tmpstr(sval);
 tmpstr._ltrim();
 return tmpstr;
}
// Version surchargée de rtrim(). Modifie directement l'objet.
void String::rtrim(bool dummy)
{
 this->_rtrim();
}
inline void String::_rtrim()
{
 for (long tmpii = strlen(sval) - 1 ; tmpii>= 0; tmpii--)
 {
 if ( isspace(sval[tmpii]) )
 sval[tmpii] = '\0';
 else
 break;
 }
}
String String::rtrim()
{
 String tmpstr(sval);
 tmpstr._rtrim();
 return tmpstr;
}
// Utilisé pour arrondir la partie frationnaire de réels.
// Arrondit les réels avec la précision souhaitée et stocke
// le résultat dans le champ sval de la chaîne.
// Retourne aussi le résultat comme un char *.
void String::roundf(float input_val, short precision)
{
 float   integ_flt, deci_flt;
 const   short MAX_PREC = 4;
 debug_("In roundf", "ok");
 if (precision> MAX_PREC) // précision maximale supportée
 precision = MAX_PREC;
 // récupère les parties entière et décimale du réel
 deci_flt = modff(input_val, & integ_flt);
 for (int tmpzz = 0; tmpzz < precision; tmpzz++)
 {
 debug_("deci_flt", deci_flt);
 deci_flt *= 10;
 }
 debug_("deci_flt", deci_flt);
 unsigned long deci_int = (unsigned long) ( rint(deci_flt) );
 sval = (char *) my_malloc(NUMBER_LENGTH); // float 70 chiffres max
 if (deci_int> 999) // (MAX_PREC) chiffres
 sprintf(sval, "%lu.%lu", (unsigned long) integ_flt, deci_int);
 else
 if (deci_int> 99) // (MAX_PREC - 1) chiffres
 sprintf(sval, "%lu.0%lu", (unsigned long) integ_flt, deci_int);
 else
 if (deci_int> 9) // (MAX_PREC - 2) chiffres
 sprintf(sval, "%lu.00%lu", (unsigned long) integ_flt, deci_int);
 else
 sprintf(sval, "%lu.00000%lu", (unsigned long) integ_flt, deci_int);
}
void String::roundd(double input_val, short precision)
{
 double  integ_flt, deci_flt;
 const   short MAX_PREC = 6;
 if (precision> MAX_PREC) // précision maximale supportée
 precision = MAX_PREC;
 debug_("In roundd", "ok");
 // récupère les parties entière et décimale du réel
 deci_flt = modf(input_val, & integ_flt);
 for (int tmpzz = 0; tmpzz < precision; tmpzz++)
 {
 debug_("deci_flt", deci_flt);
 deci_flt *= 10;
 }
 debug_("deci_flt", deci_flt);
 sval = (char *) my_malloc(NUMBER_LENGTH); // double 70 chiffres max
 unsigned long deci_int = (unsigned long) ( rint(deci_flt) );
 if (deci_int> 99999) // (MAX_PREC) chiffres
 sprintf(sval, "%lu.%lu", (unsigned long) integ_flt, deci_int);
 else
 if (deci_int> 9999) // (MAX_PREC - 1) chiffres
 sprintf(sval, "%lu.0%lu", (unsigned long) integ_flt, deci_int);
 else
 if (deci_int> 999) // (MAX_PREC - 2) chiffres
 sprintf(sval, "%lu.00%lu", (unsigned long) integ_flt, deci_int);
 else
 if (deci_int> 99) // (MAX_PREC - 3) chiffres
 sprintf(sval, "%lu.000%lu", (unsigned long) integ_flt, deci_int);
 else
 if (deci_int> 9) // (MAX_PREC - 4) chiffres
 sprintf(sval, "%lu.0000%lu", (unsigned long) integ_flt, deci_int);
 else // (MAX_PREC - 5) chiffres
 sprintf(sval, "%lu.00000%lu", (unsigned long) integ_flt, deci_int);
}
// Fournie seulement pour documenter
// Vous devriez utiliser la fonction indexOf()
bool String::contains(char *str2, int startIndex = 0)
{
 // Par exemple -
 //              if (indexOf("ohboy")> -1 )
 //                      cout << "\nString contient 'ohboy'" << endl;
 //              if (indexOf("ohboy") < 0 )
 //                      cout << "\nString NE contient PAS 'ohboy'" << endl;
 //              if (indexOf("ohboy", 4)> -1 )
 //                      cout << "\nString contient 'ohboy'" << endl;
 //              if (indexOf("ohboy", 4) < 0 )
 //                      cout << "\nString NE contient PAS 'ohboy'" << endl;
 cerr << "\nYou must use indexOf() function instead of contains()\n" << endl;
 exit(-1);
}
// Fonction synonyme de empty()
bool String::isNull()
{
 if (sval[0] == '\0')
 return true;
 else
 {
 if (sval == NULL)
 return true;
 else
 return false;
 }
}
// Les caractères blancs de début et de fin sont ignorés.
bool String::isInteger()
{
 String tmpstr(sval);
 tmpstr.trim(true);
 debug_("tmpstr.sval", tmpstr.sval );
 if ( strspn ( tmpstr.sval, "0123456789" ) != strlen(tmpstr.sval) )
 return ( false ) ;
 else
 return ( true ) ;
}
// Fonction surchargée
bool String::isInteger(int pos)
{
 verifyIndex(pos);
 return (isdigit(sval[pos]));
}
// Les caractères blancs de début et de fin sont ignorés.
bool String::isNumeric()
{
 String tmpstr(sval);
 tmpstr.trim(true);
 debug_("tmpstr.sval", tmpstr.sval );
 if ( strspn ( tmpstr.sval, "0123456789.+-e" ) != strlen(tmpstr.sval) )
 return ( false ) ;
 else
 return ( true ) ;
}
// Fonction surchargée
bool String::isNumeric(int pos)
{
 verifyIndex(pos);
 return (isdigit(sval[pos]));
}
bool String::isEmpty()
{
 if (strlen(sval) == 0)
 return true;
 else
 return false;
}
// Voir aussi explode()
//      Attention : l'objet String est modifié et ne contient plus le token renvoyé.
//                  Il est conseillé de sauvegarder la chaîne originale avant d'appeler
//                  cette fonction, comme par exemple ainsi :
//              String savestr = origstr;
//              String aa, bb, cc;
//              aa = origstr.token();
//              bb = origstr.token();
//              cc = origstr.token();
//
//  Cette méthode retourne le premier token non séparateur (par défaut espace) de la chaîne.
String String::token(char seperator = ' ')
{
 char ee[2];
 ee[0] = seperator;
 ee[1] = 0;
 char *res = strtok(sval, ee);
 if (!res) // if res == NULL
 {
 debug_("token", res);
 debug_("sval", sval);
 return(String(sval));
 }
 else
 {
 String tmpstr(res);
 // Utilise la longueur de la chaîne sval et pas celle de res
 // car strtok() a mis un NULL ('\0') sur l'emplacement et
 // aussi car strtok() ignore les blancs initiaux de sval
 strcpy(sval, & sval[strlen(sval)+1]);
 debug_("token", res);
 debug_("sval", sval);
 return tmpstr;
 }
}
String String::crypt(char *original, char *salt)
{
 return String("");
}
int String::toInteger()
{
 if ( strlen(sval) == 0 ) {
 cerr << "Cannot convert a zero length string "
 << " to a numeric" << endl ;
 abort() ;
 }
 if ( ! isInteger() ) {
 cerr << "Cannot convert string [" << sval
 << "] to an integer numeric string" << endl ;
 abort() ;
 }
 return ( atoi ( sval ) ) ;
}
long String::parseLong()
{
 if ( strlen(sval) == 0 ) {
 cerr << "Cannot convert a zero length string "
 << " to a numeric" << endl ;
 abort() ;
 }
 if ( ! isInteger() ) {
 cerr << "Cannot convert string [" << sval
 << "] to an integer numeric string" << endl ;
 abort() ;
 }
 return ( atol ( sval ) ) ;
}
double String::toDouble()
{
 if ( strlen(sval) == 0 ) {
 cerr << "Cannot convert a zero length string "
 << " to a numeric" << endl ;
 abort() ;
 }
 if ( ! isNumeric() ) {
 cerr << "Cannot convert string [" << sval
 << "] to a double numeric string" << endl ;
 abort() ;
 }
 double d = atof ( sval ) ;
 return ( d ) ;
}
String String::getline(FILE *infp = stdin)
{
 register char ch, *aa = NULL;
 register const short SZ = 100;
 // Valeur initiale de ii> SZ donc aa est de la mémoire allouée
 register int jj = 0;
 for (int ii = SZ+1; (ch = getc(infp)) != EOF; ii++, jj++)
 {
 if (ii> SZ)  // alloue la memoire en paquets de SZ pour la performance
 {
 aa = (char *) realloc(aa, jj + ii + 15);  // +15 par sécurité
 ii = 0;
 }
 if (ch == '\n')  // lit jusqu'à rencontrer une nouvelle ligne
 break;
 aa[jj] = ch;
 }
 aa[jj] = 0;
 _str_cpy(aa);  // met la valeur dans la chaîne
 free(aa);
 return *this;
}
/*
void String::Format(const char *fmt, ... )
{
 va_list iterator;
 va_start(iterator, fmt );
 va_end(iterator);
}
*/
// contrôle qu'un indice se trouve dans les limites
inline void String::verifyIndex(unsigned long index) const
{
 if (index < 0 || index>= strlen(sval) )
 {
 // throw "Index Out Of Bounds Exception";
 cerr << "Index Out Of Bounds Exception at ["
 << index << "] in:\n" << sval << endl;
 exit(1);
 }
}
// contrôle qu'un indice se trouve dans les limites
inline void String::verifyIndex(unsigned long index, char *aa) const
{
 if (!aa) // aa == NULL
 {
 cerr << "\nverifyIndex(long, char *) str null value\n" << endl;
 exit(-1);
 }
 if (index < 0 || index>= strlen(aa) )
 {
 cerr << "Index Out Of Bounds Exception at ["
 << index << "] in:\n" << aa << endl;
 exit(1);
 }
}
//////////////////////////////////////////////////////////
// Les fonctions privées commencent à partir d'ici...
//////////////////////////////////////////////////////////
void String::_str_cpy(char bb[])
{
 debug_("In _str_cpy bb", bb);
 if (bb == NULL)
 {
 sval[0] = '\0';
 return;
 }
 unsigned long tmpii = strlen(bb);
 if (tmpii == 0)
 {
 sval[0] = '\0';
 return;
 }
 debug_("In _str_cpy tmpii", tmpii);
 debug_("In _str_cpy sval", sval);
 sval = (char *) my_realloc(sval, tmpii);
 //sval = new char [tmpii + SAFE_MEM_2];
 debug_("In _str_cpy bb", bb);
 strncpy(sval, bb, tmpii);
 debug_("In _str_cpy sval", sval);
 sval[tmpii] = '\0';
 debug_("In _str_cpy sval", sval);
}
void String::_str_cpy(int bb)
{
 char tmpaa[100];
 sprintf(tmpaa, "%d", bb);
 _str_cpy(tmpaa);
}
void String::_str_cpy(unsigned long bb)
{
 char tmpaa[100];
 sprintf(tmpaa, "%ld", bb);
 _str_cpy(tmpaa);
}
void String::_str_cpy(float bb)
{
 char tmpaa[100];
 sprintf(tmpaa, "%f", bb);
 _str_cpy(tmpaa);
}
void String::_str_cat(char bb[])
{
 unsigned long tmpjj = strlen(bb), tmpii = strlen(sval);
 sval = (char *) my_realloc(sval, tmpii + tmpjj);
 debug_("sval in _str_cat() ", sval);
 strncat(sval, bb, tmpjj);
}
void String::_str_cat(int bb)
{
 char tmpaa[100];
 sprintf(tmpaa, "%d", bb);
 unsigned long tmpjj = strlen(tmpaa), tmpii = strlen(sval);
 sval = (char *) my_realloc(sval, tmpii + tmpjj);
 strncat(sval, tmpaa, tmpjj);
}
void String::_str_cat(unsigned long bb)
{
 char tmpaa[100];
 sprintf(tmpaa, "%ld", bb);
 unsigned long tmpjj = strlen(tmpaa), tmpii = strlen(sval);
 sval = (char *) my_realloc(sval, tmpii + tmpjj);
 strncat(sval, tmpaa, tmpjj);
}
void String::_str_cat(float bb)
{
 char tmpaa[100];
 sprintf(tmpaa, "%f", bb);
 unsigned long tmpjj = strlen(tmpaa), tmpii = strlen(sval);
 sval = (char *) my_realloc(sval, tmpii + tmpjj);
 strncat(sval, tmpaa, tmpjj);
}
//////////////////////////////////////////////////////////
// Les opérateurs sont définis à partir d'ici...
//////////////////////////////////////////////////////////
String operator+ (const String & lhs, const String & rhs)
{
 /*******************************************************/
 // Note : pour concaténer deux chaînes, transtyper d'abord
 // en String comme ici :
 //aa = (String) "alkja " + " 99djd " ;
 /*******************************************************/
 String tmp(lhs);
 tmp._str_cat(rhs.sval);
 return(tmp);
 /*
 if (String::_global_String == NULL)
 {
 String::_global_String = new String;
 String::_global_String->_str_cpy(lhs.sval);
 String::_global_String->_str_cat(rhs.sval);
 //return *String::_global_String;
 return String(String::_global_String->val);
 }
 */
 /*
 else
 if (String::_global_String1 == NULL)
 {
 debug_("1)global", "ok" );
 String::_global_String1 = new String;
 String::_global_String1->_str_cpy(lhs.sval);
 String::_global_String1->_str_cat(rhs.sval);
 return *String::_global_String1;
 }
 */
 /*
 else
 {
 fprintf(stderr, "\nError: cannot alloc _global_String\n");
 exit(-1);
 }
 */
 /*
 String *aa = new String;
 aa->_str_cpy(lhs.sval);
 aa->_str_cat(rhs.sval);
 return *aa;
 */
}
String String::operator+ (const String & rhs)
{
 String tmp(*this);
 tmp._str_cat(rhs.sval);
 debug_("rhs.sval in operator+", rhs.sval );
 debug_("tmp.sval in operator+", tmp.sval );
 return (tmp);
}
// L'utilisation d'une référence accélèrera l'opérateur =
String& String:: operator= ( const String& rhs )
{
 if (& rhs == this)
 {
 debug_("Fatal Error: In operator(=). rhs is == to 'this pointer'!!", "ok" );
 return *this;
 }
 this->_str_cpy(rhs.sval);
 debug_("rhs value", rhs.sval );
 // Libere la memoire des variables globales
 //_free_glob(& String::_global_String);
 //if (String::_global_String == NULL)
 //fprintf(stderr, "\n_global_String is freed!\n");
 //return (String(*this));
 return *this;
}
// L'utilisation d'une référence accélèrera l'opérateur =
String& String::operator+= (const String & rhs)
{
 /*******************************************************/
 // Note : pour concaténer deux chaînes, transtyper d'abord
 // en String comme ici :
 //aa = (String) "cccc " + " dddd " ;
 /*******************************************************/
 if (& rhs == this)
 {
 debug_("Fatal error: In operator+= rhs is equals 'this' ptr", "ok");
 return *this;
 }
 this->_str_cat(rhs.sval);
 return *this;
 //return (String(*this));
}
bool String::operator== (const String & rhs)
{
 return(_equalto(rhs.sval));
}
bool String::operator== (const char *rhs)
{
 return(_equalto(rhs));
}
bool String::operator!= (const String & rhs)
{
 return(_equalto(rhs.sval, true));
}
bool String::operator!= (const char *rhs)
{
 return(_equalto(rhs, true));
}
char String::operator[] (unsigned long Index) const
{
 verifyIndex(Index);
 return sval[Index];
}
char & String::operator[] (unsigned long Index)
{
 verifyIndex(Index);
 return sval[Index];
}
istream & operator>> (istream & In, String & str2)
{
 // alloue la taille max de 2048 caractères
 static char aa[MAX_ISTREAM_SIZE];
 In>> aa;
 str2 = aa; // affecte aa à la référence
 return In; // retourne un istream
}
ostream & operator << (ostream & Out, const String & str2)
{
 Out << str2.sval;
 return Out;
}
////////////////////////////////////////////////////
//  Imite StringBuffer Object
//      MéThodes de StringBuffer
////////////////////////////////////////////////////
// Imite StringBuffer ; le constructeur par défaut
// (celui sans paramètre) réserve de la place pour 16
// caractères.
StringBuffer::StringBuffer()
 :String()   // appelle le constructeur de la classe de base sans paramètres
{
 debug_("in StringBuffer cstr()", "ok");
}
// Imite StringBuffer
StringBuffer::StringBuffer(int size)
 :String(size, true) // appelle le constructeur de la classe de base sans paramètres
{
 // String(size, true) -- ne pas l'appeler ici dans le corps de la
 // fonction mais durant la phase d'initialisation pour éviter un
 // appel supplémentaire du constructeur par défaut de la classe de
 // base et être plus rapide et plus efficace
 debug_("in StringBuffer cstr(int size)", "ok");
}
// Imite StringBuffer
// appelle le constructeur de la classe de base avec une chaîne en paramètre
StringBuffer::StringBuffer(String str)
 :String(str.val())  // appelle le constructeur de la classe de base
{
 // String(str.val()) -- ne pas l'appeler ici dans le corps de la
 // fonction mais durant la phase d'initialisation pour éviter un
 // appel supplémentaire du constructeur par défaut de la classe de
 // base et être plus rapide et plus efficace
 debug_("in StringBuffer cstr(String str)", "ok");
}
// Imite StringBuffer
StringBuffer::~StringBuffer()
{
 debug_("in StringBuffer dstr()", "ok");
}
// Imite la classe Float
// appelle le constructeur de la classe de base avec une chaîne en paramètre
Float::Float(String str)
 :String(str.val())  // appelle le constructeur de la classe de base
{
 // String(str.val()) -- ne pas l'appeler ici dans le corps de la
 // fonction mais durant la phase d'initialisation pour éviter un
 // appel supplémentaire du constructeur par défaut de la classe de
 // base et être plus rapide et plus efficace
 debug_("in Float cstr(String str)", "ok");
}
// Imite la classe Double
// appelle le constructeur de la classe de base avec une chaîne en paramètre
Double::Double(String str)
 :String(str.val())  // appelle le constructeur de la classe de base
{
 // String(str.val()) -- ne pas l'appeler ici dans le corps de la
 // fonction mais durant la phase d'initialisation pour éviter un
 // appel supplémentaire du constructeur par défaut de la classe de
 // base et être plus rapide et plus efficace
 debug_("in Double cstr(String str)", "ok");
}
// Imite la classe StringReader
// appelle le constructeur de la classe de base avec une chaîne en paramètre
StringReader::StringReader(String str)
 :String(str.val())  // appelle le constructeur de la classe de base
{
 // String(str.val()) -- ne pas l'appeler ici dans le corps de la
 // fonction mais durant la phase d'initialisation pour éviter un
 // appel supplémentaire du constructeur par défaut de la classe de
 // base et être plus rapide et plus efficace
 debug_("in StringReader cstr(String str)", "ok");
 _curpos = 0;
 _mark_pos = 0;
}
// Imite la méthode read de la classe StringReader
int StringReader::read()
{
 _curpos++;
 if (_curpos> strlen(sval) )
 return -1;
 return sval[_curpos-1];
}
// Lit des caractères dans une portion d'un tableau
// cbuf est le tampon destination, offset est le décalage indiquant où écrire
// les caractères, length est le nombre maximum de caractères à lire
// Retourne le nombre de caractères lus ou -1 en cas de fin du flux
int StringReader::read(char cbuf[], int offset, int length)
{
 if (_curpos> strlen(sval) - 1 )
 return -1;
 strncpy(& cbuf[offset], & sval[_curpos], length);
 _curpos += length;
 return length;
}
// Marque la position courante dans le flux. Les appels suivants
// à reset() repositionneront le flux à ce point.
// Le paramètre 'readAheadLimit' limite le nombre de caractères qui
// pourraient être lus tout en préservant la marque.
// Comme le flux d'entrée provient d'une chaîne, il n'y a pas de
//limite actuellement, donc l'argument est ignoré.
void StringReader::mark(int readAheadLimit)
{
 _mark_pos = _curpos;
}
// réinitialise le flux à la marque la plus récente, ou au début de
// la chaîne si aucun marque n'a été posée
void StringReader::reset()
{
 _curpos = _mark_pos;
}
// Passe des caractères. Cette méthode bloquera jusqu'a ce que des caractères soient
// disponibles, qu'une erreur arrive ou que la fin du flux soit atteinte.
// Paramètre ii : nombre de caractères à passer
// Retourne : le nombre courant de caractères passés
long StringReader::skip(long ii)
{
 long tmpjj = strlen(sval) - _curpos - 1;
 if (ii> tmpjj)
 ii = tmpjj;
 _curpos = ii;
 return ii;
}
// Imite la classe StringWriter
StringWriter::StringWriter()
{
 debug_("in StringWriter cstr()", "ok");
 char *aa = (char *) malloc(300);
 memset(aa, ' ', 299); // remplit avec des blancs
 aa[300] = 0;
 String((char *) aa);
 my_free(aa);
}
StringWriter::StringWriter(int bufferSize)
{
 debug_("in StringWriter cstr(int bufferSize)", "ok");
 char *aa = (char *) malloc(bufferSize);
 memset(aa, ' ', bufferSize-1); // remplit avec des blancs
 aa[bufferSize] = 0;
 String((char *) aa);
 my_free(aa);
}
void StringWriter::write(int bb)
{
 _str_cat(bb);
}
void StringWriter::write(char *bb)
{
 _str_cat(bb);
}
void StringWriter::write(String bb)
{
 _str_cat(bb.val());
}
void StringWriter::write(char *bb, int startIndex, int endIndex)
{
 char *aa = strdup(bb); // teste le null dans verifyIndex
 verifyIndex(startIndex, aa);
 verifyIndex(endIndex, aa);
 aa[endIndex] = 0;
 _str_cat(& aa[startIndex]);
}
void StringWriter::write(String str, int startIndex, int endIndex)
{
 write(str.val(), startIndex, endIndex);
}


Page suivantePage précédenteTable des matières

Hosting by: Hurra Communications GmbH
Generated: 2007-01-26 18:01:30