MyString.cpp

Go to the documentation of this file.

/* *************************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        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.  See the
        GNU General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
************************************************************************************* */

#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <stdlib.h> 
#include <math.h>

#include "myString.h"
#include "myException.h"

// *********************************************************************************

long MyString::GetSize()
{
        return size;
}

char *MyString::GetValue()
{
        return value;
}

MyString::MyString()
{
        value = NULL;
        Zero();
}

MyString::MyString(char letter)
{
        value = NULL;
        *this=letter;
}

MyString::MyString(int integer)
{
        value = NULL;
        *this=integer;
}

MyString::MyString(long linteger)
{
        value = NULL;
        *this=linteger;
}

MyString::MyString(float floating)
{
        value = NULL;
        *this=floating;
}

MyString::MyString(double lfloating)
{
        value = NULL;
        *this=lfloating;
}

MyString::MyString(char *string)
{
        value = NULL;
        *this=string;
}

MyString::MyString(MyString &string)
{
        value = NULL;
        *this=string;
}

// *********************************************************************************

void MyString::Delete()
{
        if (value) 
        {
                try
                {
                        delete []value;
                }
                catch(int num)
                {
                }
        }
        size = 0;
        allocSize = 0;
        value = NULL;
}

// *********************************************************************************

MyString & MyString::operator=(char letter) // string.operator=(char letter);
{
        Delete();
        size = 1;
        allocSize = 2;
        value = new char[allocSize];
        if (!value) throw MyExceptionMemory("MyString","operator=",allocSize);
        value[0]= letter;
        value[1]= '\0';
        return *this; // pour: s=t=u="coucou";
}

MyString & MyString::operator=(int integer)
{
        char temp[40];
        sprintf (temp,"%d",integer);
        *this = temp;
        return *this;
}

MyString & MyString::operator=(long linteger)
{
        char temp[80];
        sprintf (temp,"%d",linteger);
        *this = temp;
        return *this;
}

MyString & MyString::operator=(float floating)
{
        char temp[40];
        sprintf(temp,"%g",floating);
        *this = temp;
        return *this;
}

MyString & MyString::operator=(double lfloating)
{
        char temp[40];
        sprintf(temp,"%g",lfloating);
        *this = temp;
        return *this;
}

MyString & MyString::operator=(char *string) // string.operator=(char *string);
{
        Delete();
        if (!string) return *this;
        size= (long)strlen(string);
        allocSize = size +1;
        value = new char[allocSize];
        if (!value) throw MyExceptionMemory("MyString","operator=(char *)",allocSize);
        strcpy(value,string);
        return *this; // pour: s=t=u="coucou";
}

MyString & MyString::operator=(MyString &string)
{
        Delete();
        size = string.size;
        allocSize = size +1;
        value = new char[allocSize];
        if (!value) throw MyExceptionMemory("MyString","operator=(MyString &)",allocSize);
        strcpy (value,string.value);
        return *this;
}

// *********************************************************************************

BOOL MyString::operator==(char letter) 
{
        MyString temp = letter;
        return !strcmp (value,temp.value);
}

BOOL MyString::operator==(int integer) 
{
        MyString temp = integer;
        return !strcmp (value,temp.value);
}

BOOL MyString::operator==(long linteger) 
{
        MyString temp = linteger;
        return !strcmp (value,temp.value);
}

BOOL MyString::operator==(float floating) 
{
        MyString temp = floating;
        return !strcmp (value,temp.value);
}

BOOL MyString::operator==(double lfloating) 
{
        MyString temp = lfloating;
        return !strcmp (value,temp.value);
}

BOOL MyString::operator==(char *string) 
{
        if (!string) return FALSE;
        return !strcmp (value,string);
}

BOOL MyString::operator==(MyString &string)
{
        return !strcmp (value,string.value);
}

// *********************************************************************************

void MyString::operator+=(char letter) 
{
        // Celle solution n'inserais pas les '\0'
        MyString temp = letter;
        *this += temp;

        // Cette solution insert le '\0' mais les strcpy ne repsect plus alors le '\0'
        // Resize (size+1,TRUE);
        // value[size]=letter;
        // size+= 1;
}

void MyString::operator+=(int integer)
{
        MyString temp = integer;
        *this += temp;
}

void MyString::operator+=(long linteger)
{
        MyString temp = linteger;
        *this += temp;
}

void MyString::operator+=(float floating)
{
        MyString temp = floating;
        *this += temp;
}

void MyString::operator+=(double lfloating)
{
        MyString temp = lfloating;
        *this += temp;
}

void MyString::operator+=(char *string)
{
        if (!string) { *this; return; }

        long addSize = (long)strlen(string);
        Resize (size+addSize,TRUE);
        strcat (value,string);
        size+= addSize;
}

// *********************************************************************************

MyString operator+(MyString &string1,char *string2)
{
        MyString temp = string1;
        if (!string2) return temp;
        temp += string2;
        return temp;
}

// *********************************************************************************

MyString operator+(char *string1,MyString &string2)
{
        MyString temp;
        if (!string1)
        {
                temp = string2;
                return temp;
        }
        temp = string1;
        temp += string2;
        return temp;
}

// *********************************************************************************

MyString operator+(MyString &string,char letter)
{
        MyString temp = string;
        temp += letter;
        return temp;
}

MyString operator+(char letter,MyString &string)
{
        MyString temp = letter;
        temp += string;
        return temp;
}

MyString operator+(MyString &string,int integer)
{
        MyString temp = string;
        temp += integer;
        return temp;
}

MyString operator+(int integer,MyString &string)
{
        MyString temp = integer;
        temp += string;
        return temp;
}

MyString operator+(MyString &string,long linteger)
{
        MyString temp = string;
        temp += linteger;
        return temp;
}

MyString operator+(long linteger,MyString &string)
{
        MyString temp = linteger;
        temp += string;
        return temp;
}

MyString operator+(MyString &string,float floating)
{
        MyString temp = string;
        temp += floating;
        return temp;
}

MyString operator+(float floating,MyString &string)
{
        MyString temp = floating;
        temp += string;
        return temp;
}

MyString operator+(MyString &string,double lfloating)
{
        MyString temp = string;
        temp += lfloating;
        return temp;
}

MyString operator+(double lfloating,MyString &string)
{
        MyString temp = lfloating;
        temp += string;
        return temp;
}

MyString operator+(MyString &string1,MyString &string2)
{
        MyString temp = string1;
        temp += string2;
        return temp;
}

char &MyString::operator [] (int index)
{
        static char error='\0';
        index = GetPositionFromLeft(index);
        if (index!=-1) return value[index];
        else return error;
/*
        MyString temp;
        temp <<"out of bounds: index <> [-"<<size<<";"<<size<<"]";
        throw CMyException("MyString","operator[](int)",temp);
*/
}

// *********************************************************************************

MyString & operator << (MyString& string , char letter)
{
        string += letter;
        return string;
}

MyString & operator << (MyString& string , int integer)
{
        string += integer;
        return string;
}

MyString & operator << (MyString& string , long linteger)
{
        string += linteger;
        return string;
}

MyString & operator << (MyString& string , float floating)
{
        string += floating;
        return string;
}

MyString & operator << (MyString& string , double lfloating)
{
        string += lfloating;
        return string;
}

MyString & operator << (MyString& string1 , char *string2)
{
        string1 += string2;
        return string1;
}

MyString & operator << (MyString& string1 , MyString &string2)
{
        string1 += string2;
        return string1;
}

// *********************************************************************************

BOOL MyString::Resize()
{
        return Resize((int)strlen(value),TRUE);
}

// *********************************************************************************

BOOL MyString::Resize(int newSize,BOOL recopy)
{
        if (newSize<0) newSize=0;
        char *newValue = new char[newSize+1];
        if (!newValue) throw MyExceptionMemory("MyString","Resize",newSize+1);
        if (recopy && value) 
        {
                int curSize = min(newSize,allocSize-1);
                strncpy(newValue,value,newSize);
                newValue[curSize]='\0';
                Delete();
                size = curSize;
                allocSize = newSize+1;
        }
        else 
        {
                Delete();
                size = 0;
                allocSize = newSize+1;
                newValue[0]='\0';
        }
        value = newValue;
        return TRUE;
}

BOOL MyString::SubStringBeforToken(int numSubString,MyString &result,char *lstToken)
{
        int indexCur=0;
        int posIndex = size;
        int sizeLstToken = (int)strlen(lstToken);
        int signe = numSubString<0 ? -1 : 1;
        for (int i=numSubString<0;i<size;i++)
        {
                for (int j=0;j<sizeLstToken;j++)
                {
                        if (*this[i*size]==lstToken[j])
                        {
                                indexCur += signe;
                                if (indexCur==numSubString)
                                {
                                        posIndex = i-signe;
                                        CopyTo(result,i+signe,labs(posIndex-i));
                                        return TRUE;
                                }
                        }
                }
        }
        return FALSE;
}

// *********************************************************************************

char * MyString::GetValue(int index)
{
        if (index>=0 && index<size) return value+index;
        if (index<0 && index>=-size) return value+size+index;

        MyString temp;
        temp <<"out of bounds: index <> [-"<<size<<";"<<size<<"]";
        throw MyException("MyString","GetValue[](int)",temp);

}

BOOL MyString::CopyTo(MyString &result,int index,int sizeToCopy)
{
        int signe = index<0 ? -1 : 1;
        int indexReal = index+sizeToCopy*signe;
        if (sizeToCopy==-1) sizeToCopy = size-index;
        char oldLetter = operator[](indexReal);
        operator[](indexReal)='\0';
        result.Resize(sizeToCopy);
        result=GetValue(index);
        operator[](indexReal) = oldLetter;
        return TRUE;
}

// *********************************************************************************

void MyString::SplitPath(MyString *drive,MyString *dir,MyString *file,MyString *ext,MyString *driveDir,MyString *fileExt)
{
   char _drive[_MAX_DRIVE];
   char _dir[_MAX_DIR];
   char _file[_MAX_FNAME];
   char _ext[_MAX_EXT];

   _splitpath(value,(drive||driveDir)?_drive:NULL,(dir||driveDir)?_dir:NULL,(file||fileExt)?_file:NULL,(ext||fileExt)?_ext:NULL);

   if (drive) *drive=_drive;
   if (dir) *dir=_dir;
   if (file) *file=_file;
   if (ext) *ext=_ext;
   if (fileExt) { *fileExt<<clear<<_file<<_ext; }
   if (driveDir) { *driveDir<<clear<<_drive<<_dir; }
}

// *********************************************************************************

long MyString::ToInteger()
{
        long res;
        sscanf(value,"%d",&res);
        return res;
}

float MyString::ToFloat()
{
        float res;
        sscanf(value,"%f",&res);
        return res;
}

double MyString::ToDouble()
{
        double res;
        sscanf(value,"%lf",&res);
        return res;
}

// *********************************************************************************

BOOL MyString::FormatToNoCtrl()
{
        BOOL isChanged = FALSE;
        MyString temp;
        for (int i=0;i<size;i++)
        {
                if (value[i]>=32) temp+=value[i];
                else isChanged = TRUE;
        }
        *this=temp;
        return isChanged;
}

// *********************************************************************************

BOOL MyString::FormatToLower()
{
        BOOL isChanged = FALSE;
        for (int i=0;i<size;i++) 
                if (!islower(value[i]))
                {
                        value[i] = tolower(value[i]);
                        isChanged = TRUE;
                }
        return isChanged;
}

// *********************************************************************************

BOOL MyString::FormatToUpper()
{
        BOOL isChanged = FALSE;
        for (int i=0;i<size;i++) 
                if (!isupper(value[i]))
                {
                        value[i] = toupper(value[i]);
                        isChanged = TRUE;
                }
        return isChanged;
}

// *********************************************************************************

BOOL MyString::IsVisibleText()
{
        for (int i=0;i<size;i++)
        {
                if (value[i]>32 && value[i]!=255) return TRUE;
        }
        return FALSE;
}

// *********************************************************************************

void MyString::AddRepetitiveFormat(char *matrise,int nbCopy)
{
        for (int i=0;i<nbCopy;i++)
        {
                operator+=(matrise);
        }
}

int MyString::GetPositionFromLeft(int pos)
{
        pos = pos>=0? pos: size+pos;
        return pos<size? pos : -1;
}

int MyString::GetPositionFromRight(int pos)
{
        if (pos>=0) return -size+pos;
        else return pos;
}

BOOL MyString::Delete(int pos,BOOL after,char letterToFind)
{
        int posLeft = GetPositionFromLeft(pos);
        int posLeft2 = FindLetter(posLeft,after,letterToFind);
        if (posLeft2==-1) return FALSE;
        return Delete(pos,after,abs(posLeft-posLeft2)+1);
}

BOOL MyString::Delete(int pos,BOOL after,int nbLetter)
{
        int posLeft = GetPositionFromLeft(pos);
        if (!after) posLeft-=nbLetter-1;
        strncpy(value+posLeft,value+posLeft+nbLetter,size-posLeft-nbLetter);
        return Resize(size-nbLetter,TRUE);
}

BOOL MyString::Add(int pos,BOOL after,char letter)
{
        MyString temp;
        int posLeft = GetPositionFromLeft(pos);
        CopyTo(temp,0,posLeft+!after);
        temp<<letter;
        temp<<value+posLeft+!after+1;
        operator=(temp);
        return TRUE;
}

BOOL MyString::Add(int pos,BOOL after,int integer)
{
        return TRUE;
}
BOOL MyString::Add(int pos,BOOL after,long linteger)
{
        return TRUE;
}
BOOL MyString::Add(int pos,BOOL after,float floating)
{
        return TRUE;
}
BOOL MyString::Add(int pos,BOOL after,double lfloating)
{
        return TRUE;
}
BOOL MyString::Add(int pos,BOOL after,char *string)
{
        return TRUE;
}
BOOL MyString::Add(int pos,BOOL after,MyString &string)
{
        return TRUE;
}

int MyString::FindLetter(int pos,BOOL after,char letter)
{
        int posLeft = GetPositionFromLeft(pos);

        if (after)
        {
                for (int i=posLeft;i<size;i++)
                        if (value[i]==letter) return i;
        }
        else
        {
                for (int i=posLeft;i>=0;i--)
                        if (value[i]==letter) return i;
        }
        return -1;
}

int MyString::FindLetter(char letter)
{
        return FindLetter(0,TRUE,letter);
}

BOOL MyString::AddFormat(char *format,...)
{
        va_list args;
        int len;
        char *buffer;
        va_start(args,format);
        len = _vscprintf( format, args )+ 1; // _vscprintf doesn't count terminating '\0'
        buffer = (char *)malloc(len * sizeof(char));
        if (!buffer) return FALSE;
        vsprintf(buffer,format,args);
        operator+=(buffer);
        free(buffer);
        return TRUE;
}

MyString MyString::Mids(int beginPos,int sizeToCopy)
{
        MyString result;
        if (beginPos+sizeToCopy>size) return result;
        char oldlLetter = value[beginPos+sizeToCopy];
        value[beginPos+sizeToCopy]='\0';
        result=value+beginPos;
        value[beginPos+sizeToCopy]=oldlLetter;
        return result;
}

BOOL MyString::Format(char *format,...)
{
        va_list args;
        int len;
        char *buffer;
        va_start(args,format);
        len = _vscprintf( format, args )+ 1; // _vscprintf doesn't count terminating '\0'
        buffer = (char *)malloc(len * sizeof(char));
        if (!buffer) return FALSE;
        vsprintf(buffer,format,args);
        operator=(buffer);
        free(buffer);
        return TRUE;
}

BOOL MyString::IsBeginWith(char *model)
{
        return !strncmp(value,model,strlen(model));
}

char * MyString::TestSubString(char *text,BOOL caseSensitive)
{
        if (!caseSensitive)
        {
                MyString lowerThis(*this),lowerText(text);
                lowerThis.FormatToLower();
                lowerText.FormatToLower();
                return strstr(lowerText,lowerThis);
        }
        return strstr(text,value); 
}
void MyString::EnterHexaNumber(int value)
{
        int reste;
        char letter;
        Zero();
        while (value)
        {
                reste = value%16;
                value/=16;
                letter=reste>9?'A'+reste-10:'0'+reste;
                operator+=(letter);
        }
        Reverse();
}
void MyString::EnterBinNumber(int value)
{
        int reste;
        Zero();
        while (value)
        {
                reste = value%2;
                value/=2;
                operator+=((char)(reste+'0'));
        }
        Reverse();
}
void MyString::Reverse()
{
        if (size<2) return;
        char letter;
        char *begin,*end;
        begin=value;
        end=value+size-2;

        for (int i=0;i<(size/2);i++)
        {
                letter = *begin;
                *begin=*end;
                *end=letter;
                begin++;
                end--;
        }
}


MyString & operator << (MyString& in ,FncManipulateur fnc)
{
        fnc(in);
        return in;
}

void clear (MyString &in)
{
        in.Zero();
}

void ret (MyString &in)
{
        in<<"\n";
}

---