---

TString.cpp

Go to the documentation of this file.

// TString.cpp: implementation of the TString class.


#include "stdafx.h"
#include "TString.h"

// Macro Definitions

#ifdef UNICODE
    #define TSTRING_BUFFERSIZE(length) ((int)(sizeof(WCHAR) * length))
#else
    #define TSTRING_BUFFERSIZE(length) ((int)(length))
#endif

#define TSTRING_BUFFERLENGTHA(ansiString) (strlen(ansiString) + 1)

#define TSTRING_BUFFERLENGTHW(unicodeString) (wcslen(unicodeString) + 1)

// Construction/Destruction

TString::TString()
{
    bufferLength = 1;
    string = EMPTYSTRING;
}

TString::TString(const TString &copy)
{
    bufferLength = 1;
    string = EMPTYSTRING;
    set(copy.get());
}

TString::TString(PCSTR ansiString)
{
    bufferLength = 1;
    string = EMPTYSTRING;
    set(ansiString);
}

TString::TString(PCWSTR unicodeString)
{
    bufferLength = 1;
    string = EMPTYSTRING;
    set(unicodeString);
}

TString::TString(const WCHAR unicodeChar)
{
    bufferLength = 1;
    string = EMPTYSTRING;
    set(unicodeChar);
}

TString::TString(const CHAR ansiChar)
{
    bufferLength = 1;
    string = EMPTYSTRING;
    set(ansiChar);
}

TString::TString(const int integer)
{
    bufferLength = 1;
    string = EMPTYSTRING;
    set(integer);
}


TString::~TString()
{
    memoryDealloc();
}



PTSTR TString::EMPTYSTRING = TEXT("");

TString operator +( const TString& left, const TString& right)
{
    // Length of right (less term) + this length (includes term)
    const int totalLength = left.bufferLength - 1 + right.bufferLength;

    TString rtrn;

    // Alloc sufficient memory
    assert( rtrn.alloc( totalLength ) );

    // Copy left to rtrn (inc term)
    assert( rtrn.stringCopy( left, left.bufferLength ) == left.bufferLength );

#ifdef UNICODE

    wcscat( rtrn.string, right.string );

#else

    strcat( rtrn.string, right.string );

#endif

    return rtrn;
}

// The relience on the TString + TString operator by the following can 
// easily be removed to improve perfomance.
TString operator +( const TString& left, PCSTR right)
{
    return left + TString(right);
}

TString operator +( const TString& left, PCWSTR right)
{
    return left + TString(right);
}

TString operator +( PCSTR left, const TString& right)
{
    return TString(left) + right;
}

TString operator +( PCWSTR left, const TString& right)
{
    return TString(left) + right;
}

TString operator +( const TString& left, const WCHAR right)
{
    return left + TString(right);
}

TString operator +( const TString& left, const CHAR right)
{
    return left + TString(right);
}

TString operator +( const WCHAR left, const TString& right)
{
    return TString(left) + right;
}

TString operator +( const CHAR left, const TString& right)
{
    return TString(left) + right;
}


const TString &TString::operator=(const TString& right)
{
    if(&right != this)
        set(right.get());

    return *this;
}

const TString &TString::operator=(PCSTR right)
{
#ifndef UNICODE
    // if native to ansi then it is possible that this is a self assignment 
    if(right == string)
        return *this;
#endif

    set(right);

    return *this;
}

const TString &TString::operator=(PCWSTR right)
{
#ifdef UNICODE
    // if native to unicode then it is possible that this is a self assignment 
    if(right == string)
        return *this;
#endif

    set(right);

    return *this;
}

const TString &TString::operator =(const CHAR ansiChar)
{
    set(ansiChar);
    return *this;
}

const TString &TString::operator =(const WCHAR unicodeChar)
{
    set(unicodeChar);
    return *this;
}



const TString& TString::operator +=( const TString& right )
{
    TString left( *this );

    memoryDealloc();

    const int totalLength = left.bufferLength - 1 + right.bufferLength;

    assert( alloc( totalLength ) );

    assert( stringCopy ( left, left.bufferLength ) == left.bufferLength );

#ifdef UNICODE

    wcscat( string, right.string );

#else

    strcat( string, right.string );

#endif

    return *this;
}

// The relience on the += TString operator by the following can 
// easily be removed to improve perfomance.
const TString& TString::operator +=( PCSTR right )
{
    *this += TString(right);
    return *this;
}

const TString& TString::operator +=( PCWSTR right )
{
    *this += TString(right);
    return *this;
}

const TString &TString::operator +=( const WCHAR right )
{
    *this += TString(right);
    return *this;
}

const TString &TString::operator +=( const CHAR right )
{
    *this += TString(right);
    return *this;
}


TCHAR TString::operator []( const int index ) const
{
    if( index < 0 || index > bufferLength - 1 )
        RaiseException(EXCEPTION_ARRAY_BOUNDS_EXCEEDED, 0, 0, NULL);

    TCHAR rtrn = string[index];
    return rtrn;
}

bool TString::operator !() const
{
    return bufferLength == 1;
}


bool TString::set(PCSTR ansiString)
{
    if( ansiString == NULL ){
        clear();
        return true;
    }

    int ansiLength = TSTRING_BUFFERLENGTHA(ansiString);

    if( memoryAlloc(ansiString) == TSTRING_BUFFERSIZE(ansiLength) )
        return stringCopy(ansiString, ansiLength) == ansiLength;
    else
        return false;
}

bool TString::set(PCWSTR unicodeString)
{
    if( unicodeString == NULL ){
        clear();
        return true;
    }

    int unicodeLength = TSTRING_BUFFERLENGTHW(unicodeString);

    if( memoryAlloc(unicodeString) == TSTRING_BUFFERSIZE(unicodeLength) )
        return stringCopy(unicodeString, unicodeLength) == unicodeLength;
    else
        return false;
}

bool TString::set(const CHAR ansiChar)
{
    if( alloc(1+1) ){
        *(string + 1)  = TEXT('');
        return stringCopy(&ansiChar, 1) == 1;
    } else
        return false;
}

bool TString::set(const WCHAR unicodeChar)
{
    if( alloc(1+1) ){
        *(string + 1)  = TEXT('');
        return stringCopy(&unicodeChar, 1) == 1;
    } else
        return false;
}

bool TString::set(const int integer)
{
    TCHAR temp[12]; // temp: longest string needed to represent int

#ifdef UNICODE
    swprintf(temp, L"%d", integer);
#else
    sprintf(temp, "%d", integer);
#endif 

    return set(temp);
}


PCTSTR TString::get() const
{
    return string;
}

TString::clear()
{
    memoryDealloc();
}

int TString::getBufferSize() const
{
    return TSTRING_BUFFERSIZE(bufferLength);
}

int TString::getLength() const
{
    return bufferLength - 1;
}


int TString::memoryAlloc(PCSTR ansiString, const bool allocate)
{
    int length;

#ifdef UNICODE

    // Calculate string length
    length = MultiByteToWideChar(
            CP_ACP,     // code page
            0,          // character-type options
            ansiString, // string to map
            -1,         // calculate number characters in string (inc terminator)
            NULL,       // wide-character buffer (not used yet)
            0);         // return size of required buffer in bytes

    if( !allocate || length == 0)
        return TSTRING_BUFFERSIZE(length);

#else

    length = calculateTotalLength(ansiString);

    if( !allocate )
        return TSTRING_BUFFERSIZE(length);

#endif

    memoryDealloc();

    if( alloc(length) )
        return TSTRING_BUFFERSIZE(bufferLength);
    else 
        return -1;

}

int TString::memoryAlloc(PCWSTR unicodeString, const bool allocate)
{
    int length;

#ifdef UNICODE

    length =  TSTRING_BUFFERLENGTHW(unicodeString);

    if( !allocate )
        return TSTRING_BUFFERSIZE(length);

#else

    length = WideCharToMultiByte(
            CP_ACP,         // code page
            0,              // performance and mapping flags
            unicodeString,  // wide-character string
            -1,             // calculate number of chars in string
            NULL,           // buffer for new string (not used yet)
            0,              // return size of required buffer in bytes
            NULL,           // default for unmappable chars
            NULL);          // set when default char used

    if( !allocate || length == 0)
        return TSTRING_BUFFERSIZE(length);

#endif    

    memoryDealloc();

    if( alloc(length) )
        return TSTRING_BUFFERSIZE(bufferLength);
    else 
        return -1;

}

bool TString::alloc(const int length)
{
    // Allocate memory
    string = new TCHAR[TSTRING_BUFFERSIZE(length)];
    // Check Allocation
    if ( string == NULL ){
        bufferLength = 1;
        string = EMPTYSTRING;
        return false;
    } else {
        bufferLength = length;
        return true;
    }
}

TString::memoryDealloc()
{
    if( string != EMPTYSTRING ){
        delete [] string;
        string = EMPTYSTRING;
        bufferLength = 1;
    }
}

int TString::stringCopy(PCSTR ansiString, const int length)
{
#ifdef UNICODE

    // Convert ANSI to Unicode
    return MultiByteToWideChar(CP_ACP, 0, ansiString, length, string, TSTRING_BUFFERSIZE(bufferLength));

#else

    int ansiLength = length;
    if( ansiLength < 0 ){
        ansiLength = calculateTotalLength(ansiString);
    }

    __try{
        CopyMemory(string, ansiString, TSTRING_BUFFERSIZE(ansiLength));
    }
    __except( (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION) 
            ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        return -1;
    }
    
    return ansiLength;

#endif
}

int TString::stringCopy(PCWSTR unicodeString, const int length)
{
#ifdef UNICODE

    int unicodeLength = length;
    if( unicodeLength < 0 ){
        unicodeLength = TSTRING_BUFFERLENGTHW(unicodeString);
    }

    __try{
        CopyMemory(string, unicodeString, TSTRING_BUFFERSIZE(unicodeLength));
    }
    __except( (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION) 
            ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        return -1;
    }
    
    return unicodeLength;

#else

    // Convert Unicode to ANSI
    return WideCharToMultiByte(CP_ACP,  0, unicodeString, length, string, TSTRING_BUFFERSIZE(bufferLength), NULL, NULL);

#endif
}

---