mirror of https://github.com/gabime/spdlog.git
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1784 lines
48 KiB
C++
1784 lines
48 KiB
C++
#ifndef ____INC___STRT_H____CNI_____
|
|
#define ____INC___STRT_H____CNI_____
|
|
|
|
/*
|
|
###############################################################################
|
|
Interface StrT
|
|
###############################################################################
|
|
|
|
*******************************************************************************
|
|
STR* c_ptr (void) // not necessarily NUL terminated!
|
|
Liefert einen Zeiger auf den Puffer, ohne die Terminierung zu beachten
|
|
*******************************************************************************
|
|
STR const* c_str (void) // return char*
|
|
Liefert terminierten String
|
|
*******************************************************************************
|
|
long length (void)
|
|
*******************************************************************************
|
|
|
|
*******************************************************************************
|
|
long Len (void)
|
|
*******************************************************************************
|
|
|
|
//*****************************************************************************
|
|
long Size (void) // Größe des belegten Puffers
|
|
*******************************************************************************
|
|
|
|
*******************************************************************************
|
|
void ReserveBuffer(long ReqSize) // Puffergröße direkt modifizieren
|
|
*******************************************************************************
|
|
|
|
|
|
|
|
|
|
//*****************************************************************************
|
|
// Constructor's of different kind
|
|
//*****************************************************************************
|
|
StrT(void)
|
|
StrT(STR* s)
|
|
StrT(STR const* s)
|
|
StrT(STR const * s, long len)
|
|
StrT(STR c)
|
|
StrT(unsigned long val)
|
|
StrT(int val)
|
|
StrT(StrT & s)
|
|
|
|
|
|
*******************************************************************************
|
|
StrT& Set(StrT& s) // Überträgt Inhalt von anerem String
|
|
*******************************************************************************
|
|
StrT & Clear(void) // Löscht String
|
|
*******************************************************************************
|
|
// Exported, but for use with very good care!!!
|
|
void __SetLen(long len) // !!! Vorsicht, direkte Längenmanipulation!!!!
|
|
*******************************************************************************
|
|
|
|
|
|
*******************************************************************************
|
|
// "=" - Operators
|
|
*******************************************************************************
|
|
StrT & operator= (StrT const & s)
|
|
StrT & operator= (STR const * s)
|
|
StrT & operator= (STR c)
|
|
StrT & operator= (long n)
|
|
StrT & operator= (unsigned long n)
|
|
|
|
*******************************************************************************
|
|
// Additionsoperatoren
|
|
*******************************************************************************
|
|
StrT& operator+=(const StrT& s)
|
|
|
|
*******************************************************************************
|
|
// String abschneiden
|
|
*******************************************************************************
|
|
long TruncateLeft(long nElem)
|
|
long TruncateRight(long nElem)
|
|
|
|
*******************************************************************************
|
|
// copy the data into a external buffer
|
|
*******************************************************************************
|
|
int Copy(STR * dst, long maxlen)
|
|
|
|
//*****************************************************************************
|
|
// Compare two strings
|
|
//*****************************************************************************
|
|
int Compare (StrT & s)
|
|
int Compare (STR const * s)
|
|
|
|
//*****************************************************************************
|
|
// Offset eines Substrings im String finden
|
|
//*****************************************************************************
|
|
long StrStr (StrT & s)
|
|
long StrStr (STR const * s)
|
|
|
|
//*****************************************************************************
|
|
// Zeichen / String einfügen an Position
|
|
//*****************************************************************************
|
|
long InsertElem (long pos, STR c)
|
|
long Insert (long pos, STR const * s, long len = -1)
|
|
|
|
//*****************************************************************************
|
|
// Stück aus String entfernen
|
|
//*****************************************************************************
|
|
long Remove (long pos, long len)
|
|
|
|
//*****************************************************************************
|
|
// Ersetzen eines Teilstrings
|
|
//*****************************************************************************
|
|
long Replace (long pos, StrT & s, long clen =-1)
|
|
long Replace (long pos, STR c, long clen =-1)
|
|
long Replace (long pos, STR const * s, long clen = -1, long len = -1)
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT & Left (long len, STR padch)
|
|
StrT & Right (long len, STR padch)
|
|
StrT & Mid (long pos, long len, STR padch)
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT Substr(long start, long len)
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
int _concat (StrT & s)
|
|
int _concat (STR ch)
|
|
int _concat (const STR * s, long len = -1)
|
|
|
|
//*****************************************************************************
|
|
// Vergleichs-Operatoren
|
|
//*****************************************************************************
|
|
bool operator== (StrT & s)
|
|
bool operator== (STR * s)
|
|
bool operator!= (StrT & s)
|
|
bool operator!= (STR * s)
|
|
bool operator< (StrT & s)
|
|
bool operator< (STR * s)
|
|
bool operator<= (StrT & s)
|
|
bool operator<= (STR * s)
|
|
bool operator> (StrT & s)
|
|
bool operator> (STR * s)
|
|
bool operator>= (StrT & s)
|
|
bool operator>= (STR * s)
|
|
|
|
|
|
//*************************************************************************
|
|
// Konvertierungsoperatoren char + wchar
|
|
//*************************************************************************
|
|
StrT & operator<< (const char* s)
|
|
StrT & operator<< (const wchar_t* s)
|
|
StrT & operator<< (StrT & s)
|
|
StrT & operator<< (int val)
|
|
StrT& operator<< (unsigned int val)
|
|
StrT & operator<< (short val)
|
|
StrT & operator<< (unsigned short val)
|
|
StrT& operator<< (long val)
|
|
StrT & operator<< (unsigned long val)
|
|
StrT& operator<< (C_StreamIoManipulator& manip)
|
|
|
|
STR const & operator[] (long pos) const
|
|
STR & operator[] (long pos)
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
int _compare(StrT s)
|
|
int __compare(StrT const s) const
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long _strstr(StrT s)
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long RemoveCh (STR const * clist)
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long CountCh (STR const * clist)
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT& toUpper(void)
|
|
StrT& toLower(void)
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT& Trim(unsigned long mode, STR c)
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
unsigned long CreateChecksum(void)
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
void ltos(const long n, int radix = -1)
|
|
void ultos(const unsigned long n, int radix = -1)
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long& Value(long& n, int radix = -1)
|
|
unsigned long& Value(unsigned long& n, int radix = -1)
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
int GetNumberConvertBase(void)
|
|
void SetNumberConvertBase(int base)
|
|
|
|
//*****************************************************************************
|
|
// Wenn CaseSens TRUE ist, werden Vergleiche case-sensitiv durchgeführt.
|
|
//*****************************************************************************
|
|
void SetCompareCase(bool CaseSens)
|
|
|
|
//*****************************************************************************
|
|
// Index: liefert den Offset im String nach AWK-Manier
|
|
//*****************************************************************************
|
|
long Index(const STR* strCharset)
|
|
long IndexBin(long start,STR* chr,long nPat)
|
|
|
|
//*****************************************************************************
|
|
// Erstes Vorkommen von str finden. Die Variable pos wird initialisiert und
|
|
// wird bei nächsten Such-Durchläuifen werwendet.
|
|
//*****************************************************************************
|
|
long& FindFirst(const STR* str,long& pos)
|
|
long& FindFirst(const StrT& str,long& pos)
|
|
|
|
//*****************************************************************************
|
|
// Find the next occurrence of substring 'findStr' in the string
|
|
// pos ist die von FindFirst initialisierte Variable zum Zwischenspeichern
|
|
// des aktuellen Ergebnisses.
|
|
//*****************************************************************************
|
|
long& FindNext(const STR* str,long& pos)
|
|
long& FindNext( StrT& str,long& pos)
|
|
|
|
*******************************************************************************
|
|
*******************************************************************************
|
|
|
|
###############################################################################
|
|
Interface StrTArray
|
|
###############################################################################
|
|
typedef StrTArray<StrW,StrWLlEntry, wchar_t> StrWArray;
|
|
typedef StrTArray<StrC,StrCLlEntry, char> StrCArray;
|
|
*******************************************************************************
|
|
STRINGOBJ& push_back(STRINGOBJ& ob) // String einfügen
|
|
bool GetString(STRINGOBJ& str,unsigned long idx) // Auf String per Index zugr.
|
|
STRINGOBJ* GetString(unsigned long idx)
|
|
void Clear(void) // Array leermachen
|
|
*******************************************************************************
|
|
// StrX in das Array aufsplitten, jedes gefundene Trennzeichen (charset)
|
|
// erzeugt einen neuen Arrayeintrag.
|
|
unsigned long Split(STRINGOBJ& str,STR* charset,long nChr)
|
|
*******************************************************************************
|
|
*******************************************************************************
|
|
|
|
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <wchar.h>
|
|
//#include "Snip_str.h"
|
|
#include "V_Strx_Iomanip.h"
|
|
#include "LlistT.h"
|
|
#include "V_MemoryAllocator.h"
|
|
#include "StrBBuffer.h"
|
|
#include "StrTBuffer.h"
|
|
|
|
# define STDLEN 32
|
|
//#define BLOCKSIZE 64
|
|
|
|
// Define to 0 for much smaller class
|
|
#define VIRTUAL_DESTRUCTOR 0
|
|
#if VIRTUAL_DESTRUCTOR
|
|
#define __VIRTUAL virtual
|
|
#else
|
|
#define __VIRTUAL
|
|
#endif
|
|
|
|
char *stristr(const char *String,const char *Pattern);
|
|
wchar_t *wcsistr(const wchar_t *String, const wchar_t *Pattern);
|
|
|
|
/*
|
|
enum
|
|
{
|
|
LEFT = 0,
|
|
CENTER = 1,
|
|
RIGHT = 2,
|
|
NOCLIP = 0,
|
|
NOTRIM = 0,
|
|
CLIP = 1,
|
|
TRIM = 2,
|
|
WHITESPACE = 0
|
|
}STRING_T_MODES;
|
|
*/
|
|
|
|
const unsigned int STRTTMODE_LEFT = 0;
|
|
const unsigned int STRTTMODE_CENTER = 1;
|
|
const unsigned int STRTTMODE_RIGHT = 2;
|
|
|
|
const unsigned int STRTTMODE_NOCLIP = 0;
|
|
const unsigned int STRTTMODE_NOTRIM = 0;
|
|
const unsigned int STRTTMODE_CLIP = 1;
|
|
const unsigned int STRTTMODE_TRIM = 2;
|
|
|
|
const unsigned int STRTTMODE_WHITESPACE = 0;
|
|
|
|
// Die ersten zwei Bits repräsentieren den Zahlen-Konvertierungs-
|
|
// Modus. Macht natürlich nur einer der drei Sinn.
|
|
const unsigned int STRTTFLAG_DEC = 0x00;
|
|
const unsigned int STRTTFLAG_HEX = 0x01;
|
|
const unsigned int STRTTFLAG_OCT = 0x02;
|
|
const unsigned int STRTTFLAG_CASE = 0x04;
|
|
|
|
const unsigned int STRTT_DEFAULT_FLAG = STRTTFLAG_DEC;
|
|
|
|
// Globale Funtionsprototypen
|
|
char* StrT_WideCharToCharString(const wchar_t* txt);
|
|
wchar_t* StrT_CharToWideString(const char* txt);
|
|
|
|
|
|
template<class STR>
|
|
class WIDECHAR_SUPPORT
|
|
{
|
|
public:
|
|
// Ersatz-Funktionen zum Mapping der unterschiedlichen OS-Funktionen
|
|
// gemäß dem Template-Typ (wchar/char)
|
|
size_t __strlen(const wchar_t* str){return wcslen(str);};
|
|
STR* __ultoa(unsigned long val,wchar_t* str,int radix){return _ultow(val,str,radix);};
|
|
STR* __itoa(int val,wchar_t* str,int radix){return _itow(val,str,radix);};
|
|
int __stricmp(const wchar_t* s1,const wchar_t* s2){return _wcsicmp(s1,s2);};
|
|
int __strcmp(const wchar_t* s1,const wchar_t* s2){return wcscmp(s1,s2);};
|
|
STR* __strstr(const wchar_t* str,const wchar_t* strCharset){return (STR*) wcsstr(str,strCharset);};
|
|
STR* __stristr(const wchar_t* str,const wchar_t* strCharset){return (STR*) wcsistr(str,strCharset);};
|
|
STR* __strchr(const wchar_t* str,int c){return wcschr(str,c);};
|
|
STR* __strupr(wchar_t* str){return _wcsupr(str);};
|
|
STR* __strlwr(wchar_t* str){return _wcslwr(str);};
|
|
long __strtol(const wchar_t* str,wchar_t** endptr,int base){return wcstol(str,endptr,base);};
|
|
unsigned long __strtoul(const wchar_t* str,wchar_t** endptr,int base){return wcstoul(str,endptr,base);};
|
|
size_t __strcspn(const wchar_t* str,const wchar_t* strCharSet){return wcscspn(str,strCharSet);};
|
|
|
|
// Funktionen zur Konvertierung von Standardstrings in STR-Ketten
|
|
// Nach Gebrauch ist die entsprechende Free-Funktion aufzurufen. Auf keinen
|
|
// Fall selbst freigeben!
|
|
STR* __csconvert(const char* str){return StrT_CharToWideString(str);};
|
|
void __csconvert_free(STR* data){if(data) delete data;};
|
|
STR* __wcsconvert(const wchar_t* str){return (STR*)str;};
|
|
void __wcsconvert_free(STR* data){};
|
|
|
|
// Funktion für Checksummen-Wert eines Elementes (bei char und WCHAR einfach der
|
|
// Zeichenwert)
|
|
unsigned long __get_element_checksum_value(wchar_t ch){return (unsigned long) ch;};
|
|
|
|
// Ersatz-Funktionen zur Puffermanipulation
|
|
STR* __block_move(wchar_t* dest,const wchar_t* src, size_t count){return (STR*)memmove(dest,src,count*sizeof(wchar_t));};
|
|
STR* __block_copy(wchar_t* dest,const wchar_t* src, size_t count){return (STR*)memcpy(dest,src,count*sizeof(wchar_t));};
|
|
STR* __block_set(wchar_t* dest,wchar_t val,size_t count)
|
|
{
|
|
for(size_t i=0;i<count;i++)
|
|
dest[i] = val;
|
|
return (STR*) dest;
|
|
};
|
|
|
|
// Konstanten wie z.B. für NULL-Terminierung
|
|
STR __std_terminating_element(void){return L'\0';};
|
|
STR __std_whitespace_element(void){return L' ';};
|
|
STR* __std_eol_element(void){return L"\r\n";};
|
|
|
|
};
|
|
|
|
|
|
template<class STR>
|
|
class CHAR_SUPPORT
|
|
{
|
|
public:
|
|
// Ersatz-Funktionen zum Mapping der unterschiedlichen OS-Funktionen
|
|
// gemäß dem Template-Typ (wchar/char)
|
|
size_t __strlen(const char* str){return strlen(str);};
|
|
STR* __ultoa(unsigned long val,char* str,int radix){return _ultoa(val,str,radix);};
|
|
STR* __itoa(int val,char* str,int radix){return _itoa(val,str,radix);};
|
|
int __stricmp(const char* s1,const char* s2){return _stricmp(s1,s2);};
|
|
int __strcmp(const char* s1,const char* s2){return strcmp(s1,s2);};
|
|
STR* __strstr(const char* str,const char* strCharset){return (char*)strstr(str,strCharset);};
|
|
STR* __stristr(const char* str,const char* strCharset){return stristr(str,strCharset);};
|
|
STR* __strchr(const char* str,int c){return strchr(str,c);};
|
|
STR* __strupr(char* str){return _strupr(str);};
|
|
STR* __strlwr(char* str){return _strlwr(str);};
|
|
long __strtol(const char* str,char** endptr,int base){return strtol(str,endptr,base);};
|
|
unsigned long __strtoul(const char* str,char** endptr,int base){return strtoul(str,endptr,base);};
|
|
size_t __strcspn(const char* str,const char* strCharSet){return strcspn(str,strCharSet);};
|
|
|
|
// Funktionen zur Konvertierung von Standardstrings in STR-Ketten
|
|
// Nach Gebrauch ist die entsprechende Free-Funktion aufzurufen. Auf keinen
|
|
// Fall selbst freigeben!
|
|
STR* __csconvert(const char* str){return (STR*)str;};
|
|
void __csconvert_free(STR* data){};
|
|
STR* __wcsconvert(const wchar_t* str){return StrT_WideCharToCharString(str);};
|
|
void __wcsconvert_free(STR* data){if(data) delete data;};
|
|
|
|
|
|
// Funktion für Checksummen-Wert eines Elementes (bei char und WCHAR einfach der
|
|
// Zeichenwert)
|
|
unsigned long __get_element_checksum_value(char ch){return (unsigned long) ch;};
|
|
|
|
|
|
// Auch die Memory-Operationen sollten anpassbar sein (z.B. tut memset nur bei
|
|
// char's veernünftig)
|
|
STR* __block_move(char* dest,const char* src, size_t count){return (STR*)memmove(dest,src,count);};
|
|
STR* __block_copy(char* dest,const char* src, size_t count){return (STR*)memcpy(dest,src,count*sizeof(char));};
|
|
STR* __block_set(char* dest,int val,size_t count){return (STR*)memset(dest,val,count);};
|
|
|
|
|
|
STR __std_terminating_element(void){return '\0';};
|
|
STR __std_whitespace_element(void){return ' ';};
|
|
STR* __std_eol_element(void){return "\r\n";};
|
|
|
|
};
|
|
|
|
|
|
|
|
#pragma pack(push, 1)
|
|
template<typename STR,
|
|
typename SUPPORT,
|
|
typename ALLOC>
|
|
class StrT : public StrBBuffer<STR>
|
|
{
|
|
private:
|
|
// StrTBuffer<STR, ALLOC> m_Str;
|
|
// StrBBuffer<STR> m_Str;
|
|
SUPPORT SupportFn;
|
|
unsigned long m_Flag;
|
|
|
|
void InitPrivateData(void)
|
|
{
|
|
m_Flag = STRTT_DEFAULT_FLAG;
|
|
}
|
|
|
|
|
|
// Private Member
|
|
//*****************************************************************************
|
|
// private initialisation functions
|
|
//*****************************************************************************
|
|
void _strinit (STR const * s, long len, /*long siz,*/ unsigned long flgs)
|
|
{
|
|
m_Flag = flgs;
|
|
_strinit(s,len);
|
|
}
|
|
|
|
void _strinit (STR const * s, long len /*long siz, unsigned long flgs*/)
|
|
{
|
|
if (len < 0)
|
|
len = (long) ((s) ? SupportFn.__strlen (s) : 0);
|
|
if(s==NULL)
|
|
StrBBuffer<STR>::clear();
|
|
else
|
|
StrBBuffer<STR>::Set((STR*)s,len);
|
|
|
|
};
|
|
|
|
|
|
|
|
void _strinit_n (unsigned long val, int radix)
|
|
{
|
|
if(radix==-1)
|
|
radix = GetNumberConvertBase();
|
|
|
|
STR buf[32], * p = buf;
|
|
|
|
SupportFn.__ultoa(val, buf, radix);
|
|
|
|
_strinit(buf, -1);
|
|
}
|
|
|
|
void _strinit_n (int val, int radix)
|
|
{
|
|
STR buf[32];
|
|
|
|
if(radix==-1)
|
|
radix = GetNumberConvertBase();
|
|
|
|
SupportFn.__itoa(val, buf, radix);
|
|
_strinit(buf, -1);
|
|
}
|
|
|
|
|
|
|
|
void __strinit (STR const * s =0, long slen =0,
|
|
unsigned long flgs = 0)
|
|
{
|
|
_strinit(s,slen,flgs);
|
|
};
|
|
|
|
|
|
|
|
//*****************************************************************************
|
|
// to access the data directly over PTR: internally used
|
|
//*****************************************************************************
|
|
public:
|
|
STR* c_ptr (void) // not necessarily NUL terminated!
|
|
{ // Use with caution...
|
|
return StrBBuffer<STR>::Get();
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
public:
|
|
STR const* c_str (void) // return char*
|
|
{
|
|
|
|
return StrBBuffer<STR>::Get(SupportFn.__std_terminating_element(),NULL);
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
// length returns len of string
|
|
//*****************************************************************************
|
|
public:
|
|
long length (void)
|
|
{
|
|
// Null-Terminator zählt nicht und muß vorher weg!
|
|
STR sTerm = SupportFn.__std_terminating_element();
|
|
StrBBuffer<STR>::TruncateChr(sTerm,false,true);
|
|
|
|
return StrBBuffer<STR>::Len();
|
|
}
|
|
|
|
long Len (void)
|
|
{
|
|
// Null-Terminator zählt nicht und muß vorher weg!
|
|
STR sTerm = SupportFn.__std_terminating_element();
|
|
StrBBuffer<STR>::TruncateChr(sTerm,false,true);
|
|
|
|
return StrBBuffer<STR>::Len();
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// size returns the buffer's size
|
|
//*****************************************************************************
|
|
long Size (void)
|
|
{
|
|
// Null-Terminator zählt nicht und muß vorher weg!
|
|
STR sTerm = SupportFn.__std_terminating_element();
|
|
StrBBuffer<STR>::TruncateChr(sTerm,false,true);
|
|
|
|
return (long)StrBBuffer<STR>::size();
|
|
}
|
|
|
|
void ReserveBuffer(long ReqSize,STR& FillElem)
|
|
{
|
|
StrBBuffer<STR>::ReserveBuffer(ReqSize,FillElem);
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
//*****************************************************************************
|
|
// Constructor's of different kind
|
|
//*****************************************************************************
|
|
StrT(void)
|
|
{
|
|
// OutputDebugString("Constructor void\r\n");
|
|
InitPrivateData();
|
|
_strinit(NULL,-1);
|
|
};
|
|
|
|
StrT(STR* s)
|
|
{
|
|
// OutputDebugString("Constructor STR*\r\n");
|
|
InitPrivateData();
|
|
_strinit(s,-1);
|
|
};
|
|
|
|
StrT(STR const* s)
|
|
{
|
|
// OutputDebugString("Constructor STR*\r\n");
|
|
InitPrivateData();
|
|
_strinit(s,-1);
|
|
};
|
|
|
|
|
|
StrT(STR const * s, long len)
|
|
{
|
|
// OutputDebugString("Constructor STR* + len\r\n");
|
|
InitPrivateData();
|
|
_strinit(s, len);
|
|
};
|
|
|
|
|
|
StrT(STR c)
|
|
{
|
|
// OutputDebugString("Constructor STR\r\n");
|
|
InitPrivateData();
|
|
_strinit (&c, 1);
|
|
}
|
|
|
|
StrT(unsigned long val)
|
|
{
|
|
InitPrivateData();
|
|
// OutputDebugString("Constructor long\r\n");
|
|
_strinit_n(val,-1);
|
|
};
|
|
|
|
StrT(int val)
|
|
{
|
|
// OutputDebugString("Constructor int\r\n");
|
|
InitPrivateData();
|
|
_strinit_n(val,-1);
|
|
};
|
|
|
|
StrT(StrT & s)
|
|
// : strdata(s.strdata)
|
|
{
|
|
// Übernahme des Flags vom Anderen
|
|
m_Flag = s.m_Flag;
|
|
_strinit(s.c_ptr(),s.length());
|
|
// OutputDebugString("Constructor const StrT: ref++\r\n");
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
// Destructor
|
|
//*****************************************************************************
|
|
~StrT(void)
|
|
{
|
|
// OutputDebugString("Destructor\r\n");
|
|
InitPrivateData();
|
|
}
|
|
|
|
StrT& Set(StrT& s)
|
|
{
|
|
StrBBuffer<STR>::Set(s.c_ptr(),s.length());
|
|
return *this;
|
|
}
|
|
|
|
StrT& Set(const STR* s,long nCh)
|
|
{
|
|
if(s)
|
|
StrBBuffer<STR>::Set(s,nCh);
|
|
return *this;
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
// deletes the data or decrements the buffer's reference counter
|
|
//*****************************************************************************
|
|
StrT & Clear(void)
|
|
{
|
|
StrBBuffer<STR>::Clear();
|
|
return *this;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// Exported, but for use with very good care!!!
|
|
//*****************************************************************************
|
|
void __SetLen(long len)
|
|
{
|
|
StrBBuffer<STR>::SetLen(len);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// Checks the buffer and does CopyOnWrite operation to duplicate buffer
|
|
//*****************************************************************************
|
|
private:
|
|
|
|
//*****************************************************************************
|
|
// "=" - Operators
|
|
//*****************************************************************************
|
|
public:
|
|
//StrT & operator= (StrT const & s)
|
|
//{
|
|
// StrBBuffer<STR>:: = s; //.m_Str;
|
|
|
|
// return *this;
|
|
//}
|
|
|
|
|
|
StrT & operator= (STR const * s)
|
|
{
|
|
_strinit(s,-1);
|
|
|
|
return *this;
|
|
}
|
|
|
|
StrT & operator= (STR c)
|
|
{
|
|
_strinit(&c,-1);
|
|
return *this;
|
|
}
|
|
|
|
StrT & operator= (long n)
|
|
{
|
|
ltos(n);
|
|
return *this;
|
|
}
|
|
|
|
StrT & operator= (unsigned long n)
|
|
{
|
|
ultos(n);
|
|
return *this;
|
|
}
|
|
|
|
//*************************************************************************
|
|
// Additionsoperatoren
|
|
//*************************************************************************
|
|
StrT& operator+=(const StrT& s)
|
|
{
|
|
_concat((StrT<STR,SUPPORT,ALLOC>&)s);
|
|
// m_Str += s.m_Str;
|
|
return *this;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long TruncateLeft(long nElem)
|
|
{
|
|
return StrBBuffer<STR>::TruncateLeft(nElem);
|
|
}
|
|
|
|
long TruncateRight(long nElem)
|
|
{
|
|
// Null-Terminator zählt nicht und muß vorher weg!
|
|
STR sTerm = SupportFn.__std_terminating_element();
|
|
StrBBuffer<STR>::TruncateChr(sTerm,false,true);
|
|
|
|
return StrBBuffer<STR>::TruncateRight(nElem);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// copy the data into a external buffer
|
|
//*****************************************************************************
|
|
int Copy(STR * dst, long maxlen)
|
|
{
|
|
if(dst==NULL)
|
|
return 0;
|
|
if (maxlen == -1)
|
|
maxlen = long(length() + 1);
|
|
long len = long(maxlen - 1);
|
|
if (len > length())
|
|
len = length();
|
|
if (len > 0)
|
|
SupportFn.__block_copy(dst, c_ptr(), len);
|
|
if (len >= 0)
|
|
dst[len] = SupportFn.__std_terminating_element();
|
|
return len;
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
// Compare two strings
|
|
//*****************************************************************************
|
|
int Compare (StrT & s)
|
|
{
|
|
return _compare(s);
|
|
}
|
|
|
|
int Compare (StrT & s, bool CompareCase)
|
|
{
|
|
return Compare(s.c_str(),CompareCase);
|
|
}
|
|
|
|
|
|
int Compare (STR const * s)
|
|
{
|
|
// Wenn NULL-Vergleich, ist String immer größer als Vergl.Str.
|
|
if(s==NULL)
|
|
return 1;
|
|
|
|
if(m_Flag&STRTTFLAG_CASE)
|
|
return SupportFn.__stricmp(c_str(), s);
|
|
return SupportFn.__strcmp(c_str(), s);
|
|
|
|
}
|
|
|
|
int Compare (STR const * s, bool CompareCase)
|
|
{
|
|
// Wenn NULL-Vergleich, ist String immer größer als Vergl.Str.
|
|
if(s==NULL)
|
|
return 1;
|
|
|
|
if(CompareCase)
|
|
return SupportFn.__strcmp(c_str(), s);
|
|
return SupportFn.__stricmp(c_str(), s);
|
|
|
|
}
|
|
|
|
|
|
private:
|
|
int __compare_int(STR const* s1, STR const* s2)
|
|
{
|
|
|
|
if(m_Flag&STRTTFLAG_CASE)
|
|
return SupportFn.__stricmp(s1, s1);
|
|
return SupportFn.__strcmp(s1, s2);
|
|
}
|
|
|
|
public:
|
|
//*****************************************************************************
|
|
// Offset eines Substrings im String finden
|
|
//*****************************************************************************
|
|
long StrStr (StrT & s)
|
|
{
|
|
return _strstr(s);
|
|
}
|
|
|
|
long StrStr (STR const * s)
|
|
{
|
|
return _strstr(s);
|
|
}
|
|
|
|
|
|
|
|
//*****************************************************************************
|
|
// String einfügen an Position
|
|
//*****************************************************************************
|
|
/* long insert (long pos, StrT & s)
|
|
{
|
|
return insert (pos, s.c_ptr(), s.length());
|
|
}
|
|
*/
|
|
long InsertElem (long pos, STR c)
|
|
{
|
|
return Insert (pos, &c, 1);
|
|
}
|
|
|
|
|
|
/*
|
|
long insert (long pos, const STR& s, long len)
|
|
{
|
|
insert(pos,&s,len);
|
|
}
|
|
*/
|
|
|
|
|
|
long Insert (long pos, STR const * s, long len = -1)
|
|
{
|
|
if(s==0)
|
|
return length();
|
|
|
|
if (len < 0)
|
|
len = (long) SupportFn.__strlen (s);
|
|
|
|
return StrBBuffer<STR>::Insert(pos,s,len);
|
|
}
|
|
|
|
|
|
|
|
//*****************************************************************************
|
|
// Stück aus String entfernen
|
|
//*****************************************************************************
|
|
long Remove (long pos, long len)
|
|
{
|
|
return StrBBuffer<STR>::remove(pos,len);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// Ersetzen eines Teilstrings
|
|
//*****************************************************************************
|
|
long Replace (long pos, StrT & s, long clen =-1)
|
|
{
|
|
return Replace (pos, s.c_ptr(), clen, s.length());
|
|
}
|
|
/*
|
|
long replace (long pos, STR const * s, long clen =-1, long len =-1)
|
|
{
|
|
return replace (pos, s, clen, len);
|
|
}
|
|
*/
|
|
long Replace (long pos, STR c, long clen =-1)
|
|
{
|
|
return Replace (pos, &c, clen, 1);
|
|
}
|
|
|
|
|
|
long Replace (long pos, STR const * s, long clen = -1, long len = -1)
|
|
{
|
|
if(s==NULL)
|
|
return StrBBuffer<STR>::Len();
|
|
|
|
if (len < 0)
|
|
len = (long) SupportFn.__strlen (s);
|
|
|
|
return StrBBuffer<STR>::replace(pos,s,clen,len);
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT & Left (long len, STR padch)
|
|
{
|
|
StrBBuffer<STR>::left(len,padch);
|
|
|
|
return *this;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT & Right (long len, STR padch)
|
|
{
|
|
StrBBuffer<STR>::right(len,padch);
|
|
|
|
return *this;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT & Mid (long pos, long len, STR padch)
|
|
{
|
|
StrBBuffer<STR>::mid(pos,len,padch);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT Substr(long start, long len)
|
|
{
|
|
if (start < 0)
|
|
start = long(length() + (start));
|
|
if (start < 0 || start >= StrBBuffer<STR>::Len())
|
|
return StrT(); // Empty
|
|
if (len < 0 || (long(start + len) > StrBBuffer<STR>::Len()))
|
|
len = long(StrBBuffer<STR>::Len() - start);
|
|
return StrT(c_ptr() + (start), len);
|
|
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
int _concat (StrT & s)
|
|
{
|
|
return _concat (s.c_ptr(), s.length());
|
|
}
|
|
|
|
int _concat (STR ch)
|
|
{
|
|
return _concat (&ch, 1);
|
|
}
|
|
|
|
|
|
int _concat (const STR * s, long len = -1)
|
|
{
|
|
if(s==NULL)
|
|
return length();
|
|
|
|
if (len < 0)
|
|
len = (long) SupportFn.__strlen (s);
|
|
if (len > 0)
|
|
{
|
|
StrBBuffer<STR>::Add(s,len,SupportFn.__std_terminating_element());
|
|
}
|
|
|
|
return length();
|
|
}
|
|
|
|
|
|
|
|
|
|
// bool operator== (StrT const & s) const
|
|
bool operator== (StrT & s)
|
|
{
|
|
return (_compare(s) == 0) ? true : false;
|
|
}
|
|
|
|
bool operator== (STR /*const*/ * s) /*const*/
|
|
{
|
|
return (_compare(s) == 0) ? true : false;
|
|
}
|
|
|
|
|
|
bool operator!= (StrT /*const*/ & s) /*const*/
|
|
{
|
|
return (_compare(s) != 0) ? true : false;
|
|
}
|
|
|
|
bool operator!= (STR /*const*/ * s) /*const*/
|
|
{
|
|
return (_compare(s) != 0) ? true : false;
|
|
}
|
|
|
|
bool operator< (StrT /*const*/ & s) /*const*/
|
|
{
|
|
return (_compare(s) < 0) ? true : false;
|
|
}
|
|
|
|
bool operator< (STR /*const*/ * s) /*const*/
|
|
{
|
|
return (_compare(s) < 0) ? true : false;
|
|
}
|
|
|
|
|
|
bool operator<= (StrT /*const*/ & s) /*const*/
|
|
{
|
|
return (_compare(s) <= 0) ? true : false;
|
|
}
|
|
|
|
bool operator<= (STR /*const*/ * s) /*const*/
|
|
{
|
|
return (_compare(s) <= 0) ? true : false;
|
|
}
|
|
|
|
|
|
bool operator> (StrT /*const*/ & s) /*const*/
|
|
{
|
|
return (_compare(s) > 0) ? true : false;
|
|
}
|
|
|
|
bool operator> (STR /*const*/ * s) /*const*/
|
|
{
|
|
return (_compare(s) > 0) ? true : false;
|
|
}
|
|
|
|
bool operator>= (StrT /*const*/ & s) /*const*/
|
|
{
|
|
return (_compare(s) >= 0) ? true : false;
|
|
}
|
|
|
|
bool operator>= (STR /*const*/ * s) /*const*/
|
|
{
|
|
return (_compare(s) >= 0) ? true : false;
|
|
}
|
|
|
|
/*
|
|
StrT & operator<< (STR const * s) // concatenate
|
|
{
|
|
_concat (s);
|
|
return *this;
|
|
}
|
|
*/
|
|
//*************************************************************************
|
|
// Stream-in-Operatoren
|
|
//*************************************************************************
|
|
|
|
//*************************************************************************
|
|
// Konvertierungsoperatoren char + wchar
|
|
//*************************************************************************
|
|
StrT & operator<< (const char* s)
|
|
{
|
|
STR* lpStr = SupportFn.__csconvert(s);
|
|
if(lpStr)
|
|
{
|
|
_concat (lpStr);
|
|
SupportFn.__csconvert_free(lpStr);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
StrT & operator<< (const wchar_t* s)
|
|
{
|
|
STR* lpStr = SupportFn.__wcsconvert(s);
|
|
if(lpStr)
|
|
{
|
|
_concat (lpStr);
|
|
SupportFn.__wcsconvert_free(lpStr);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
StrT & operator<< (StrT & s)
|
|
{
|
|
_concat (s.c_ptr(),s.length());
|
|
return *this;
|
|
}
|
|
|
|
StrT & operator<< (int val)
|
|
{
|
|
StrT<STR,SUPPORT,ALLOC> ts;
|
|
ts.ltos(val,GetNumberConvertBase());
|
|
_concat(ts);
|
|
// _concat (StrT(val));
|
|
return *this;
|
|
}
|
|
|
|
StrT& operator<< (unsigned int val)
|
|
{
|
|
StrT<STR,SUPPORT,ALLOC> ts;
|
|
ts.ultos(val,GetNumberConvertBase());
|
|
_concat(ts);
|
|
// _concat (StrT(val));
|
|
return *this;
|
|
}
|
|
|
|
StrT & operator<< (short val)
|
|
{
|
|
StrT<STR,SUPPORT,ALLOC> ts;
|
|
ts.ltos(val,GetNumberConvertBase());
|
|
_concat(ts);
|
|
// _concat (StrT(val));
|
|
return *this;
|
|
}
|
|
|
|
StrT & operator<< (unsigned short val)
|
|
{
|
|
StrT<STR,SUPPORT,ALLOC> ts;
|
|
ts.ultos(val,GetNumberConvertBase());
|
|
_concat(ts);
|
|
// _concat (StrT(val));
|
|
return *this;
|
|
}
|
|
|
|
StrT& operator<< (long val)
|
|
{
|
|
StrT<STR,SUPPORT,ALLOC> ts;
|
|
ts.ltos(val,GetNumberConvertBase());
|
|
_concat(ts);
|
|
// _concat (StrT(val));
|
|
return *this;
|
|
}
|
|
|
|
StrT & operator<< (unsigned long val)
|
|
{
|
|
StrT<STR,SUPPORT,ALLOC> ts;
|
|
ts.ultos(val,GetNumberConvertBase());
|
|
_concat(ts);
|
|
// _concat (StrT(val));
|
|
return *this;
|
|
}
|
|
|
|
StrT& operator<< (C_StreamIoManipulator& manip)
|
|
{
|
|
switch(manip.g_ManipId())
|
|
{
|
|
case IOMID_clear:
|
|
// Löschen des Strings
|
|
Clear();
|
|
break;
|
|
|
|
case IOMID_endl:
|
|
// Endline-Zeichen einbringen
|
|
Insert(-1,SupportFn.__std_eol_element(),-1);
|
|
|
|
// AddStr("\r\n");
|
|
break;
|
|
|
|
case IOMID_flag:
|
|
switch(manip.g_Manip())
|
|
{
|
|
case IOM_hex:
|
|
SetNumberConvertBase(16);
|
|
break;
|
|
|
|
case IOM_dec:
|
|
SetNumberConvertBase(10);
|
|
break;
|
|
|
|
case IOM_oct:
|
|
SetNumberConvertBase(8);
|
|
break;
|
|
|
|
case IOM_comp_case:
|
|
SetCompareCase(true);
|
|
break;
|
|
|
|
case IOM_comp_nocase:
|
|
SetCompareCase(false);
|
|
break;
|
|
|
|
};
|
|
|
|
break;
|
|
};
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
/*
|
|
StrT & operator<< (const STR c)
|
|
{
|
|
_concat (c);
|
|
return *this;
|
|
}
|
|
|
|
StrT & operator<< (unsigned char c)
|
|
{
|
|
_concat (c);
|
|
return *this;
|
|
}
|
|
*/
|
|
|
|
|
|
//*****************************************************************************
|
|
// String is never modified in this version
|
|
//*****************************************************************************
|
|
STR const & operator[] (long pos) const
|
|
{
|
|
if (pos < 0) // Negative index addresses from eos
|
|
pos = long(StrBBuffer<STR>::Len() + pos);
|
|
if (pos >= m_Data.Len())
|
|
{
|
|
STR * buf = c_ptr() + length();
|
|
*buf = 0;
|
|
return *buf;
|
|
}
|
|
return c_ptr()[pos];
|
|
}
|
|
|
|
// ... but here it may be
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
STR & operator[] (long pos)
|
|
{
|
|
if (pos < 0) // Negative index addresses from eos
|
|
pos = long(StrBBuffer<STR>::Len() + pos);
|
|
if (pos < 0) // Any cleaner way without exceptions?
|
|
pos = StrBBuffer<STR>::Len();
|
|
if (pos < StrBBuffer<STR>::Len())
|
|
{
|
|
// Nix zu tun.
|
|
}
|
|
else
|
|
{
|
|
for(long i=StrBBuffer<STR>::Len();i<pos;i++)
|
|
StrBBuffer<STR>::AddElem(SupportFn.__std_whitespace_element());
|
|
}
|
|
return c_ptr()[pos];
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
int _compare(StrT /*const*/ s)
|
|
{
|
|
if((m_Flag&STRTTFLAG_CASE)||(s.m_Flag&STRTTFLAG_CASE))
|
|
return SupportFn.__stricmp(c_str(), s.c_str());
|
|
return SupportFn.__strcmp(c_str(), s.c_str());
|
|
}
|
|
|
|
int __compare(StrT const s) const
|
|
{
|
|
if((m_Flag&STRTTFLAG_CASE)||(s.m_Flag&STRTTFLAG_CASE))
|
|
return SupportFn.__stricmp(c_str(), s.c_str());
|
|
return SupportFn.__strcmp(c_str(), s.c_str());
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long _strstr(StrT /*const*/ s)
|
|
{
|
|
STR *p;
|
|
|
|
if((m_Flag&STRTTFLAG_CASE)||(s.m_Flag&STRTTFLAG_CASE))
|
|
p = SupportFn.__strstr(c_str(), s.c_str());
|
|
else
|
|
p = SupportFn.__stristr(c_str(), s.c_str());
|
|
return long((p) ? (p - StrBBuffer<STR>::Get(NULL)) : -1);
|
|
}
|
|
|
|
long AddChOnce(STR ch)
|
|
{
|
|
// Entfernen des Terminators
|
|
STR sTerm = SupportFn.__std_terminating_element();
|
|
StrBBuffer<STR>::TruncateChr(sTerm,false,true);
|
|
long dwSize = StrBBuffer::Len();
|
|
if(dwSize>0)
|
|
{
|
|
STR* MyStr = StrBBuffer::Get();
|
|
if((MyStr)&&(MyStr[dwSize-1]==ch))
|
|
return dwSize;
|
|
}
|
|
|
|
StrBBuffer::AddElem(ch);
|
|
|
|
return StrBBuffer::Len();
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long RemoveCh (STR const * clist)
|
|
{
|
|
|
|
long result = 0;
|
|
if (*clist)
|
|
{
|
|
// Kopie des Puffers anlegen und Puffer löschen
|
|
StrTBuffer<STR> ts((StrTBuffer<STR>)this/*m_Str*/);
|
|
StrBBuffer<STR>::Clear();
|
|
|
|
STR * buf;
|
|
long nLen = 0;
|
|
buf = ts.Get(&nLen);
|
|
|
|
for (long i = 0; i < nlen; ++i)
|
|
{
|
|
// Char nicht im Charset? Dann zum String hinzufügen.
|
|
if (SupportFn.__strchr (clist, buf[i]) != 0)
|
|
StrBBuffer<STR>::AddElem(buf[i],SupportFn.__std_terminating_element);
|
|
else
|
|
result++;
|
|
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long CountCh (STR const * clist)
|
|
{
|
|
long result = 0;
|
|
if (*clist)
|
|
{
|
|
long nLen;
|
|
STR * buf = StrBBuffer<STR>::Get(&nLen);
|
|
for (long i = 0; i < nlen; ++i, ++buf)
|
|
if (SupportFn.__strchr (clist, *buf) != 0)
|
|
++result;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
// Funktionen zur Kompatibilität mit V_String-Klasse
|
|
//*****************************************************************************
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT& toUpper(void)
|
|
{
|
|
SupportFn.__strupr((STR*)c_str());
|
|
return *this;
|
|
};
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT& toLower(void)
|
|
{
|
|
SupportFn.__strlwr((STR*)c_str());
|
|
return *this;
|
|
};
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
StrT& Trim(unsigned long mode, STR c)
|
|
{
|
|
|
|
if(mode == STRTTMODE_RIGHT)
|
|
{
|
|
// Bevor es rechts funktioieren kann, muß der Terminator weg!
|
|
STR sTerm = SupportFn.__std_terminating_element();
|
|
StrBBuffer<STR>::TruncateChr(sTerm,false,true);
|
|
StrBBuffer<STR>::TruncateChr(c,false,true);
|
|
}
|
|
else if(mode == STRTTMODE_LEFT)
|
|
StrBBuffer<STR>::TruncateChr(c,true,false);
|
|
else if(mode == STRTTMODE_CENTER)
|
|
{
|
|
// Bevor es rechts funktioieren kann, muß der Terminator weg!
|
|
STR sTerm = SupportFn.__std_terminating_element();
|
|
StrBBuffer<STR>::TruncateChr(sTerm,false,true);
|
|
StrBBuffer<STR>::TruncateChr(c,true,true);
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
};
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
unsigned long CreateChecksum(void)
|
|
{
|
|
unsigned long chs = 0;
|
|
long nChr = 0;
|
|
STR * buf = StrBBuffer<STR>::Get(&nChr);
|
|
for(long i=0;i<nChr;i++)
|
|
{
|
|
chs = __HashKey(chs,SupportFn.__get_element_checksum_value(buf[i]));
|
|
};
|
|
return chs;
|
|
};
|
|
|
|
private:
|
|
unsigned long __HashKey(unsigned long key, unsigned long nHash)
|
|
{
|
|
return ((nHash<<5) + nHash + key);
|
|
};
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
public:
|
|
void ltos(const long n, int radix = -1)
|
|
{
|
|
if(radix==-1)
|
|
radix = GetNumberConvertBase();
|
|
_strinit_n(n,radix);
|
|
};
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
void ultos(const unsigned long n, int radix = -1)
|
|
{
|
|
if(radix==-1)
|
|
radix = GetNumberConvertBase();
|
|
_strinit_n(n,radix);
|
|
};
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long& Value(long& n, int radix = -1)
|
|
{
|
|
if(radix==-1)
|
|
radix = GetNumberConvertBase();
|
|
|
|
const STR * buf = c_str();
|
|
n = SupportFn.__strtol(buf,NULL,radix);
|
|
return n;
|
|
};
|
|
|
|
unsigned long& Value(unsigned long& n, int radix = -1)
|
|
{
|
|
if(radix==-1)
|
|
radix = GetNumberConvertBase();
|
|
|
|
const STR * buf = c_str();
|
|
n = SupportFn.__strtoul(buf,NULL,radix);
|
|
return n;
|
|
};
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
int GetNumberConvertBase(void)
|
|
{
|
|
// Bit-Flags sind für octal + hex, wenn keins gesetzt ist, ist's dezimal
|
|
if(m_Flag&STRTTFLAG_OCT)
|
|
return 8;
|
|
else if(m_Flag&STRTTFLAG_HEX)
|
|
return 16;
|
|
else
|
|
return 10;
|
|
|
|
return 10;
|
|
};
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
void SetNumberConvertBase(int base)
|
|
{
|
|
// Löschen der Flags
|
|
m_Flag &= ~(STRTTFLAG_HEX|STRTTFLAG_OCT);
|
|
|
|
switch(base)
|
|
{
|
|
case 8:
|
|
m_Flag |= STRTTFLAG_OCT;
|
|
break;
|
|
|
|
case 16:
|
|
m_Flag |= STRTTFLAG_HEX;
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// Wenn CaseSens TRUE ist, werden Vergleiche case-sensitiv durchgeführt.
|
|
//*****************************************************************************
|
|
void SetCompareCase(bool CaseSens)
|
|
{
|
|
if(CaseSens)
|
|
{
|
|
m_Flag |= STRTTFLAG_CASE;
|
|
}
|
|
else
|
|
{
|
|
m_Flag &= ~STRTTFLAG_CASE;
|
|
}
|
|
}
|
|
|
|
|
|
//*****************************************************************************
|
|
// Index: liefert den Offset im String nach AWK-Manier
|
|
//*****************************************************************************
|
|
long Index(const STR* strCharset)
|
|
{
|
|
if(strCharset==NULL)
|
|
return -1;
|
|
|
|
|
|
STR *p;
|
|
STR* buf;
|
|
buf = (STR*)c_str();
|
|
if(m_Flag&STRTTFLAG_CASE)
|
|
p = SupportFn.__strstr(buf, strCharset);
|
|
else
|
|
p = SupportFn.__stristr(buf, strCharset);
|
|
return long((p) ? (p - buf) : -1);
|
|
|
|
};
|
|
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long FindFirstElemInSetBin(long start,STR* chr,long nPat)
|
|
{
|
|
return StrBBuffer<STR>::FindFirstElemInSet(start,chr,nPat);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//*****************************************************************************
|
|
long IndexBin(long start,STR* chr,long nPat)
|
|
{
|
|
|
|
return StrBBuffer<STR>::Index(start,chr,nPat);
|
|
|
|
//if((chr==NULL)||(nPat<0)||(start>m_Str.Len()))
|
|
// return -1;
|
|
|
|
//if(start<0)
|
|
// start = 0;
|
|
|
|
|
|
//STR* lpDat = m_Str.Get();
|
|
//long Len = m_Str.Len() - nPat;
|
|
//for(long i = start;i<Len;i++)
|
|
//{
|
|
// if(memcmp(lpDat+i,chr,nPat*sizeof(STR))==0)
|
|
// {
|
|
// return i;
|
|
// }
|
|
//}
|
|
|
|
//return -1;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// Erstes Vorkommen von str finden. Die Variable pos wird initialisiert und
|
|
// wird bei nächsten Such-Durchläuifen werwendet.
|
|
//*****************************************************************************
|
|
long& FindFirst(const STR* str,long& pos)
|
|
{
|
|
|
|
pos = Index(str); // do the search
|
|
|
|
return pos;
|
|
};
|
|
|
|
long& FindFirst(const StrT& str,long& pos)
|
|
{
|
|
const STR * buf = str.c_str();
|
|
return FindFirst(buf,pos);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// Find the next occurrence of substring 'findStr' in the string
|
|
// pos ist die von FindFirst initialisierte Variable zum Zwischenspeichern
|
|
// des aktuellen Ergebnisses.
|
|
//*****************************************************************************
|
|
long& FindNext(const STR* str,long& pos)
|
|
{
|
|
|
|
long leng = StrBBuffer<STR>::Len();
|
|
const STR * buf = c_str();
|
|
|
|
if(pos>=leng)
|
|
pos = -1;
|
|
else
|
|
{
|
|
// Wahrscheinlich ist pos noch ein Hinweis auf einen
|
|
// gefundenen str. Wenn ja, weiterschalten.
|
|
if(__compare_int(buf+pos,str)>=0)
|
|
pos += SupportFn.__strlen(str);
|
|
|
|
STR* lpStr = SupportFn.__strstr(buf+pos,str);
|
|
if(lpStr)
|
|
pos = (lpStr-buf);
|
|
else
|
|
pos = -1;
|
|
};
|
|
|
|
return pos;
|
|
};
|
|
|
|
|
|
long& FindNext( StrT& str,long& pos)
|
|
{
|
|
const STR * buf = str.c_str();
|
|
return FindNext(buf,pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
|
|
|
|
typedef StrT<wchar_t, WIDECHAR_SUPPORT<wchar_t>, C_MemoryAllocatorRtl > StrW;
|
|
typedef StrT<char, CHAR_SUPPORT<char>, C_MemoryAllocatorRtl > StrC;
|
|
|
|
typedef StrT<wchar_t, WIDECHAR_SUPPORT<wchar_t>, C_MemoryAllocatorHeap > StrHW;
|
|
typedef StrT<char, CHAR_SUPPORT<char>, C_MemoryAllocatorHeap > StrHC;
|
|
|
|
#ifdef _UNICODE
|
|
#define _tStr StrW
|
|
#else
|
|
#define _tStr StrC
|
|
#endif
|
|
|
|
typedef LinkedListEntryT<StrW> StrWLlEntry;
|
|
typedef LinkedListEntryT<StrC> StrCLlEntry;
|
|
|
|
template<typename STRINGOBJ, typename LLIST, typename STR>
|
|
class StrTArray
|
|
{
|
|
private:
|
|
LLIST* lpLinkedList;
|
|
|
|
public:
|
|
StrTArray(){lpLinkedList = NULL;}
|
|
|
|
~StrTArray()
|
|
{
|
|
if(lpLinkedList!=NULL) delete lpLinkedList;
|
|
lpLinkedList = NULL;
|
|
}
|
|
|
|
STRINGOBJ& push_back(STRINGOBJ& ob)
|
|
{
|
|
// STRINGOBJ* lpNew = new STRINGOBJ(ob);
|
|
if(lpLinkedList==NULL)
|
|
lpLinkedList = new LLIST(&ob);
|
|
else
|
|
lpLinkedList->Add(&ob);
|
|
// return *lpNew;
|
|
return ob;
|
|
}
|
|
|
|
bool GetString(STRINGOBJ& str,unsigned long idx)
|
|
{
|
|
STRINGOBJ* lpRetVal = GetString(idx);
|
|
if(lpRetVal)
|
|
{
|
|
str.Set(*lpRetVal);
|
|
return true;
|
|
}
|
|
// str = *lpRetVal;
|
|
/* if(lpLinkedList)
|
|
{
|
|
lpLinkedList->Get(idx,str);
|
|
}*/
|
|
return false;
|
|
}
|
|
|
|
STRINGOBJ* GetString(unsigned long idx)
|
|
{
|
|
if(lpLinkedList)
|
|
return lpLinkedList->GetPtr(idx);
|
|
return NULL;
|
|
}
|
|
|
|
void Clear(void)
|
|
{
|
|
if(lpLinkedList)
|
|
delete lpLinkedList;
|
|
lpLinkedList = NULL;
|
|
}
|
|
|
|
|
|
// Hackt einen String dort in Stücke, wo die komplette Sequenz SplitStr
|
|
// gefunden wird.
|
|
unsigned long SplitStr(STRINGOBJ& str,STR* SplitStr,long nChr)
|
|
{
|
|
unsigned long SegCount = 0;
|
|
|
|
Clear();
|
|
|
|
// unsigned long i,j;
|
|
long LastPos = 0;
|
|
long pos = 0;
|
|
|
|
STRINGOBJ seg;
|
|
|
|
while((pos = str.IndexBin(pos,SplitStr,nChr))!=-1)
|
|
{
|
|
// Segment liegt zwischen LastPos und Pos
|
|
seg = str.Substr(LastPos,pos-LastPos);
|
|
push_back(seg);
|
|
SegCount++;
|
|
pos += nChr;
|
|
LastPos = pos;
|
|
|
|
}
|
|
/*
|
|
while( (pos = str.FindNext(charset,pos))!=-1)
|
|
{
|
|
// Segment liegt zwischen LastPos und Pos
|
|
seg = str.Substr(LastPos,pos-LastPos);
|
|
push_back(seg);
|
|
SegCount++;
|
|
LastPos = pos + charset.length();
|
|
};
|
|
*/
|
|
seg = str.Substr(LastPos,-1);
|
|
if(seg.length()!=0)
|
|
{
|
|
push_back(seg);
|
|
SegCount++;
|
|
};
|
|
|
|
return SegCount;
|
|
|
|
}
|
|
|
|
|
|
// Trennt einen String in Segmente bei jedem Vorkommen eines
|
|
// Elementes von charset
|
|
unsigned long Split(STRINGOBJ& str,STR* charset,long nChr)
|
|
{
|
|
unsigned long SegCount = 0;
|
|
|
|
Clear();
|
|
|
|
// unsigned long i,j;
|
|
long LastPos = 0;
|
|
long pos = 0;
|
|
|
|
STRINGOBJ seg;
|
|
|
|
// while((pos = str.IndexBin(pos,charset,nChr))!=-1)
|
|
while((pos=str.FindFirstElemInSetBin(pos,charset,nChr))!=-1)
|
|
{
|
|
// Segment liegt zwischen LastPos und Pos
|
|
seg = str.Substr(LastPos,pos-LastPos);
|
|
push_back(seg);
|
|
SegCount++;
|
|
pos++; // Überspringen des Separators
|
|
LastPos = pos;
|
|
|
|
}
|
|
/*
|
|
while( (pos = str.FindNext(charset,pos))!=-1)
|
|
{
|
|
// Segment liegt zwischen LastPos und Pos
|
|
seg = str.Substr(LastPos,pos-LastPos);
|
|
push_back(seg);
|
|
SegCount++;
|
|
LastPos = pos + charset.length();
|
|
};
|
|
*/
|
|
seg = str.Substr(LastPos,-1);
|
|
if(seg.length()!=0)
|
|
{
|
|
push_back(seg);
|
|
SegCount++;
|
|
};
|
|
|
|
return SegCount;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
typedef StrTArray<StrW,StrWLlEntry, wchar_t> StrWArray;
|
|
typedef StrTArray<StrC,StrCLlEntry, char> StrCArray;
|
|
|
|
|
|
//*****************************************************************************
|
|
// Prototypen für globale Funktionen
|
|
//*****************************************************************************
|
|
int StrWPrintf(StrW& buffer,long siz,const wchar_t* format, ...);
|
|
int StrCPrintf(StrC& buffer,long siz,const char* format, ...);
|
|
|
|
unsigned long StrCGetPrivateProfileString(StrC AppName,StrC KeyName,StrC Default,StrC& ReturnedString,long MaxSize,StrC FileName);
|
|
|
|
|
|
#endif // ____INC___STRT_H____CNI_____
|