//****************************************************************// // Filename: SIFC_Strings.cpp // Autor: Christian Taulien of Strange Intelligence // Purpose: Implementierung der StringC Klasse // Creation: 27. Mai 1997 //****************************************************************// #define RCSID_SIFC_STRINGS_CPP "$Id: SIFC_Strings.cpp 1.23 1998/04/20 02:44:01 Christian_Taulien Exp Christian_Taulien $" #include "SIFC_Strings.h" #include #include //#ifdef si_debug //#undef si_debug //#define si_debug_x //#endif /*S*/ // stringc-needed macros #ifndef SIFC_MAX # define SIFC_MAX(a,b) ((a)>(b) ? (a) : (b)) #endif void dummyFunc(void *,...) {}; #ifndef SIFC_MIN # define SIFC_MIN(a,b) ((a)<(b) ? (a) : (b)) #endif #ifndef TRACEMETHOD # ifdef si_debug # define TRACEMETHOD cout << __FUNC__ " [this: " << (void *) this << "]" << endl; # else # define TRACEMETHOD # endif #endif // TRACE-Macro #ifndef TRACE # ifdef si_debug # define TRACE printf # else # define TRACE ::dummyFunc # endif #endif #ifndef ASSERT # ifdef si_asserts # define ASSERT(condition) if (!(condition)) \ {\ cout << "!!!Assertion failed: \"" << #condition << "\", in file " << __FILE__ << " line " << __LINE__ << endl;\ } # else # define ASSERT(contition) # endif #endif #define STRINGC_XC "stringc-class-exception" /*E*/ StringDataC glob_oEmptyStringData = { "", 0, 0, 1 }; const char *StringC::m_asStringTable[StringC::STRINGC_AccessLast] = /*S*/ { "tried to access a char not in bufferrange", "not enough memory for string addition", "write access on empty string", "illegal use of zero-string length" }; /*E*/ // private methods ------------------------------------------------- const char *StringC::getStringTableEntry(ULONG arg_ulIndex) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: getStringTableEntry() * * Klasse: StringC * * Funktion: ermittelt einen Bibliotheken-String * * Zugriff: private * * Eingabe-Parameter: 1 * ULONG arg_ulIndex: Der Index des gewünschten Strings * [0...STRINGC_Last aus der enum-Anweisung] * * Ausgabe-Parameter: const char *: Zeiger auf den ermittelten String * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: 1 * global_sSpecialErr_WrongStringID: Zeiger auf Text für schweren Fehler * * Benutzte Methoden: - * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 4. Juni 1997 * * Letzte Änderungen/Neuerungen: * 4. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { ASSERT(arg_ulIndex < STRINGC_Last) // if the index is smaller than STRINGC_Last (max. ID) if (arg_ulIndex < STRINGC_Last) { // return the wanted string return(m_asStringTable[arg_ulIndex]); } else { // return a heavy-error-message return("###"); } // if (arg_ulIndex < STRINGC_Last) } /*E*/ BOOL StringC::isFilled() /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: * * Klasse: * * Funktion: * * Zugriff: * * Eingabe-Parameter: * * Ausgabe-Parameter: * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 1. April 1998: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(m_poData) return m_poData != &glob_oEmptyStringData; } /*E*/ BOOL StringC::isMultiUsed() /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: * * Klasse: * * Funktion: * * Zugriff: * * Eingabe-Parameter: * * Ausgabe-Parameter: * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 1. April 1998: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(m_poData); return m_poData->m_lRefs > 1 ? TRUE : FALSE; } /*E*/ void StringC::decReference() /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: * * Klasse: * * Funktion: * * Zugriff: * * Eingabe-Parameter: * * Ausgabe-Parameter: * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 1. April 1998: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()); // if we are not the default pointer if (isFilled() && isMultiUsed()) { // increment the reference counter m_poData->m_lRefs--; } // if } /*E*/ void StringC::incReference() /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: * * Klasse: * * Funktion: * * Zugriff: * * Eingabe-Parameter: * * Ausgabe-Parameter: * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 1. April 1998: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()); // if we are not the default pointer if (isFilled()) { // increment the reference counter m_poData->m_lRefs++; } // if } /*E*/ void StringC::prepareModify() /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: * * Klasse: * * Funktion: * * Zugriff: * * Eingabe-Parameter: * * Ausgabe-Parameter: * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 2. April 1998 * * Letzte Änderungen/Neuerungen: * 2. April 1998: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) // if the object is empty or multiused if (!isFilled() || isMultiUsed()) { // allocate a new data-object StringDataC *poNewData = new StringDataC; if (!poNewData) { throw STRINGC_XC; } // if // take over the datas poNewData->m_ulStrLen = m_poData->m_ulStrLen; poNewData->m_ulBufLen = SIFC_MAX(m_poData->m_ulBufLen,8); poNewData->m_lRefs = 1; // allocate the buffer poNewData->m_sStrPtr = new char [m_poData->m_ulBufLen+1]; if (!poNewData->m_sStrPtr) { delete poNewData; throw STRINGC_XC; } // ... and copy the string memcpy(poNewData->m_sStrPtr, m_poData->m_sStrPtr, poNewData->m_ulBufLen); poNewData->m_sStrPtr[poNewData->m_ulStrLen] = '\0'; // from now on, we're changed to the new buffer m_poData = poNewData; } // if } /*E*/ StringC::StringC(ULONG arg_ulStrLen, ULONG arg_ulBufLen, char *arg_sStrPtr) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: * * Klasse: * * Funktion: * * Zugriff: * * Eingabe-Parameter: * * Ausgabe-Parameter: * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 1. April 1998: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD m_poData = new StringDataC; if (!m_poData) { throw STRINGC_XC; } // if m_poData->m_sStrPtr = arg_sStrPtr; m_poData->m_ulStrLen = arg_ulStrLen; m_poData->m_ulBufLen = arg_ulBufLen; m_poData->m_lRefs = 1; } /*E*/ // protected methods ----------------------------------------------- #ifdef si_debug void StringC::dumpContext(void) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: dumpContext() * * Klasse: StringC * * Funktion: gibt den Inhalt der Datenmember nach cout aus * * Zugriff: protected * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 28. Mai 1997 * * Letzte Änderungen/Neuerungen: * 28. Mai 1997: Methode definiert * *************************************************************************/ /*E*/ { ASSERT(checkInstance()) cout << "+++ StringC-Datenmembers: +++" << endl; cout << "StringC::m_sStrPtr=\t\t" << (void *) m_poData->m_sStrPtr << endl; cout << "StringC::m_ulStrLen=\t\t" << m_poData->m_ulStrLen << endl; cout << "StringC::m_ulBufLen=\t\t" << m_poData->m_ulBufLen << endl; cout << "StringC::m_rRefs=\t\t\t" << m_poData->m_lRefs << endl; cout << "+++ StringC dump complete " << endl; } /*E*/ #endif void StringC::initStringC(const char *arg_sStrPtr, ULONG arg_ulBufLen) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: initStringC() [Nr. 1] * * Klasse: StringC * * Funktion: initialisiert ein Objekt anhand eines Quellpointers und * einer Bufferlänge * * Zugriff: protected * * Eingabe-Parameter: 2 * char *arg_sStrPtr: Der Zeiger auf den Quell-String (wird kopiert) * ULONG arg_ulBufLen: Gewünschte Länge des Buffers * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 4 * initInstance() * allocBuffer() * string.h/strlen() * string.h/strncpy() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 28. Mai 1997 * * Letzte Änderungen/Neuerungen: * 28. Mai 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(arg_sStrPtr) // Init & Alloc initInstance(); // for safety reasons an additional byte must be allocated allocBuffer(arg_ulBufLen); // Compute the new string length, but maximal the new buflength ULONG lStrLen=SIFC_MIN(arg_ulBufLen, strlen(arg_sStrPtr)); // copy the source-string strncpy(m_poData->m_sStrPtr, arg_sStrPtr, lStrLen); // init the values m_poData->m_ulStrLen=lStrLen; // the new string length m_poData->m_sStrPtr[lStrLen]=0; // set the terminating byte } /*E*/ void StringC::initStringC(ULONG arg_ulBufLen) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: initStringC() [Nr. 2] * * Klasse: StringC * * Funktion: Initialisiert das Objekt anhand einer Buffer-Größe * * Zugriff: protected * * Eingabe-Parameter: 1 * ULONG arg_ulBufLen: Gewünschte Größe des Buffers * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * allocBuffer() * initInstance() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Juni 1997 * * Letzte Änderungen/Neuerungen: * 28. Mai 1997: Methode definiert * 25. Juni 1997: memset() wird nun von allocBuffer() übernommen. * *************************************************************************/ /*E*/ { TRACEMETHOD // Parameter-Check ASSERT(arg_ulBufLen) // Init & Alloc initInstance(); // allocate buffer and initialize it with zeros allocBuffer(arg_ulBufLen); } /*E*/ void StringC::allocBuffer(ULONG arg_ulSize) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: allocBuffer() * * Klasse: StringC * * Funktion: alloziert Speicher für den String-Object-Buffer * Achtung: Wenn nicht genug Mem, dann wird eine XC geschmissen * * Zugriff: protected * * Eingabe-Parameter: 1 * ULONG arg_ulSize: Die Größe des Buffers in Bytes. NULL für Speicher * freigeben * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: 1 * global_sCommonErr_NoMem - bei Übergabe an XC * * Benutzte Methoden: 4 * freeBuffer() * isMultiUsed() * ObjectXC::ObjectXC() * string.h/memset() * * Version: 3.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 27. Mai 1997: Methode definiert * 4. Juni 1997: Speichermanagement verbessert. Es wird nur noch dann * neuer Speicher reserviert, wenn der alte Buffer nicht * groß genug für den neuen ist. Um Buffer explizit zu * schmälern sollte zuvor freeBuffer() aufgerufen werden * 1. April 1998: Speichermanagement für StringArrayC angepasst * *************************************************************************/ /*E*/ { TRACEMETHOD // a size of zero means freeBuffer() if (!arg_ulSize) { freeBuffer(); return; } // if (!arg_ulSize) // A new buffer can't contain a string yet m_poData->m_ulStrLen=0; // If multiused or the existing buffer is not big enough if (isMultiUsed() || m_poData->m_ulBufLen < arg_ulSize) { // free the old buffer freeBuffer(); // allocate a new big one // (dividable by 8 and mind 1 bigger than wanted) ULONG ulSize=(arg_ulSize+8) & (~0x7); m_poData = new StringDataC; if (!m_poData) { throw STRINGC_XC; } // if m_poData->m_sStrPtr = new char [ulSize]; if (!m_poData->m_sStrPtr) { // if the string-buffer could not be allocated delete m_poData; throw STRINGC_XC; } // if m_poData->m_ulBufLen = ulSize-1; // one wall-byte m_poData->m_lRefs = 1; } // if (m_ulBufLen < arg_ulSize) // always set the Bytes in the buffer to zero memset(m_poData->m_sStrPtr, 0, m_poData->m_ulBufLen+1); } /*E*/ void StringC::freeBuffer(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: freeBuffer(void) * * Klasse: StringC * * Funktion: Gibt den Puffer-Speicher eines String-Objekts frei und init- * ialisiert es wieder. * * Zugriff: protected * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 3 * isFilled() * isMultiUsed() * initInstance() * * Version: 2.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 27. Mai 1997: Methode definiert * 1. April 1998: Speichermanagement für StringArrayC angepasst. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(m_poData) ASSERT(m_poData->m_sStrPtr) // if we have a pointer to a string-data-object if (isFilled()) { // if the reference pointer if (isMultiUsed()) { decReference(); } else { // if there is something to free if (m_poData->m_ulBufLen) { delete [] m_poData->m_sStrPtr; } // if delete m_poData; } // if initInstance(); } // if } /*E*/ void StringC::resizeBuffer(ULONG arg_ulSize) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: resizeBuffer() * * Klasse: StringC * * Funktion: Verändert die Größe des Buffers * * Zugriff: protected * * Eingabe-Parameter: 1 * ULONG arg_ulSize: Die neue Größe des Buffers * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * releaseBuffer() * initStringC() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 4. Juni 1997 * * Letzte Änderungen/Neuerungen: * 4. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) // the resize-size must be min 2 chars ULONG ulSize = SIFC_MAX(arg_ulSize, 2); // save the buffer-pointer char *sTemp = releaseBuffer(); // now the old buffer can be freed if it is neccessary if (sTemp) { // allocate a new buffer with the right size, but the old string initStringC(sTemp, ulSize); delete [] sTemp; } else { // get the new buffer by giving just the new size initStringC(ulSize); } // if (sTemp) } /*E*/ ULONG StringC::getBufferSize(void) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: getBufferSize() * * Klasse: StringC * * Funktion: Ermittelt die Größe des Buffers * * Zugriff: protected * * Eingabe-Parameter: - * * Ausgabe-Parameter: ULONG: Die Größe des Buffers * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 1. April 1998: Speichermanagement für StringArrayC angepasst. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) return(m_poData->m_ulBufLen); } /*E*/ // public methods -------------------------------------------------- // Constructors & Destruktor StringC::StringC() /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: StringC() * * Klasse: StringC * * Funktion: Konstruktor * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * initInstance() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 2. März 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 2. März 1998: Fehler in den debug-infos berichtigt * *************************************************************************/ /*E*/ { TRACEMETHOD initInstance(); } /*E*/ StringC::StringC(const char *arg_sStrPtr) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: StringC() * * Klasse: StringC * * Funktion: Konstruktor mit const char-Pointer als Argument * * Zugriff: public * * Eingabe-Parameter: 1 * arg_sStrPtr: Zeiger auf eine Zeichenkette oder NULL * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * initString() * intiInstance() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 2. März 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 2. März 1998: Fehler in den Debuginfos berichtigt * *************************************************************************/ /*E*/ { TRACEMETHOD // if we got a non-zero-pointer if (arg_sStrPtr) { initStringC(arg_sStrPtr, strlen(arg_sStrPtr)); } else { // otherwise default init initInstance(); } // if } /*E*/ StringC::StringC(ULONG arg_ulBufLen) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: StringC() * * Klasse: StringC * * Funktion: Konstruktor mit Bufferlängenangabe * * Zugriff: public * * Eingabe-Parameter: 1 * arg_ulBufLen: Gewünschte Länge des StringBuffers * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * initString() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 2. März 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 2. März 1998: Fehler in den Debuginfos berichtigt * *************************************************************************/ /*E*/ { TRACEMETHOD // if the buflen is non-zero if (arg_ulBufLen) { initStringC(arg_ulBufLen); } else { // otherwise default way initInstance(); } // if } /*E*/ StringC::StringC(const char *arg_sStrPtr, ULONG arg_ulBufLen) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: StringC() * * Klasse: StringC * * Funktion: Konstruktor mit Zeichenketten- und Bufferlängenangabe * * Zugriff: public * * Eingabe-Parameter: 2 * arg_sStrPtr: Zeiger auf den Init-string * arg_ulBufLen: Gewünschte Länge des StringBuffers * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * initString() * initInstance() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 2. März 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 2. März 1998: Fehler in den Debuginfos berichtigt * *************************************************************************/ /*E*/ { TRACEMETHOD // if we got a non-zero string pointer at all if (arg_sStrPtr) { // ok - ready to init initStringC(arg_sStrPtr, arg_ulBufLen); } else { // but if we got a non-zero buflen if (arg_ulBufLen) { // init by buflen initStringC(arg_ulBufLen); } else { // init the object in a default way initInstance(); } // if } // if } /*E*/ StringC::StringC(const StringC &arg_roSrcObj) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: StringC() * * Klasse: StringC * * Funktion: Kopier-Konstruktor * * Zugriff: public * * Eingabe-Parameter: 1 * arg_roSrcObj: Referenz auf ein Quell-objekt * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * initString() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 2. März 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 2. März 1998: Fehler in den Debuginfos berichtigt * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(arg_roSrcObj.checkInstance()); // copy the datapointer m_poData = arg_roSrcObj.m_poData; // and increase the reference counter incReference(); } /*E*/ StringC::~StringC() /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: ~StringC() * * Klasse: StringC * * Funktion: Destruktor * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * freeBuffer() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 15. Oktober 1997 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD freeBuffer(); } /*E*/ // CVI-Methods BOOL StringC::checkInstance(void) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: checkInstance() * * Klasse: StringC * * Funktion: prüft, ob die Objekt-Instanz gültig ist * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: 1 * global_sEmptyString: der globale EmptryString * * Benutzte Methoden: - * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 11. Juni 1997: Methode definiert * 1. April 1998: Speichermanagement für StringArrayC angepasst. * *************************************************************************/ /*E*/ { TRACEMETHOD // worst case at all: if (!m_poData) { printf("!m_poData\n"); return FALSE; } // if // At no time, it is valid to have a zero-stringpointer if (!m_poData->m_sStrPtr) { printf("!m_poData->m_sStrPtr\n"); return(FALSE); } // if (!m_sStrPtr) // our StrLen can't be greater than our BufLen if (m_poData->m_ulStrLen > m_poData->m_ulBufLen) { printf("m_poData->m_ulStrLen > m_poData->m_ulBufLen\n"); return(FALSE); } // if (m_ulStrLen > m_ulBufLen) // if we got no BufLen, we can't have got a StrLen if (m_poData->m_ulStrLen && (!m_poData->m_ulBufLen)) { printf("m_poData->m_ulStrLen && (!m_poData->m_ulBufLen)\n"); return(FALSE); } // if (m_ulStrLen && (!m_ulBufLen)) // if our string is not zero-byted if (m_poData->m_sStrPtr[m_poData->m_ulStrLen]!=0) { printf("m_poData->m_sStrPtr[m_poData->m_ulStrLen]!=0\n"); return(FALSE); } // if (m_sStrPtr[m_ulStrLen]!=0) // if we reached this point, we are valid return(TRUE); } /*E*/ void StringC::validateInstance(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: validateInstance() * * Klasse: StringC * * Funktion: Überprüft die Objektinstanz und korrigiert es gegebenenfalls * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * initInstance() * string.h/strlen() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 11. Juni 1997: Methode definiert * 1. April 1998: Speichermanagement für StringArrayC angepasst. * *************************************************************************/ /*E*/ { TRACEMETHOD // if we have an invalid string pointer if (!m_poData->m_sStrPtr) { // initialize the object initInstance(); } else { // if buf is valid and no empty string if (m_poData->m_ulBufLen) { // there has to be a zero-byte m_poData->m_sStrPtr[m_poData->m_ulBufLen]=0; // compute the real string-length m_poData->m_ulStrLen=strlen(m_poData->m_sStrPtr); } // if (m_ulBufLen) // if if (m_poData->m_lRefs < 1) { m_poData->m_lRefs = 1; } // if } // if (!m_sStrPtr) } /*E*/ void StringC::initInstance(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: initInstance() * * Klasse: StringC * * Funktion: Initialisiert die StringC-Instanz * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: 1 * global_sEmtpyString - Zeiger auf eine leere Zeichenkette * * Benutzte Methoden: - * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 27. Mai 1997: Methode definiert * 1. April 1998: Speichermanagement für StringArrayC angepasst. * *************************************************************************/ /*E*/ { TRACEMETHOD // Assign the global empty string to the object m_poData = &glob_oEmptyStringData; } /*E*/ // static methods void StringC::initStatic(StringC *arg_poString) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: * * Klasse: * * Funktion: * * Zugriff: * * Eingabe-Parameter: * * Ausgabe-Parameter: * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 15. April 1998 * * Letzte Änderungen/Neuerungen: * 15. April 1998: Methode definiert * *************************************************************************/ /*E*/ { if (arg_poString) { arg_poString->m_poData = &glob_oEmptyStringData; } // if } /*E*/ // other public methods BOOL StringC::isEmpty(void) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: isEmpty() * * Klasse: StringC * * Funktion: Prüft, ob das Objekt eine Leere Zeichenkette repräsentiert * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: BOOL: TRUE, wenn der String leer ist (Länge=0) * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.2 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 2. März 1998: Fehler in den Debuginfos berichtigt * 1. April 1998: Speichermanagement für StringArrayC angepasst. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) return m_poData->m_ulStrLen ? FALSE : TRUE; } /*E*/ void StringC::emptyString(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: emptyString() * * Klasse: StringC * * Funktion: Leert den String. D.h. setzt einen Leerstring. * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * freeBuffer() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 2. März 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 2. März 1998: Fehler in den Debuginfos berichtigt * *************************************************************************/ /*E*/ { TRACEMETHOD freeBuffer(); } /*E*/ ULONG StringC::getLength(void) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: getLength() * * Klasse: StringC * * Funktion: Ermittelt die Länge des Strings * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: ULONG: Die Länge des Strings * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.2 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 2. März 1998: Fehler in den Debuginfos berichtigt * 1. April 1998: Speichermanagement für StringArrayC angepasst. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()); return m_poData->m_ulStrLen; } /*E*/ const char *StringC::getBuffer(void) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: getBuffer() * * Klasse: StringC * * Funktion: Ermittelt einen Zeiger auf den String als char * * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: const char *: Der Zeicher auf die Zeichenkette * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.2 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 1. April 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 28. Februar 1998: Fehler in der debug-info berichtigt. * 1. April 1998: Speichermanagement für StringArrayC angepasst. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) return m_poData->m_sStrPtr; } /*E*/ void StringC::freeExtra(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: freeExtra() * * Klasse: StringC * * Funktion: Minimiert den Speicherverbrauch. (Aber: Fragmentierung!) * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * resizeBuffer() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 2. März 1998 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * 2. März 1998: Fehler in den Debuginfos berichtigt * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) // prepareModify() is not nessecary, because // releaseBuffer() called by resizeBuffer() will // do this for us. resizeBuffer(strlen(m_poData->m_sStrPtr)); } /*E*/ char StringC::getAt(ULONG arg_ulIndex, BOOL arg_fResizeIfNeccessary /*=FALSE*/) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: getAt() * * Klasse: StringC * * Funktion: Ermittelt das n.te Zeichen des Strings * * Zugriff: public * * Eingabe-Parameter: 2 * ULONG arg_ulIndex: Das wievielte Zeichen ermittelt werden soll * BOOL arg_fResizeIfNeccessary: (optional, def=FALSE) TRUE, wenn der Buffer * vergrößert werden soll, wenn außerhalb des Buffers zugegriffen wird * * Ausgabe-Parameter: char: Das an der n.ten Stelle stehende Zeichen * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 3 * ObjectXC::ObjectXC() * getStringTableEntry() * resizeBuffer() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 29. Juni 1997 * * Letzte Änderungen/Neuerungen: * 4. Juni 1997: Methode definiert * 29. Juni 1997: Wenn versucht wird auch außerhalb der String-Länge * zuzugreifen, wird lediglich eine NULL zurückgegeben. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_ulIndex < getBufferSize()) // if the access is out of allocated range if (arg_ulIndex > getBufferSize()) { // and if no Resizing is wanted if (!arg_fResizeIfNeccessary) { // we have to throw a stone, okay not really but nearly ASSERT(FALSE); arg_ulIndex = NULL; } else { // reallocate memory resizeBuffer(arg_ulIndex); } // if (!arg_fResizeIfNeccessary) } // if (arg_ulIndex >= m_ulBufLen) // if we try to access out of the string length if (arg_ulIndex >= m_poData->m_ulStrLen) { // just return zero return(NULL); } // if (arg_ulIndex >= m_ulStrLen) return(m_poData->m_sStrPtr[arg_ulIndex]); } /*E*/ char *StringC::releaseBuffer(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: releaseBuffer() * * Klasse: StringC * * Funktion: gibt die Verwaltung des Buffers an andere frei * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: char *: Zeiger auf den Buffer * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * initInstance() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 4. Juni 1997 * * Letzte Änderungen/Neuerungen: * 4. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()); // safety - check if (!getBufferSize()) { return(NULL); } // if (!m_ulBufLen) // den Buffermodus auf jeden fall jetzt umschalten prepareModify(); // save pointer to the string char *sTemp = m_poData->m_sStrPtr; // re-init the object without freeing our mem (because we'll need it later) initInstance(); // return the pointer to the mem, now its left to the caller to free the mem return(sTemp); } /*E*/ char StringC::setAt(ULONG arg_ulIndex, char arg_cChar, BOOL arg_fResizeIfNeccessary /*=FALSE*/) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: setAt() * * Klasse: StringC * * Funktion: setzt das n.te byte und gibt das alte zurück * * Zugriff: public * * Eingabe-Parameter: 3 * ULONG arg_ulIndex: das wievielte byte bearbeitet werden soll * char arg_cChar: Dieses Byte wird an n.ter Stelle eingetragen * BOOL arg_fResizeIfNeccessary: (optional, def=FALSE) TRUE, wenn der Buffer * vergrößert werden soll, wenn außerhalb des Buffers zugegriffen wird * * Ausgabe-Parameter: char: das Zeichen, welches sich vorher an der stelle * befand * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 3 * ObjectXC::ObjectXC() * getStringTableEntry() * resizeBuffer() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 29. Juni 1997 * * Letzte Änderungen/Neuerungen: * 4. Juni 1997: Methode definiert * 29. Juni 1997: Zugriffe sind nur noch vor und am String-Ende erlaubt * Zugriffe hinter dem Zero-Byte werden ignoriert. * Wenn das Zero-Byte indiziert wird, so wird nach * der Schreiboperation die Stringlänge erhöht und * das Zero-Byte auf der nächsten Position gesetzt. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) // Access-Check (index should be smaller than buflen!) ASSERT(arg_ulIndex < getBufferSize()) char cOldChar = NULL; prepareModify(); // if the access is out of allocated range if (arg_ulIndex >= getBufferSize()) { // and if no resizing is wanted if (!arg_fResizeIfNeccessary) { ASSERT(FALSE); // we have to throw a stone throw STRINGC_XC; } // if (!arg_fResizeIfNeccessary) // reallocate memory resizeBuffer(arg_ulIndex); } // if the user accesses the "zero-byte" if (arg_ulIndex == getLength()) { // if we do not write a zerobyte if (arg_cChar != NULL) { // set the new char m_poData->m_sStrPtr[arg_ulIndex] = arg_cChar; // increase the string length an guarantee the zero-byte exists m_poData->m_ulStrLen++; m_poData->m_sStrPtr[m_poData->m_ulStrLen] = '\0'; } // if (arg_cChar != NULL) } else if (arg_ulIndex < getLength()) { // otherwise we only allow accesses inner the string // outer-string accesses will be ignored // save the old char cOldChar = m_poData->m_sStrPtr[arg_ulIndex]; // set the new char m_poData->m_sStrPtr[arg_ulIndex] = arg_cChar; // if we wrote a zerobyte if (arg_cChar == '\0') { // the given Index is the new string-length m_poData->m_ulStrLen = arg_ulIndex; } // if (arg_cChar == NULL) } // if (arg_ulIndex >= m_ulBufLen) // return the old char return(cOldChar); } /*E*/ void StringC::setString(const char *arg_sString) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: setString() * * Klasse: StringC * * Funktion: Zuweisungs-operator * * Zugriff: public * * Eingabe-Parameter: 1 * arg_sString: Ein Zeiger auf den neuen String * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 4 * initInstance() * string.h/strlen() * allocBuffer() * string.h/strncpy() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 10. Oktober 1997 * * Letzte Änderungen/Neuerungen: * 10. Oktober 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) // if we have got a zeropointer if (!arg_sString) { // default values initInstance(); } else { // calculate the string-length int iLen = strlen(arg_sString); // allocate the required buffer // (no need for prepareModify()) allocBuffer(iLen); // set the new length appropriately m_poData->m_ulStrLen = iLen; // copy the string strncpy(m_poData->m_sStrPtr, arg_sString, iLen); // put the zerobyte m_poData->m_sStrPtr[iLen] = 0; } // if } /*E*/ LONG StringC::compareStringNoCase(StringC &arg_roCompObj) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: compareStringNoCase() * * Klasse: StringC * * Funktion: vergleicht den String mit einem anderem ohne Beachtung der * Groß- und Kleinschreibung * * Zugriff: public * * Eingabe-Parameter: 1 * StringC &arg_roCompObj: eine Referenz auf ein StringC-Object mit dem * dieses Obj. verglichen werden soll. * * Ausgabe-Parameter: LONG: >0 wenn this>arg, <0 wenn this" * 12. Juni 1997 : Aus dem Berlin-Projekt übernommen und angepasst * Aufgrund der StringC-Implementierung können * NULL-Zeiger nicht auftreten. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()); ASSERT(arg_roCompObj.checkInstance()); return(Stricmp(m_poData->m_sStrPtr, arg_roCompObj.m_poData->m_sStrPtr)); } /*E*/ LONG StringC::compareStringNoCase(char *arg_sCompStr) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: compareStringNoCase() * * Klasse: StringC * * Funktion: Vergleicht den String mit einem anderem ohne Beachtung der * Groß- und Kleinschreibung * * Zugriff: public * * Eingabe-Parameter: 1 * char *arg_sCompStr: ein Zeiger auf ein String mit dem * dieses Obj. verglichen werden soll. * * Ausgabe-Parameter: LONG: >0 wenn this>arg, <0 wenn this" * 12. Juni 1997 : Aus dem Berlin-Projekt übernommen und angepasst * Aufgrund der StringC-Implementierung können * NULL-Zeiger nicht auftreten. * 30. Juni 1997: Komplett von der gleichnamigen Methode mit StringC& * als Parameter übernommen * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_sCompStr) return(Stricmp(m_poData->m_sStrPtr, arg_sCompStr)); } /*E*/ LONG StringC::compareStringLimited(StringC &arg_roCompObj, ULONG arg_ulLength) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: compareStringLimited() * * Klasse: StringC * * Funktion: Vergleicht den String mit einem Anderem mit Längenbegrenzung * * Zugriff: public * * Eingabe-Parameter: 2 * StringC &arg_roCompObj: Eine Referenz eines StringC-Objektes mit dem verglichen * werden soll * ULONG arg_ulLength: Die maximale Anzahl der Bytes die beim Vergleich * berücksichtigt werden sollen. * * Ausgabe-Parameter: LONG: >0 wenn this>s, <0 wenn this" * 12. Juni 1997: Aus dem Berlin-Projekt übernommen und angepasst * Aufgrund der StringC-Implementierung können * NULL-Pointer nicht auftreten. XC werden nur * bei Zugriff außerhalb der Range geworfen * 30. Juni 1997: Name des 2. Parameters berichtigt (l jetzt ul) * Es wird keine XC mehr geworfen, die Länge wird * automatisch auf die kleinere der beiden String- * Längen beschränkt. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_roCompObj.checkInstance()) arg_ulLength = SIFC_MIN(arg_ulLength, getLength()+1); arg_ulLength = SIFC_MIN(arg_ulLength, arg_roCompObj.getLength()+1); return(strncmp(m_poData->m_sStrPtr,arg_roCompObj.m_poData->m_sStrPtr, arg_ulLength)); } /*E*/ LONG StringC::compareStringLimited(char *arg_sCompStr, ULONG arg_ulLength) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: compareStringLimited() * * Klasse: StringC * * Funktion: Vergleicht den String mit einem Anderem mit Längenbegrenzung * * Zugriff: public * * Eingabe-Parameter: 2 * char *arg_sCompStr: Ein Zeiger auf einen String mit dem das Objekt * verglichen werden soll * ULONG arg_ulLength : Die maximale Anzahl der Bytes die beim Vergleich * berücksichtigt werden sollen. * * Ausgabe-Parameter: LONG: >0 wenn this>s, <0 wenn this" * 12. Juni 1997: Aus dem Berlin-Projekt übernommen und angepasst * Aufgrund der StringC-Implementierung können * NULL-Pointer nicht auftreten. XC werden nur * bei Zugriff außerhalb der Range geworfen * 30. Juni 1997: Es wird keine XC mehr geworfen, die Länge wird * automatisch auf die String-Länge beschränkt * Die Methode wurde von der gleichnamigen Version * die jedoch StringC& als 1. Parameter nimmt über- * nommen. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_sCompStr) arg_ulLength=SIFC_MIN(arg_ulLength,getLength()+1); return(strncmp(m_poData->m_sStrPtr,arg_sCompStr, arg_ulLength)); } /*E*/ LONG StringC::compareStringLimitedNoCase(StringC &arg_roCompObj, ULONG arg_ulLength) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: compareStringLimitedNoCase() * * Klasse: StringC * * Funktion: Vergleicht den String mit einem anderen mit Längenbegrenzung * * Zugriff: public * * Eingabe-Parameter: 2 * StringC &arg_roCompObj: eine Referenz eines StringC-Objektes mit dem * verglichen werden soll * ULONG arg_ulLength: Die maximale Anzahl der Bytes die beim Vergleich * berücksichtigt werden sollen. * * Ausgabe-Parameter: LONG: >0 wenn this>s, <0 wenn this" * 12. Juni 1997: Aus dem Berlin-Projekt übernommen und angepasst * 30. Juni 1997: Es wird keine XC mehr geworfen. Die Vergleichs- * länge wird automatisch auf die kleinere der * beiden String-Längen beschränkt. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_roCompObj.checkInstance()) arg_ulLength=SIFC_MIN(arg_ulLength,getLength()+1); arg_ulLength=SIFC_MIN(arg_ulLength,arg_roCompObj.getLength()+1); return(Strnicmp(m_poData->m_sStrPtr,arg_roCompObj.m_poData->m_sStrPtr, arg_ulLength)); } /*E*/ LONG StringC::compareStringLimitedNoCase(char *arg_sCompStr, ULONG arg_ulLength) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: compareStringLimitedNoCase() * * Klasse: StringC * * Funktion: Vergleicht den String mit einem anderen mit Längenbegrenzung * * Zugriff: public * * Eingabe-Parameter: 2 * StringC &arg_sCompStr: ein Zeiger auf den String mit dem verglichen * werden soll * ULONG arg_ulLength : Die maximale Anzahl der Bytes die beim Vergleich * berücksichtigt werden sollen. * * Ausgabe-Parameter: LONG: >0 wenn this>s, <0 wenn this" * 12. Juni 1997: Aus dem Berlin-Projekt übernommen und angepasst * 30. Juni 1997: Es wird keine XC mehr geworfen. Die Vergleichs- * länge wird automatisch auf die kleinere der * beiden String-Längen beschränkt. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_sCompStr) arg_ulLength=SIFC_MIN(arg_ulLength,getLength()+1); return(Strnicmp(m_poData->m_sStrPtr,arg_sCompStr, arg_ulLength)); } /*E*/ StringC StringC::midString(ULONG arg_ulFirst, ULONG arg_ulCount) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: midString() * * Klasse: StringC * * Funktion: Pedant zur BASIC-Funktion MID$() * * Zugriff: public * * Eingabe-Parameter: 2 * ULONG arg_ulFirst: 1. Zeichen das übernommen werden soll (index) * ULONG arg_ulCount: Anzahl der Zeichen * * Ausgabe-Parameter: Ein neues StringC-Objekt * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 3 * ObjectXC::ObjectXC() * getStringTableEntry() * StringC() * * Version: 1.2 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 6. August 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * 30. Juni 1997: Die Methode prüft die Zugriffe jetzt stärker. * Bei einer Länge von NULL wird eine XC geworfen. * Die Länge muß kleiner oder gleich der restlichen * Bytes ab dem Index sein. * 6. August 1997: Ist die Länge NULL, so wird keine XC mehr geworfen * Es wird nun ein leeres StringC-Objekt zurückgegeben. * was auch logischer ist. Außerdem wurde die Reihen- * folge der Prüfung verändert: Erst OutOfRange-Check * für das StartZeichen, dann Minimierung der Länge * Dann Prüfung auf Länge=NULL; * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_ulCount) ASSERT(arg_ulFirst+arg_ulCount <= getLength()) // if the first char is already out of range if (arg_ulFirst >= getLength()) { // we got to throw a stone throw STRINGC_XC; } // if // Minimize the Size of the destination string arg_ulCount=SIFC_MIN(arg_ulCount, getLength()-arg_ulFirst); // if the wanted stringlength is zero, if (!arg_ulCount) { // we return a zero-lengthened string return(StringC()); } // if return(StringC(m_poData->m_sStrPtr+arg_ulFirst, arg_ulCount)); } /*E*/ StringC StringC::midString(ULONG arg_ulFirst) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: midString() * * Klasse: StringC * * Funktion: Pedant zur BASIC-Funktion MID$() * Alles ab dem Index wird in einen neuen String übernommen * * Zugriff: public * * Eingabe-Parameter: 1 * ULONG arg_ulFirst: 1. Zeichen das übernommen werden soll (index) * * Ausgabe-Parameter: Ein neues StringC-Objekt * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 3 * ObjectXC::ObjectXC() * getStringTableEntry() * StringC() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 30. Juni 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * 30. Juni 1997: Die Methode kontrolliert den Zugriff schärfer * Für das Ergebnis wird ein sichererer Konstruktor ver- * wendet. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_ulFirst <= getLength()) if (arg_ulFirst >= getLength()) { throw STRINGC_XC; } // if return(StringC(m_poData->m_sStrPtr+arg_ulFirst, getLength()-arg_ulFirst)); } /*E*/ StringC StringC::leftString(ULONG arg_ulCount) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: leftString() * * Klasse: StringC * * Funktion: Pedant zur BASIC-Funktion LEFT$() * * Zugriff: public * * Eingabe-Parameter: 1 * ULONG arg_ulCount: Anzahl der Zeichen von links * * Ausgabe-Parameter: Ein neues StringC-Objekt * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 3 * ObjectXC::ObjectXC() * getStringTableEntry() * StringC() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 30. Juni 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * 30. Juni 1997: Eine Länge von NULL wird mit einer Exception geahndet * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_ulCount <= getLength()) if (!arg_ulCount || (arg_ulCount > getLength())) { throw STRINGC_XC; } // if return(StringC(m_poData->m_sStrPtr, arg_ulCount)); } /*E*/ StringC StringC::rightString(ULONG arg_ulCount) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: rightString() * * Klasse: StringC * * Funktion: Pedant zur BASIC-Funktion RIGHT$() * * Zugriff: public * * Eingabe-Parameter: 1 * ULONG arg_ulCount: Anzahl der Zeichen von rechts * * Ausgabe-Parameter: Ein neues StringC-Objekt * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 3 * ObjectXC::ObjectXC() * getStringTableEntry() * StringC() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 30. Juni 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * 30. Juni 1997: Eine Länge von NULL wird mit einer Exception geahndet * Außerdem wird ein sichererer Konstruktor verwendet. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_ulCount <= getLength()) if (!arg_ulCount || (arg_ulCount > getLength())) { throw STRINGC_XC; } // if return(StringC(m_poData->m_sStrPtr+getLength()-arg_ulCount, arg_ulCount)); } /*E*/ LONG StringC::findChar(char arg_cSearchedChar) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: findChar() * * Klasse: StringC * * Funktion: versucht ein Zeichen im String zu finden * * Zugriff: public * * Eingabe-Parameter: 1 * char arg_cSearchedChar: Das zu suchende Zeichen * * Ausgabe-Parameter: der Index des gefundenen Zeichens (-1 für nicht * gefunden) * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 13. Juni 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) LONG lFoundIndex=-1; // try for every of our chars for (int i=0; i < getLength(); i++) { // if we found our char if (m_poData->m_sStrPtr[i]==arg_cSearchedChar) { lFoundIndex=i; break; } // if } // for return(lFoundIndex); } /*E*/ LONG StringC::findCharNot(char arg_cSearchedChar) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: findCharNot() * * Klasse: StringC * * Funktion: versucht ein anderes Zeichen als das angegebene zu finden * * Zugriff: public * * Eingabe-Parameter: 1 * char arg_cSearchedChar: Das nicht zu suchende Zeichen * * Ausgabe-Parameter: der Index des gefundenen Zeichens (-1 für nicht * gefunden) * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 3. Juli 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * 3. Juli 1997: von findChar() übernommen und angepasst * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) LONG lFoundIndex=-1; // try for every of our chars for (int i=0; i < getLength(); i++) { // if we found our char if (m_poData->m_sStrPtr[i]!=arg_cSearchedChar) { lFoundIndex=i; break; } // if } // for return(lFoundIndex); } /*E*/ LONG StringC::findCharReverse(char arg_cSearchedChar) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: findCharReverse() * * Klasse: StringC * * Funktion: versucht ein Zeichen im String zu finden (Start von hinten) * * Zugriff: public * * Eingabe-Parameter: 1 * char arg_cSearchedChar: Das zu suchende Zeichen * * Ausgabe-Parameter: der Index des gefundenen Zeichens (-1 für nicht * gefunden) * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 13. Juni 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) LONG lFoundIndex=-1; // try for every of our chars for (int i = getLength()-1; i>=0 ; i--) { // if we found our char if (m_poData->m_sStrPtr[i]==arg_cSearchedChar) { lFoundIndex=i; break; } // if } // for return(lFoundIndex); } /*E*/ LONG StringC::findCharNotReverse(char arg_cSearchedChar) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: findCharReverseNot() * * Klasse: StringC * * Funktion: versucht ein anderes Zeichen als das angegebene zu finden * (Start von hinten) * * Zugriff: public * * Eingabe-Parameter: 1 * char arg_cSearchedChar: Das nicht zu suchende Zeichen * * Ausgabe-Parameter: der Index des gefundenen Zeichens (-1 für nicht * gefunden) * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 3. Juli 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * 3. Juli 1997: Von findCharNotReverse() übernommen und angepasst * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) LONG lFoundIndex=-1; // try for every of our chars for (int i = getLength()-1; i>=0 ; i--) { // if we found our char if (m_poData->m_sStrPtr[i] != arg_cSearchedChar) { lFoundIndex=i; break; } // if } // for return(lFoundIndex); } /*E*/ LONG StringC::findString(char *arg_sSearchedString) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: findString() * * Klasse: StringC * * Funktion: Sucht nach einem String innerhalb eines Strings * * Zugriff: public * * Eingabe-Parameter: 1 * char *arg_sSearchedString: Zeiger auf den zu suchenden String * * Ausgabe-Parameter: LONG: index an dem der string anfängt * (-1 = wenn nicht gefunden) * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * string.h/strlen() * string.h/strncmp() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 14. Juni 1997 * * Letzte Änderungen/Neuerungen: * 14. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_sSearchedString) LONG lFoundIndex=-1; // if we have something to find at all if (arg_sSearchedString && getBufferSize()) { // calculate the length of the argument-string ULONG ulSourceLen=strlen(arg_sSearchedString); // if the search-string is not empty and smaller than or same-sized as the object-string if (ulSourceLen && (ulSourceLen <= getLength())) { // try from left to right for (int i=0; i <= (getLength()-ulSourceLen); i++) { // compare this possibility if (0==strncmp(arg_sSearchedString, m_poData->m_sStrPtr+i, ulSourceLen)) { // Ahh! We found the string lFoundIndex=i; break; } // if } // for } // if } // if return(lFoundIndex); } /*E*/ LONG StringC::findString(const StringC &arg_roSearchedString) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: findString() * * Klasse: StringC * * Funktion: Sucht nach einem String innerhalb eines Strings * * Zugriff: public * * Eingabe-Parameter: 1 * StringC &arg_roSearchedString: Referenz auf das zu suchenden StringC-Obj * * Ausgabe-Parameter: LONG: Index an dem der String anfängt * -1 = wenn nicht gefunden * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * string.h/strncmp() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 14. Juni 1997 * * Letzte Änderungen/Neuerungen: * 14. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_roSearchedString.checkInstance()) LONG lFoundIndex=-1; // if we have something to find at all if (arg_roSearchedString.getBufferSize() && getBufferSize()) { ULONG ulSourceLen = arg_roSearchedString.getLength(); // if the search-string is not empty and smaller than or same-sized as the object-string if (ulSourceLen && (ulSourceLen <= getBufferSize())) { // search from left to right for (int i=0; i <= (getLength()-ulSourceLen); i++) { // try this possibility if (0==strncmp(arg_roSearchedString, m_poData->m_sStrPtr+i, ulSourceLen)) { // if we found the string lFoundIndex=i; break; } // if } // for } // if } // if return(lFoundIndex); } /*E*/ LONG StringC::findStringNoCase(char *arg_sSearchedString) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: findStringNoCase() * * Klasse: StringC * * Funktion: Sucht nach einem String innerhalb eines Strings ohne Beachtung * der Groß- und Kleinschreibung * * Zugriff: public * * Eingabe-Parameter: 1 * char *arg_sSearchedString: Zeiger auf den zu suchenden String * * Ausgabe-Parameter: LONG: index an dem der string anfängt (-1=nicht vorhanden) * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * string.h/strlen() * utility.library/Strnicmp() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 14. Juni 1997 * * Letzte Änderungen/Neuerungen: * 14. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_sSearchedString) LONG lFoundIndex=-1; // if we have something to find at all if (arg_sSearchedString && getBufferSize()) { ULONG ulSourceLen=strlen(arg_sSearchedString); // if the search-string is not empty and smaller than or same-sized as the object-string if (ulSourceLen && (ulSourceLen <= getLength())) { // search from left to right for (int i=0; i <= (getLength()-ulSourceLen); i++) { // try this possibility if (0==Strnicmp(arg_sSearchedString, m_poData->m_sStrPtr+i, ulSourceLen)) { // if we found the string lFoundIndex=i; break; } // if } // for } // if } // if return(lFoundIndex); } /*E*/ LONG StringC::findStringNoCase(const StringC &arg_roSearchedString) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: findStringNoCase() * * Klasse: StringC * * Funktion: Sucht nach einem String innerhalb eines Strings ohne beachtung der * Groß- und Kleinschreibung * * Zugriff: public * * Eingabe-Parameter: 1 * StringC &arg_roSearchedString: Referenz auf das zu suchenden StringC-Obj * * Ausgabe-Parameter: LONG: index an dem der string anfängt (-1=nicht vorhanden) * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * utility.library/Strnicmp() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 14. Juni 1997 * * Letzte Änderungen/Neuerungen: * 14. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_roSearchedString.checkInstance()) LONG lFoundIndex=-1; // if we have something to find at all if (arg_roSearchedString.getBufferSize() && getBufferSize()) { ULONG ulSourceLen=arg_roSearchedString.getLength(); // if the search-string is not empty and smaller than or same-sized as the object-string if (ulSourceLen && (ulSourceLen <= getLength())) { // Search from left to right for (int i=0; i <= (getLength()-ulSourceLen); i++) { // try this possibility if (0==Strnicmp(arg_roSearchedString, m_poData->m_sStrPtr+i, ulSourceLen)) { // if we found the string lFoundIndex=i; break; } // if } // for } // if } // if return(lFoundIndex); } /*E*/ LONG StringC::findOneOf(char *arg_sCharSet) const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: findOneOf() * * Klasse: StringC * * Funktion: Sucht nach meheren Zeichen zugleich. * * Zugriff: public * * Eingabe-Parameter: 1 * arg_sCharSet: Zeichenkette, die die gesuchten Zeichen enthält * * Ausgabe-Parameter: LONG: Index, an dem das erste Zeichen vom Set gefun- * den wurde. -1 wenn nichts gefunden wurde * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * string.h/strlen() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 14. Juni 1997 * * Letzte Änderungen/Neuerungen: * 14. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_sCharSet) LONG lFoundIndex=-1; BOOL fFound=FALSE; // if we got something to find at all if (arg_sCharSet && getBufferSize()) { // Calculate the length of the set ULONG ulCharSetLen=strlen(arg_sCharSet); // Search from left to right for (int i=0; im_sStrPtr[i]==arg_sCharSet[j]) { // if we found the char lFoundIndex=i; fFound=TRUE; break; } // if } // for } // for } // if return(lFoundIndex); } /*E*/ void StringC::makeUpper(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: makeUpper() * * Klasse: StringC * * Funktion: Wandelt den String in Großbuchstaben * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * utility.library/ToUpper() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 13. Juni 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { ASSERT(checkInstance()) prepareModify(); for (int i=0; im_sStrPtr[i] = ToUpper(m_poData->m_sStrPtr[i]); } // for } /*E*/ void StringC::makeLower(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: makeLower() * * Klasse: StringC * * Funktion: Wandelt einen String in Kleinbuchstaben * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * utility.library/ToLower() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 13. Juni 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) prepareModify(); for (int i=0; im_sStrPtr[i] = ToLower(m_poData->m_sStrPtr[i]); } // for } /*E*/ void StringC::makeReverse(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: makeReverse() * * Klasse: StringC * * Funktion: Tauscht die Groß- und Kleinschreibung eines Strings * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * utility.library/ToLower() * utility.library/ToUpper() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 13. Juni 1997 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) prepareModify(); for (int i=0; im_sStrPtr[i]==ToLower(m_poData->m_sStrPtr[i])) { // convert it to uppercase m_poData->m_sStrPtr[i]=ToUpper(m_poData->m_sStrPtr[i]); } else { // otherwise to lowercase m_poData->m_sStrPtr[i]=ToLower(m_poData->m_sStrPtr[i]); } // if } // for } /*E*/ void StringC::trimRight(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: trimRight() * * Klasse: StringC * * Funktion: Entfernt alle anhängenden Leerzeichen * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 3 * freeBuffer() * prepareModify() * getBufferSize() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Mai 1998 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * 25. Mai 1998: Bug beseitigt, der durch falsche getLength()-Anwendung * Assertions hervorrief * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) prepareModify(); // if we got a buffer at all if (getBufferSize()) { // As long as our length is not zero and the last byte is a space while(m_poData->m_ulStrLen && m_poData->m_sStrPtr[m_poData->m_ulStrLen-1]==' ') { // decrement our length counter m_poData->m_ulStrLen--; } // while // if we left no char if (!m_poData->m_ulStrLen) { freeBuffer(); } else { // append a zero-byte m_poData->m_sStrPtr[m_poData->m_ulStrLen] = 0; } // if } // if } /*E*/ void StringC::trimLeft(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: trimLeft() * * Klasse: StringC * * Funktion: Entfernt alle voranstehenden Leerzeichen * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 4 * freeBuffer() * string.h/memcpy() * prepareModify() * getBufferSize() * * Version: 1.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Mai 1998 * * Letzte Änderungen/Neuerungen: * 13. Juni 1997: Methode definiert * 25. Mai 1998: Bug beseitigt, der durch falsche getLength()-Anwendung * Assertions hervorrief * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) prepareModify(); // if we have a buffer at all if (getBufferSize()) { ULONG ulIndex=0; while ((ulIndex < getLength()) && m_poData->m_sStrPtr[ulIndex]==' ') ulIndex++; // if we found at least one space if (ulIndex) { // calculate the new stringlength m_poData->m_ulStrLen-=ulIndex; // if our String length decreased to zero if (!m_poData->m_ulStrLen) { freeBuffer(); } else { // otherwise move the string to beginning of the buffer memcpy(m_poData->m_sStrPtr, m_poData->m_sStrPtr+ulIndex, m_poData->m_ulStrLen); m_poData->m_sStrPtr[m_poData->m_ulStrLen]=0; } // if } // if } // if } /*E*/ void StringC::trimString(void) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: trimString() * * Klasse: StringC * * Funktion: Entfernt alle voranstehenden und hintanstehenden Leerzeichen * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: - * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: 2 * trimLeft(); * trimRight(); * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 2. Juli 1997 * * Letzte Änderungen/Neuerungen: * 2. Juli 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD trimLeft(); trimRight(); } /*E*/ void StringC::formatString(char *arg_sFormat, ...) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: formatString() * * Klasse: StringC * * Funktion: Formatieren eines Strings * * Zugriff: public * * Eingabe-Parameter: 1+ * char *arg_sFormat: Zeiger auf eine Zeichenkette mit Format angaben * ... Die variable Parameterliste entsprechend dem 1. Parameter * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 7 * ObjectXC::ObjectXC() * stdio.h/vsprintf() * string.h/strlen() * validateInstance() * getStringTableEntry() * stdarg.h/va_start() * stdarg.h/va_end() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 14. Juni 1997 * * Letzte Änderungen/Neuerungen: * 14. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_sFormat) prepareModify(); if (!getBufferSize()) { throw STRINGC_XC; } // if if (!arg_sFormat) { throw STRINGC_XC; } // if ASSERT(strlen(arg_sFormat)<=getBufferSize()) va_list arg; va_start(arg,arg_sFormat); vsprintf(m_poData->m_sStrPtr, arg_sFormat, arg); va_end(arg); validateInstance(); } /*E*/ void StringC::fillString(char arg_cFillByte) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: fillString() * * Klasse: StringC * * Funktion: Füllt den String mit einem bestimmten Zeichen * * Zugriff: public * * Eingabe-Parameter: 1 * char arg_cFillByte: Das Zeichen mit dem der String gefüllt werden soll * * Ausgabe-Parameter: - * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 14. Juni 1997 * * Letzte Änderungen/Neuerungen: * 14. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) prepareModify(); if (getBufferSize()) { for (int i=0; im_sStrPtr[i]=arg_cFillByte; } // for } // if if (!arg_cFillByte) { m_poData->m_ulStrLen=0; } // if } /*E*/ // operator-overloading char StringC::operator[](int arg_iIndex) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator[] * * Klasse: StringC * * Funktion: Ermittelt das n.te Zeichen des Buffers * * Zugriff: public * * Eingabe-Parameter: 1 * int arg_iIndex: Das wievielte Zeichen angesprochen werden soll * * Ausgabe-Parameter: Das Zeichen, das am angegebenen Index steht * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * resizeBuffer() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 4. Juni 1997 * * Letzte Änderungen/Neuerungen: * 4. Juni 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) // if the access is out of allocated range if (arg_iIndex >= getBufferSize()) { // reallocate memory resizeBuffer(arg_iIndex); } // if (arg_iIndex >= m_ulBufLen) return(m_poData->m_sStrPtr[arg_iIndex]); } /*E*/ StringC::operator char *() const /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator char *() * * Klasse: StringC * * Funktion: Cast-Operator für StringC -> char * * * Zugriff: public * * Eingabe-Parameter: - * * Ausgabe-Parameter: automatisch: char *: Zeiger auf die Zeichenkette * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: - * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 15. Oktober 1997 * * Letzte Änderungen/Neuerungen: * 15. Oktober 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD return(m_poData->m_sStrPtr); } /*E*/ StringC &StringC::operator= (const char *arg_sString) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator =() * * Klasse: StringC * * Funktion: Zuweisungsoperator * * Zugriff: public * * Eingabe-Parameter: 1 * arg_sString: Der neue String * * Ausgabe-Parameter: StringC &: Eine Referenz auf das StringC-Objekt * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 1 * setString() * * Version: 1.0 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 10. Oktober 1997 * * Letzte Änderungen/Neuerungen: * 10. Oktober 1997: Methode definiert * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) setString(arg_sString); return(*this); } /*E*/ StringC &StringC::operator= (const StringC &arg_roSrcObj) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator=() * * Klasse: StringC * * Funktion: Zuweisunsoperator * * Zugriff: public * * Eingabe-Parameter: 1 * arg_roSrcObj: Eine Referenz auf ein StringC-Objekt * * Ausgabe-Parameter: Eine Referenz auf das behandelte StringC-Objekt * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 4 * string.h/strncpy() * allocBuffer() * initInstance() * inherited::operator=() * * Version: 2.2 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 23. August 1997 * * Letzte Änderungen/Neuerungen: * 29. Dezember 1996: Methode definiert * 4. Juni 1997: Übernommen und komplett überarbeitet vom * Berlin-Projekt * 23. August 1997: Die Basisklasse wird jetzt durch "inherited" * angesprochen * 10. Oktober 1997: Leicht optimiert. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_roSrcObj.checkInstance()) if (this != &arg_roSrcObj) { freeBuffer(); m_poData = arg_roSrcObj.m_poData; incReference(); } // if return(*this); } /*E*/ StringC &StringC::operator += (const StringC &arg_roSummand) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator +=() * * Klasse: StringC * * Funktion: Additions/Zuweisungs-Operator * * Zugriff: public * * Eingabe-Parameter: 1 * const StringC &arg_roSummand: Eine Referenz auf ein StringC-Objekt * * Ausgabe-Parameter: Eine Referenz auf das behandelte neue StringC-Objekt * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * resizeBuffer() * string.h/strcat() * * Version: 2.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Juni 1997 * * Letzte Änderungen/Neuerungen: * 11. Januar 1997: Methode definiert * 11. Juni 1997: Übernommen aus dem Berlin-Projekt und angepasst * 25. Juni 1997: GetLength() wird nicht mehr verwendet. Die Länge * der Teilstrings wird direkt ausgelesen. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) ASSERT(arg_roSummand.checkInstance()) // Compute the required length to hold both strings ULONG ulNewLen = getLength() + arg_roSummand.getLength(); // if this length is bigger than the existing length if (ulNewLen > getBufferSize()) { // allocate the buffer in a appropriate size resizeBuffer(ulNewLen); } // if (ulNewLen > m_ulBufLen) prepareModify(); // Concatenate the both strings strcat(m_poData->m_sStrPtr, arg_roSummand.m_poData->m_sStrPtr); return(*this); } /*E*/ StringC &StringC::operator += (const char *arg_sSummand) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator +=() * * Klasse: StringC * * Funktion: Additions/Zuweisungs-Operator * * Zugriff: public * * Eingabe-Parameter: 1 * const char *arg_sSummand: Ein Zeiger auf den anzuhängenden String * * Ausgabe-Parameter: Eine Referenz auf das behandelte neue StringC-Objekt * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 3 * resizeBuffer() * string.h/strcat() * string.h/strlen() * * Version: 2.1 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Juni 1997 * * Letzte Änderungen/Neuerungen: * 11. Januar 1997: Methode definiert * 11. Juni 1997: Übernommen aus dem Berlin-Projekt / angepasst * 25. Juni 1997: GetLength() wird nicht mehr verwendet. Die Länge * der Teilstrings wird direkt ausgelesen. * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) // Compute the required length to hold both strings ULONG ulNewLen = getLength() + strlen(arg_sSummand); // if this length is bigger than the existing length if (ulNewLen > getBufferSize()) { // allocate the buffer in a appropriate size resizeBuffer(ulNewLen); } // if (ulNewLen > m_ulBufLen) prepareModify(); // conatenate the both strings strcat(m_poData->m_sStrPtr, arg_sSummand); return(*this); } /*E*/ StringC &StringC::operator += (const char arg_cSummand) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator +=() * * Klasse: StringC * * Funktion: Additions/Zuweisungs-Operator * * Zugriff: public * * Eingabe-Parameter: 1 * const char arg_cSummand: Ein hinzuzufügendes Zeichen * * Ausgabe-Parameter: Eine Referenz auf das behandelte neue StringC-Objekt * * Aufgerufen von: - * * Verwendung folgender globaler Variablen/Strukturen: - * * Benutzte Methoden: 2 * resizeBuffer() * string.h/strlen() * * Version: 2.2 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Juni 1997 * * Letzte Änderungen/Neuerungen: * 11. Januar 1997: Methode definiert * 11. Juni 1997: Übernommen aus dem Berlin-Projekt / angepasst * 25. Juni 1997: GetLength() wird nicht mehr verwendet. Die Länge * der Teilstrings wird direkt ausgelesen. * Es wird nun auch die neue Länge explizit berech- * net * *************************************************************************/ /*E*/ { TRACEMETHOD ASSERT(checkInstance()) // Compute the required length to hold both strings ULONG ulNewLen = getLength() + sizeof(char); // if this length is bigger than the existing length if (ulNewLen > getBufferSize()) { // allocate the buffer in a appropriate size resizeBuffer(ulNewLen); } prepareModify(); // append the char m_poData->m_sStrPtr[ulNewLen-sizeof(char)]=arg_cSummand; m_poData->m_sStrPtr[ulNewLen]=0; // recalculate the new strlen explicitly m_poData->m_ulStrLen = strlen(m_poData->m_sStrPtr); return(*this); } /*E*/ StringC operator+(const StringC &arg_roFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator + * * Klasse: StringC * * Funktion: Aneinanderhängen zweier StringC-Object zu einem StringC-Object * * Zugriff: public * * Eingabe-Parameter: 2 * zwei Referenzen von Objekten der Klasse StringC * * Ausgabe-Parameter: Ein neues StringC-Objekt * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: 8 * ObjectXC::ObjectXC() * StringC() Direkt-Set-Konstruktor [private] * StringC() Einfacher Konstruktor * isEmpty() * string.h/strcpy() * string.h/strcat() * string.h/strlen() * getStringTableEntry() * * Version: 1.5 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Juni 1997 * * Letzte Änderungen/Neuerungen: * 9. November 1996: Methode implementiert * 11. November 1996: Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests * wenn die Strings in den neuen kopiert werden. * 12. Januar 1997: Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt * eine Referenz darauf zurück. * 6. Februar 1997: Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern * returniert ein komplett neues Objekt, weil vorher das mit new erzeugte * Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der * Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem * Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein * Temporäres Objekt zu vermeiden. * Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel) * 11-12. Juni 1997: Methode aus dem Berlin-Projekt übernommen und angepasst * 1 Bug wurde beseitigt (Semikolon in if-Zeile) * 25. Juni 1997: GetLength() wird nicht mehr verwendet. Die Länge * der Teilstrings wird direkt ausgelesen. * *************************************************************************/ /*E*/ { ASSERT(arg_roSecond.checkInstance()) // Compute the buffersize required to hold both strings ULONG ulNewLen=arg_roFirst.getLength() + arg_roSecond.getLength(); // a size of zero results in a zero-object if (!ulNewLen) { return(StringC()); } // if // make the string divideable by 8 ULONG ulNewBufLen=(ulNewLen+8) & (~0x7); // allocate the new buffer char *sNewPtr; if (!(sNewPtr = new char [ulNewBufLen])) { // if something went wrong (e.g. no memory) throw STRINGC_XC; } //if // fill the just allocated buffer if (!arg_roFirst.isEmpty()) { strcpy(sNewPtr, arg_roFirst.m_poData->m_sStrPtr); } //if if (!arg_roSecond.isEmpty()) { strcat(sNewPtr, arg_roSecond.m_poData->m_sStrPtr); } //if // use a special direct-set-constructor to reduce the temporary objects return(StringC(ulNewLen,ulNewBufLen-1, sNewPtr)); } /*E*/ StringC operator+(const StringC &arg_roFirst, char arg_cSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator + * * Klasse: StringC * * Funktion: Aneinanderhängen eines StringC-Objects mit einem char * * Zugriff: public * * Eingabe-Parameter: 2 * Eine Referenz eines Objekten der Klasse StringC * ein char * * Ausgabe-Parameter: Ein neues StringC-Objekt * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: 6 * ObjectXC() * StringC() Direkt-Set-Konstruktor [private] * StringC() Einfacher Konstruktor * isEmpty() * string.h/strcpy() * getStringTableEntry() * * Version: 1.5 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Juni 1997 * * Letzte Änderungen/Neuerungen: * 9. November 1996: Methode implementiert * 11. November 1996: Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests * wenn die Strings in den neuen kopiert werden. * 12. Januar 1997: Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt * eine Referenz darauf zurück. * 6. Februar 1997: Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern * returniert ein komplett neues Objekt, weil vorher das mit new erzeugte * Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der * Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem * Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein * Temporäres Objekt zu vermeiden. * Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel) * 11-12. Juni 1997: Methode aus dem Berlin-Projekt übernommen und angepasst * 1 Bug wurde beseitigt (Semikolon in if-Zeile) * 25. Juni 1997: GetLength() wird nicht mehr verwendet. Die Länge * der Teilstrings wird direkt ausgelesen. * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) // Compute the buffersize required to hold both strings ULONG ulNewLen=arg_roFirst.getLength()+sizeof(char); // a size of zero results in a zero-object if (!ulNewLen) { return(StringC()); } // if (!ulNewLen) // make the string divideable by 8 ULONG ulNewBufLen=(ulNewLen+8) & (~0x7); // allocate the new buffer char *sNewPtr; if (!(sNewPtr = new char [ulNewBufLen])) { // if something went wrong (no mem) throw STRINGC_XC; } // if (m_sStrPtr = new char [(ULONG) arg_ulSize]) // fill the just allocated buffer if (!arg_roFirst.isEmpty()) { strcpy(sNewPtr, arg_roFirst.m_poData->m_sStrPtr); } //if (!arg_roFirst.isEmpty()) sNewPtr[ulNewLen-sizeof(char)]=arg_cSecond; sNewPtr[ulNewLen]=0; return(StringC(ulNewLen,ulNewBufLen-sizeof(char), sNewPtr)); } /*E*/ StringC operator+(char arg_cFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator + * * Klasse: StringC * * Funktion: Aneinanderhängen eines chars mit einem StringC-Object * * Zugriff: public * * Eingabe-Parameter: 2 * ein char * Eine Referenz eines Objekten der Klasse StringC * * Ausgabe-Parameter: Ein neues StringC-Objekt * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: 6 * ObjectXC() * StringC() Direkt-Set-Konstruktor [private] * StringC() Einfacher Konstruktor * isEmpty() * string.h/strcat() * getStringTableEntry() * * Version: 1.5 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Juni 1997 * * Letzte Änderungen/Neuerungen: * 9. November 1996: Methode implementiert * 11. November 1996: Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests * wenn die Strings in den neuen kopiert werden. * 12. Januar 1997: Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt * eine Referenz darauf zurück. * 6. Februar 1997: Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern * returniert ein komplett neues Objekt, weil vorher das mit new erzeugte * Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der * Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem * Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein * Temporäres Objekt zu vermeiden. * Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel) * 11-12. Juni 1997: Methode aus dem Berlin-Projekt übernommen und angepasst * 1 Bug wurde beseitigt (Semikolon in if-Zeile) * 25. Juni 1997: GetLength() wird nicht mehr verwendet. Die Länge * der Teilstrings wird direkt ausgelesen. * Es wurde außerdem der Fall abgefangen, wenn der * char-Parameter==NULL ist * *************************************************************************/ /*E*/ { ASSERT(arg_roSecond.checkInstance()) // Compute the buffersize required to hold both strings ULONG ulNewLen=arg_roSecond.getLength()+sizeof(char); // a size of zero results in a zero-object if (!ulNewLen) { return(StringC()); } // if (!ulNewLen) // if the char is zero, just create a copy of the StringC-object if (!arg_cFirst) { return(StringC(arg_roSecond)); } // make the string divideable by 8 ULONG ulNewBufLen=(ulNewLen+8) & (~0x7); // allocate the new buffer char *sNewPtr; if (!(sNewPtr = new char [ulNewBufLen])) { // if something went wrong (no mem) throw STRINGC_XC; } // if (m_sStrPtr = new char [(ULONG) arg_ulSize]) sNewPtr[0]=arg_cFirst; sNewPtr[sizeof(char)]=0; // fill the just allocated buffer if (!arg_roSecond.isEmpty()) { strcat(sNewPtr, arg_roSecond.m_poData->m_sStrPtr); } //if (!arg_roFirst.isEmpty()) return(StringC(ulNewLen,ulNewBufLen-sizeof(char), sNewPtr)); } /*E*/ StringC operator+(const StringC &arg_roFirst, const char *arg_sSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator + * * Klasse: StringC * * Funktion: Aneinanderhängen eines StringC-Object mit einer Zeichenkette * * Zugriff: public * * Eingabe-Parameter: 2 * Eine Referenz eines Objekten der Klasse StringC * eine Zeichenkette * * Ausgabe-Parameter: Ein neues StringC-Objekt * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: 7 * ObjectXC() * StringC() Direkt-Set-Konstruktor [private] * StringC() Einfacher Konstruktor * isEmpty() * string.h/strcpy() * string.h/strcat() * getStringTableEntry() * * Version: 1.5 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Juni 1997 * * Letzte Änderungen/Neuerungen: * 9. November 1996: Methode implementiert * 11. November 1996: Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests * wenn die Strings in den neuen kopiert werden. * 12. Januar 1997: Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt * eine Referenz darauf zurück. * 6. Februar 1997: Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern * returniert ein komplett neues Objekt, weil vorher das mit new erzeugte * Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der * Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem * Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein * Temporäres Objekt zu vermeiden. * Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel) * 11-12. Juni 1997: Methode aus dem Berlin-Projekt übernommen und angepasst * 1 Bug wurde beseitigt (Semikolon in if-Zeile) * 25. Juni 1997: GetLength() wird nicht mehr verwendet. Die Länge * der Teilstrings wird direkt ausgelesen. * Die Methode wurde optimiert und weiter abgesichert * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) ASSERT(arg_sSecond) ULONG ulNewLen=0; // only count the length of the char-pointer if one is there if(arg_sSecond) { ulNewLen = strlen(arg_sSecond); } // if(arg_sSecond) // if the char-pointer is zero or has no length if (!ulNewLen) { // just return a copy of the StringC-object return(StringC(arg_roFirst)); } // if (!ulNewLen) // Compute the buffersize required to hold both strings ulNewLen += arg_roFirst.getLength(); // make the string divideable by 8 ULONG ulNewBufLen=(ulNewLen+8) & (~0x7); // allocate the new buffer char *sNewPtr = new char [ulNewBufLen]; if (!sNewPtr) { // if something went wrong (e.g. no memory) throw STRINGC_XC; } // if (m_sStrPtr = new char [(ULONG) arg_ulSize]) // fill the just allocated buffer if (!arg_roFirst.isEmpty()) { strcpy(sNewPtr, arg_roFirst.m_poData->m_sStrPtr); } // if (!arg_roFirst.isEmpty()) // concatenate the two strings strcat(sNewPtr, arg_sSecond); return(StringC(ulNewLen,ulNewBufLen-1, sNewPtr)); } /*E*/ StringC operator+(const char *arg_sFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator + * * Klasse: StringC * * Funktion: Aneinanderhängen einer Zeichenkette mit einem StringC-Object * * Zugriff: public * * Eingabe-Parameter: 2 * eine Zeichenkette * Eine Referenz eines Objekten der Klasse StringC * * Ausgabe-Parameter: Ein neues StringC-Objekt * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: * * Benutzte Methoden: 7 * ObjectXC() * StringC() Direkt-Set-Konstruktor [private] * StringC() Einfacher Konstruktor * isEmpty() * string.h/strcpy() * string.h/strcat() * getStringTableEntry() * * Version: 1.5 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 25. Juni 1997 * * Letzte Änderungen/Neuerungen: * 9. November 1996: Methode implementiert * 11. November 1996: Sicherheit erhöht, durch Verwendung von getLen() und Existenz-Tests * wenn die Strings in den neuen kopiert werden. * 12. Januar 1997: Die Methode gibt nun einen Zeiger auf das neue Objekt, anstatt * eine Referenz darauf zurück. * 6. Februar 1997: Die Methode gibt keinen Zeiger mehr auf das neue Objekt zurück sondern * returniert ein komplett neues Objekt, weil vorher das mit new erzeugte * Return-Objekt nicht wieder gelöscht wurde. Für die Rückgabe wird der * Direktset-Konstruktor verwendet, so daß nur 1 temporäres Objekt auf dem * Stack erzeugt werden muß. Es scheint unmöglich für einen + operator ein * Temporäres Objekt zu vermeiden. * Desweiteren wurde die Länge jetzt richtig bemessen (vorher 1 Byte zuviel) * 11-12. Juni 1997: Methode aus dem Berlin-Projekt übernommen und angepasst * 1 Bug wurde beseitigt (Semikolon in if-Zeile) * 25. Juni 1997: GetLength() wird nicht mehr verwendet. Die Länge * der Teilstrings wird direkt ausgelesen. * Die Methode wurde darüberhinaus optimiert und * weiter abgesichert. * *************************************************************************/ /*E*/ { ASSERT(arg_roSecond.checkInstance()) ASSERT(arg_sFirst) ULONG ulNewLen=0; // only count the length of the char-pointer if one is there if (arg_sFirst) { ulNewLen = strlen(arg_sFirst); } // if (arg_sFirst) // if the char-pointer is zero or the string has no length if (!ulNewLen) { // just return a copy of the StringC-object return(StringC(arg_roSecond)); } // if (!ulNewLen) // Compute the buffersize required to hold both strings ulNewLen += arg_roSecond.getLength(); // make the string divideable by 8 ULONG ulNewBufLen=(ulNewLen+8) & (~0x7); // allocate the new buffer char *sNewPtr = new char [ulNewBufLen]; if (!sNewPtr) { // if something went wrong (no mem) throw STRINGC_XC; } // if (m_sStrPtr = new char [(ULONG) arg_ulSize]) // put a copy of the char-pointer-string into the new buffer strcpy(sNewPtr, arg_sFirst); // fill the just allocated buffer if (!arg_roSecond.isEmpty()) { strcat(sNewPtr, arg_roSecond.m_poData->m_sStrPtr); } //if (!arg_roFirst.isEmpty()) return(StringC(ulNewLen,ulNewBufLen-1, sNewPtr)); } /*E*/ BOOL operator==(const StringC &arg_roFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator == * * Klasse: StringC * * Funktion: Vergleichsoperator * * Zugriff: public * * Eingabe-Parameter: 2 * 2 Referenzen auf ein StringC-Objekte * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) ASSERT(arg_roSecond.checkInstance()) return(!strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer())); } /*E*/ BOOL operator==(const StringC &arg_roFirst, const char *arg_sSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator == * * Klasse: StringC * * Funktion: Vergleichsoperator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 Referenz auf ein StringC-Objekt * 1 char-pointer * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) if (!arg_sSecond) { return(FALSE); } // if (!arg_sSecond) return(!strcmp(arg_roFirst.getBuffer(),arg_sSecond)); } /*E*/ BOOL operator==(const char *arg_sFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator == * * Klasse: StringC * * Funktion: Vergleichsoperator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 char pointer * 1 Referenz auf ein StringC-Objekt * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roSecond.checkInstance()) if (!arg_sFirst) { return(FALSE); } // if (!arg_sFirst) return(!strcmp(arg_sFirst,arg_roSecond.getBuffer())); } /*E*/ BOOL operator!=(const StringC &arg_roFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator != * * Klasse: StringC * * Funktion: Ungleichheits-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 2 Referenzen auf ein StringC-Objekte * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) ASSERT(arg_roSecond.checkInstance()) return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer())); } /*E*/ BOOL operator!=(const StringC &arg_roFirst, const char *arg_sSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator 2= * * Klasse: StringC * * Funktion: Ungleichheits-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 Referenz auf ein StringC-Objekt * 1 char-pointer * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) if (!arg_sSecond) { return(TRUE); } // if (!arg_sSecond) return(strcmp(arg_roFirst.getBuffer(),arg_sSecond)); } /*E*/ BOOL operator!=(const char *arg_sFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator != * * Klasse: StringC * * Funktion: Ungleichheits-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 char pointer * 1 Referenz auf ein StringC-Objekt * * Ausgabe-Parameter: TRUE wenn s1!=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roSecond.checkInstance()) if (!arg_sFirst) { return(TRUE); } // if (!arg_sFirst) return(strcmp(arg_sFirst,arg_roSecond.getBuffer())); } /*E*/ BOOL operator<(const StringC &arg_roFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator < * * Klasse: StringC * * Funktion: Kleiner-als-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 2 Referenzen auf ein StringC-Objekte * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) ASSERT(arg_roSecond.checkInstance()) return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()) < 0); } /*E*/ BOOL operator<(const StringC &arg_roFirst, const char *arg_sSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator < * * Klasse: StringC * * Funktion: Kleiner-als-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 Referenz auf ein StringC-Objekt * 1 char-pointer * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) if (!arg_sSecond) { return(FALSE); } // if (!arg_sSecond) return(strcmp(arg_roFirst.getBuffer(),arg_sSecond) < 0); } /*E*/ BOOL operator<(const char *arg_sFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator < * * Klasse: StringC * * Funktion: Kleiner-als-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 char pointer * 1 Referenz auf ein StringC-Objekt * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roSecond.checkInstance()) if (!arg_sFirst) { return(TRUE); } // if (!arg_sFirst) return(strcmp(arg_sFirst,arg_roSecond.getBuffer()) < 0); } /*E*/ BOOL operator>(const StringC &arg_roFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator > * * Klasse: StringC * * Funktion: Größer-als-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 2 Referenzen auf ein StringC-Objekte * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) ASSERT(arg_roSecond.checkInstance()) return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()) > 0); } /*E*/ BOOL operator>(const StringC &arg_roFirst, const char *arg_sSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator > * * Klasse: StringC * * Funktion: Größer-als-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 Referenz auf ein StringC-Objekt * 1 char-pointer * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) if (!arg_sSecond) { return(TRUE); } // if (!arg_sSecond) return(strcmp(arg_roFirst.getBuffer(),arg_sSecond) > 0); } /*E*/ BOOL operator>(const char *arg_sFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator > * * Klasse: StringC * * Funktion: Größer-als-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 char pointer * 1 Referenz auf ein StringC-Objekt * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roSecond.checkInstance()) if (!arg_sFirst) { return(FALSE); } // if (!arg_sFirst) return(strcmp(arg_sFirst,arg_roSecond.getBuffer()) > 0); } /*E*/ BOOL operator<=(const StringC &arg_roFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator <= * * Klasse: StringC * * Funktion: kleiner-gleich-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 2 Referenzen auf ein StringC-Objekte * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) ASSERT(arg_roSecond.checkInstance()) return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()) <= 0); } /*E*/ BOOL operator<=(const StringC &arg_roFirst, const char *arg_sSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator <= * * Klasse: StringC * * Funktion: kleiner-gleich-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 Referenz auf ein StringC-Objekt * 1 char-pointer * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) if (!arg_sSecond) { return(FALSE); } // if (!arg_sSecond) return(strcmp(arg_roFirst.getBuffer(),arg_sSecond) <= 0); } /*E*/ BOOL operator<=(const char *arg_sFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator <= * * Klasse: StringC * * Funktion: kleiner-gleich-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 char pointer * 1 Referenz auf ein StringC-Objekt * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roSecond.checkInstance()) if (!arg_sFirst) { return(TRUE); } // if (!arg_sFirst) return(strcmp(arg_sFirst,arg_roSecond.getBuffer()) <= 0); } /*E*/ BOOL operator>=(const StringC &arg_roFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator >= * * Klasse: StringC * * Funktion: Größer-gleich-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 2 Referenzen auf ein StringC-Objekte * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) ASSERT(arg_roSecond.checkInstance()) return(strcmp(arg_roFirst.getBuffer(), arg_roSecond.getBuffer()) >= 0); } /*E*/ BOOL operator>=(const StringC &arg_roFirst, const char *arg_sSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator >= * * Klasse: StringC * * Funktion: Größer-gleich-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 Referenz auf ein StringC-Objekt * 1 char-pointer * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roFirst.checkInstance()) if (!arg_sSecond) { return(TRUE); } // if (!arg_sSecond) return(strcmp(arg_roFirst.getBuffer(),arg_sSecond) >= 0); } /*E*/ BOOL operator>=(const char *arg_sFirst, const StringC &arg_roSecond) /*S*/ /*S*/ /* Methoden-Rahmen */ /************************************************************************* * Name der Methode: operator >= * * Klasse: StringC * * Funktion: Größer-gleich-operator * * Zugriff: public * * Eingabe-Parameter: 2 * 1 char pointer * 1 Referenz auf ein StringC-Objekt * * Ausgabe-Parameter: TRUE wenn s1=s2; sonst FALSE * * Aufgerufen von: * * Verwendung folgender globaler Variablen/Strukturen: keine * * Benutzte Methoden: 2 * string.h/strcmp() * StringC::getBuffer() * * Version: 1.3 * * Autor: Christian Taulien of Strange Intelligence * * Datum: 12. Juni 1997 * * Letzte Änderungen/Neuerungen: * 12. November 1996: Methode impelmentiert * 29. November 1996: Exeptionhandling eingebaut * 5. Dezember 1996: Exceptionhandling wieder ausgebaut, weil es zu ungewollten Exceptions käme * wenn z.B. NodeC-Objekte nach Namen sortiert werden sollten, von denen * einige auch NULL-Pointer haben. * s1 / s1.str | s2 / s2.str | Erg. beim Vergleich auf s1==s2 * -------------+----------------+---------------------------------- * 0 | 0 | TRUE * 0 | s2.str="..." | FALSE * s1.str="..." | 0 | FALSE * s1.str="..." | s2.str="..." | Abhängig vom Inhalt beider str * 12. Juni 1997: Methode aus dem Berlin-Project übernommen * Aufgrund der StringC-Implementierung kann es dort * keine NULL-Pointer geben * *************************************************************************/ /*E*/ { ASSERT(arg_roSecond.checkInstance()) if (!arg_sFirst) { return(FALSE); } // if (!arg_sFirst) return(strcmp(arg_sFirst,arg_roSecond.getBuffer()) >= 0); } /*E*/ //#ifdef si_debug_x //#undef si_debug_x //#define si_debug //#endif