Mehrere Basistypen, die ich für Delphi geschrieben habe

Autor：Eve Cole Aktualisierungszeit：2025-03-13 02:16:01

// Menschen, die an Java oder C# gewöhnt sind, sind möglicherweise sehr wütend auf Delphi und haben nicht einmal Grundtypen Sie hier draußen.

Einheit Basiclass;

Schnittstelle

Verwendung

Systeme, Klassen, Strutile, Idglobal, Math;

Typ

Tcharset = set of char;

var

TnormalCharSet: tcharset = [ #13, #10, #32, '.', ','; ';'];

Typ

Tstring = Klasse

Privat

Ftext: String;

öffentlich

Funktion charat (aposition: Ganzzahl): char;

// die Buchstaben der angegebenen Position

Funktion TolowerCase: String;

Klassenfunktion TolowerCase (Astring: String): String;

//Kleinbuchstaben

Funktion touppercase: String;

Klassenfunktion Touppercase (Astring: String): String;

//Hauptstadt

Klassenfunktionswert (Avalue: String): boolean;

Klassenfunktionswert (Avalue: Boolean): String;

Klassenfunktion Stringin (Avalue: String; Avalues: Array of String): Boolean;

Klassenfunktion links (Avalue: String; Alength: Ganzzahl): String;

Klassenfunktion rechts (Avalue: String; Alength: Ganzzahl): String;

Klassenfunktion DeletePrefix (Avalue: String; FixedString: tcharset = [#32]): String;

Klassenfunktion Deletesuffix (Avalue: String; FixedString: tcharset = [#32]): String;

Klassenfunktion im Vergleich (Avalue1: String; Avalue2: String): boolean;

Klassenfunktion HashCode (Avalue: String): Ganzzahl;

Klassenfunktion LastChar (Avalue: String): char;

Klassenfunktion StringReplace (const s, OldPattern, NewPattern: String;

Flags: Treplaceflags): String;

Klasse function Stringofchar (ch: char; count: Integer): String;

Klassenfunktions -SetString (var s: String; Puffer: pchar; Len: Integer): String;

Klassenfunktion getPy (Ast: String): String;

// Holen Sie sich den entsprechenden Pinyin.

Klassenfunktion Isallchinese (Ast: String): boolean;

Klassenfunktion Isallenglish (Ast: String): boolean;

Klassenfunktion getFirstword (Avalue: String; VAR AWORD: String; ASeparator: TCharSet): Integer;

Klassenfunktion getFirstword (Avalue: String; VAR AWORD: String; ASeparator: String): Integer;

// Der Rückgabewert ist die Länge vom Anfang bis zum Dokument.

Klassenfunktion getAllword (Avalue: String; ASeparator: String): TStringList;

// Alle Schlüsselwörter zurückgeben. Befreien Sie sich nach der Verwendung das Ergebnissatz.

// Hinweis: Bitte verwenden Sie diese Funktion nicht in zukünftigen Verwendung. Bitte verwenden Sie seine neu geladene Version

// GetAllword (Avalue: String; ASeparator: String; Astringlist: TStringList);

Klassenverfahren getAllword (Avalue: String; ASeparator: String; Astringlist: TStrings);

// Alle Ergebnissätze in die Astringlist laden;

Klassenprozedur getAllwordWithall (Avalue: String; ASeparator: String; Astringlist: TStrings);

Klasse function StringToCharSet (Avalue: String): TCharSet;

Klassenfunktion CharsettoString (Avalue: TCharSet): String;

Klassenfunktionsaktualisierung (AoldString: String; // Die zu bedienende Zeichenfolge

AUPDATESORCE: String;

AUPDATESTRING: String;

ASENTENCEPARATOR: STRING; // Satzabscheider.

AWORDSEPARATOR: String // Dokumentabscheider;

): String; // Rückgabeergebnis.

// Zum Beispiel der Rückgabewert von 'Dbarcode ASC, Dname Desc', 'dbarcode', '', ',' 'ist

// 'dname desc';

Klassenfunktion Deleterepeat (AoldString: String; // Um Zeichen zu verarbeiten

Adeletestring: Char;

Arepeat: char): String;

Klassenfunktion IFTHEN (aexpression: boolean; atrue: string; afalse: string): string;

// Rückgabe die entsprechende Zeichenfolge gemäß dem Wert des Ausdrucks.

Klassenfunktion Absolutetorelate (Aabsolute: String; Acurrent: String): String;

// Bei zwei Dateien den absoluten Pfad in den relativen Pfad konvertieren.

Klassenfunktion relatetoabSolute (Arate: String; Acurrent: String): String;

Klassenfunktionsin ähneln (AOne, ATWO: String): Integer;

Klassenfunktion getCharnum (Astring: String; Achar: char): Integer;

Klassenfunktionsindex (Astring, Asubstring: String): Integer;

Klassenfunktion Zerotoint (Astring: String): Ganzzahl;

Klassenfunktion Zerotofloat (Astring: String): doppelt;

Klassenfunktion Zerotostr (Astring: String): String;

Klassenfunktion Sametext (Astring, Astring1: String): boolean;

Klassenfunktion Reverse (Astring: String): String;

Klassenfunktion Isvalidip (const s: String): boolean;

Klassenfunktion fillString (Achar: char; Alength: Ganzzahl): String;

Klassenfunktion Stuffstring (const Atext: String; Astart, Alänge: Kardinal;

const asubtext: string): string;

Klassenfunktion GetNextString (var saurcestring: String; Asplitchar: String): String;

Ende;

// Ganzzahltyp.

Tintenger = Klasse

Klassenfunktion inttoStr (Achtel: Integer): String;

Klassenfunktion inttoStr (Achtel: Int64): String;

Klassenfunktion Isvalidint (Astring: String): boolean;

Klassenfunktion Isvalidint64 (Astring: String): boolean;

Klassenfunktion Maxint: Ganzzahl;

Klassenfunktion maxlongint: Ganzzahl;

Klassenfunktion HashCode (Gilte: Ganzzahl): Ganzzahl;

Klassenfunktion Inttobin (Achtel: Kardinal): String;

Klassenfunktion inttohex (Unleider: Integer): String;

Klassenfunktion Hextoint (Astring: String): Ganzzahl;

Klassenfunktion MAISTERIALNO (AINTEGER: Ganzzahl; Adigit: Integer): String;

Ende;

Tfloat = Klasse

Klassenfunktion Isvalidfloat (Astring: String): boolean;

Klassenfunktion MaxDouble: Double;

Klassenfunktion Mindouble: Double;

Klassenfunktion maxextended: erweitert;

Klassenfunktion Minextended: Extended;

Klassenfunktion gleichwertig (const a, b: Single; Epsilon: Single = 0): boolean;

Klassenfunktion gleichwertig (const a, b: double; epsilon: double = 0): boolean;

Klassenfunktion gleichwertig (const a, b: erweitert; Epsilon: erweitert = 0): boolean;

Klassenfunktion Froattomoney (const value: double; rund: boolean = true): String;

Ende;

TBOOLEAN = Klasse

Klassenfunktion BooltoStr (Aboolean: Boolean): String;

Klassenfunktion Strtobool (Astring: String): boolean;

Ende;

Durchführung

{Tstring}

Funktion getPyIndexchar (Achar: String): char;

Beginnen

Fallwort (Achar [1]) Shl 8 + Wort (Achar [2]) von

$ B0A1 .. $ B0C4: Ergebnis: = 'a';

$ B0C5 .. $ B2C0: Ergebnis: = 'B';

$ B2C1 .. $ B4ED: Ergebnis: = 'C';

$ B4EE .. $ B6E9: Ergebnis: = 'D';

$ B6ea .. $ B7A1: Ergebnis: = 'e';

$ B7A2 .. $ B8C0: Ergebnis: = 'F';

$ B8C1 .. $ B9FD: Ergebnis: = 'G';

$ B9FE .. $ BBF6: Ergebnis: = 'H';

$ BBF7 .. $ BFA5: Ergebnis: = 'J';

$ BFA6 .. $ C0AB: Ergebnis: = 'K';

$ C0AC .. $ C2E7: Ergebnis: = 'l';

$ C2E8 .. $ C4C2: Ergebnis: = 'M';

$ C4C3 .. $ C5B5: Ergebnis: = 'n';

$ C5B6 .. $ C5BD: Ergebnis: = 'O';

$ C5BE .. $ C6D9: Ergebnis: = 'P';

$ C6DA .. $ C8BA: Ergebnis: = 'q';

$ C8BB .. $ C8F5: Ergebnis: = 'r';

$ C8F6 .. $ CBF9: Ergebnis: = 's';

$ CBFA .. $ CDD9: Ergebnis: = 'T';

$ CDDA .. $ CEF3: Ergebnis: = 'W';

$ CEF4 .. $ D188: Ergebnis: = 'x';

$ D1b9 .. $ d4d0: Ergebnis: = 'y';

$ D4d1 .. $ d7f9: Ergebnis: = 'z';

anders

Ergebnis: = char (0);

Ende;

Klassenfunktion tstring.getPy (Ast: String): String;

var

I: Ganzzahl;

Beginnen

Ergebnisse: = '';

für i: = 1 zu länge (astr) tun

Beginnen

Wenn Bytetyp (AST, i) = mbtrailByte dann

Ergebnis: = Ergebnis + getPyIndexchar (AST [i - 1] + AST [i])

anders

Wenn Bytetyp (Ast, i) = mbsinglebyte dann

Ergebnis: = Ergebnis + ast [i];

Ende;

Funktion tstring.charat (Aposition: Ganzzahl): char;

Beginnen

Ergebnis: = ftext [aposition];

Ende;

Klassenfunktion Tstring.CharsettoString (Avalue: tcharset): String;

Beginnen

Ende;

Klassenfunktion tstring.comPestring (Avalue1, Avalue2: String): boolean;

Beginnen

Ergebnis: = Großbuchstaben (avalue1) = Großbuchstaben (Avalue2);

Ende;

Klassenfunktion tstring.DeletEprefix (Avalue: String;

FixedString: TCharSet): String;

Beginnen

während system.length (avalue)> 0 tun

Beginnen

Wenn Avalue [1] in FixedString dann dann

Löschen (avalue, 1, 1)

anders

Brechen;

Ende;

Ergebnis: = avalue;

Ende;

Klassenfunktion tstring.getFirstword (Avalue: String; VAR AWORD: String; ASeparator: TCharSet

): Ganzzahl;

var

tmpstr: String;

TMPPOS: Ganzzahl;

Beginnen

tmpstr: = deletesuffix (avalue, Aseparator);

tmpstr: = deleteprefix (avalue, Aseparator);

Ergebnis: = Länge (Avalue) - Länge (tmpstr);

{if länge (tmpstr) = 0, dann beenden;

if (tmpstr [1] = '' '') und (tmpstr [2] = '' ') dann

Beginnen

für tmppos: = 3 bis länge (tmpstr) tun

Beginnen

Wenn tmpstr [tmppos] in ['' '] dann

Brechen;

Ende;

Wenn tmppos> 3 dann tmppos: = tmppos + 2;

}

für tmppos: = 1 bis länge (tmpstr) tun

Beginnen

Wenn tmpstr [tmppos] im Aseparator dann

Brechen;

Ende;

tmppos: = tmppos -1;

// {todo: -Oghs das letzte Parameter -Parsen falsch} behoben}

if (tmppos = 0) und (avalue <> '') dann

TMPPOS: = Länge (Avalue);

AWORD: = Kopie (Avalue, Ergebnis + 1, tmppos);

Ergebnis: = Ergebnis + TMPPOS;

Ende;

Klassenfunktion tstring.hashCode (Avalue: String): Integer;

var

I: Ganzzahl;

tmpValue: Ganzzahl;

Beginnen

tmpValue: = 0;

für i: = 1 bis system.length (avalue) tun

Beginnen

tmpValue: = 3 * tmpValue + ord (avalue [i]);

Ende;

Ergebnis: = tmpValue;

Ende;

Klassenfunktion tstring.isallchinese (AST: String): boolean;

var

I: Ganzzahl;

Beginnen

Ergebnis: = wahr;

für i: = 1 zu länge (astr) tun

Beginnen

Wenn Bytetyp (Ast, i) = mbsinglebyte dann

Beginnen

Ergebnis: = falsch;

Brechen;

Ende;

Klassenfunktion tstring.isallenglish (Ast: String): boolean;

var

I: Ganzzahl;

Beginnen

Ergebnis: = wahr;

für i: = 1 zu länge (astr) tun

Beginnen

Wenn Bytetyp (AST, i) mbsinglebyte dann

Beginnen

Ergebnis: = falsch;

Brechen;

Ende;

Klassenfunktion tstring.lastchar (Avalue: String): char;

Beginnen

Ergebnis: = avalue [System.Length (avalue)];

Ende;

Klassenfunktion tstring.left (Avalue: String; Alength: Integer): String;

Beginnen

Ergebnis: = Copy (Avalue, 1, Höhenlänge);

Ende;

Klassenfunktion Tstring.Right (Avalue: String; Alength: Integer): String;

Beginnen

Ergebnis: = Strutils.RightStr (Avalue, Höhen);

Ende;

Klassenfunktion tstring.setString (var s: String; Puffer: pchar;

Len: Ganzzahl): String;

Beginnen

System.SetString (s, Puffer, Len);

Ergebnisse: = S;

Ende;

Klassenfunktion Tstring.Stringin (Avalue: String;

AVALUES: ARRAY OF STRING): Boolean;

var

I: Ganzzahl;

Beginnen

Ergebnis: = falsch;

für i: = niedrig (avales) bis hoch (avales) tun

Beginnen

Wenn Großbuchstaben (Avalue) = Großbuchstaben (Values [i]) dann

Beginnen

Ergebnis: = wahr;

Brechen;

Ende;

Klassenfunktion TString.StringOfchar (ch: char; count: Integer): String;

Beginnen

Ergebnis: = System.StringOfchar (ch, count);

Ende;

Klassenfunktion Tstring.StringReplace (const s, OldPatatter,

Newpattern: String;

Beginnen

Ergebnis: = sysutils.stringReplace (s, OldPatatter, NewPattern, Flags);

Ende;

Klassenfunktion Tstring.StringtoCharSet (Avalue: String): TCharSet;

var

I: Ganzzahl;

Beginnen

Ergebnisse: = [];

für i: = 1 bis länge (avalue) tun

Beginnen

Ergebnis: = Ergebnis + [Avalue [i]];

Ende;

Funktion tstring.tolowerCase: String;

Beginnen

Ergebnis: = Kleinbuchstaben (ftext);

Ende;

Funktion tstring.touppercase: String;

Beginnen

Ergebnis: = Großbuchstaben (ftext);

Ende;

Klassenfunktion Tstring.Valueof (Avalue: boolean): String;

Beginnen

Wenn Avalue dann

Ergebnis: = 'Ja'

anders

Ergebnis: = 'nein';

Ende;

Klassenfunktion Tstring.Valueof (Avalue: String): boolean;

Beginnen

Ergebnis: = Stringin (avalue, ['yes', 'yes', 'ok']);

Ende;

Klassenfunktion tstring.getFirstword (Avalue: String; var aword: string;

ASeparator: String): Ganzzahl;

Beginnen

Ergebnis: = GetFirstWord (Avalue, Aword, StringToCharset (ASeparator));

Ende;

Klassenfunktion tstring.getallword (Avalue, ASeparator: String): TStringList;

var

TMPLIST: TStringList;

TMPWord: String;

Beginnen

tmplist: = tstringlist.create;

während Länge (Avalue)> 0 tun

Beginnen

tmpword: = '';

Löschen (avalue, 1, getFirstWord (avalue, tmpword, aseparator));

Wenn tmpword <> '' dann

tmplist.add (TMPWord)

anders

Brechen;

Ende;

Ergebnis: = tmplist;

Ende;

Klassenfunktion Tstring.Updatesentce (AoldString, Aupdatesource,

AUPDATESTRING, ASENTENCEPARATOR, AWORDSEPARATOR: STRING): String;

var

tmpStentce: String;

TMPWord: String;

tmpword1: String;

I: Ganzzahl;

tmpresult: String;

Beginnen

// Erhalten Sie den ersten Satz

tmpStentce: = aoldString;

tmpresult: = '';

während Länge (tmpStentce)> 0 tun

Beginnen

i: = GetFirstWord (tmpStentce, tmpword, asENSceceParator);

tmpresult: = tmpresult + links (tmpStentce, i - Länge (tmpword));

Löschen (tmpStentce, 1, i);

Wenn tmpword <> '' dann

Beginnen

i: = getFirstWord (tmpword, tmpword1, awordseparator);

tmpresult: = tmpresult + links (tmpword, i - Länge (tmpword1));

Wenn Sie eine Vergleiche (tmpword1, aUpdateSource) dann dann

Beginnen

TMPRESULT: = TMPRESULT + AUPDATESTRING;

Ende

anders

Beginnen

tmpresult: = tmpresult + tmpword;

Ende;

tmpresult: = deleteprefix (tmpresult, ['', ',']);

tmpresult: = deletesuffix (tmpresult, ['', ',']);

tmpresult: = deleterepeat (tmpresult, ',', '');

tmpresult: = deleterepeat (tmpresult, '', '');

Ergebnis: = tmpresult;

Ende;

Klassenfunktion Tstring.DeletRepeat (AoldString: String; Adeletestring,

Arepeat: char): String;

var

I: Ganzzahl;

tmpfind1: boolean;

Beginnen

tmpfind1: = false;

Für i: = Länge (Aoldstring) nach 1 tun

Beginnen

Wenn tmpfind1 dann

Beginnen

Wenn AoldString [i] = adeletestring dann

Löschen (Aoldstring, i, 1)

anders

Beginnen

Wenn AoldString [i] = arepeat dann

Weitermachen;

tmpfind1: = aoldString [i] = adeletestring;

Ende;

Ende

anders

Beginnen

Wenn adeletestring <> arepeat dann dann

Wenn AoldString [i] = arepeat dann

Weitermachen;

tmpfind1: = aoldstring [i] = adeletestring

Ende;

Ergebnis: = AoldString;

Ende;

Klassenfunktion Tstring.Deletesuffix (Avalue: String;

FixedString: TCharSet): String;

Beginnen

während system.length (avalue)> 0 tun

Beginnen

Wenn Avalue [System.Length (Avalue)] in FixedString dann dann

Löschen (Avalue, System.Length (Avalue), 1)

anders

Brechen;

Ende;

Ergebnis: = avalue;

Ende;

Klassenprozedur tstring.getallword (Avalue, ASeparator: String;

Astringliste: TStrings);

var

TMPWord: String;

Beginnen

Wenn adstringlist = nil dann

Astringlist: = tstringlist.create;

während Länge (Avalue)> 0 tun

Beginnen

tmpword: = '';

Löschen (avalue, 1, getFirstWord (avalue, tmpword, aseparator));

Wenn tmpword <> '' dann

Astringlist.add (TMPWord)

anders

Brechen;

Ende;

Klassenfunktion Tstring.Wenn (aexpression: boolean; atrue,

Afalse: String): String;

Beginnen

Wenn dann

Ergebnis: = atrue

anders

Ergebnis: = Afalse;

Ende;

Klassenfunktion tstring.absolutetorelate (aabsolute,

ACURENT: String): String;

var

tmpsimaLilarstring: String;

Aoldfile: String;

I: Ganzzahl;

TMPPOS: Ganzzahl;

Beginnen

// Nach der Konvertierung bildet es .../../A.ini;

// Wenn es nicht auf demselben Laufwerk liegt, kehrt es direkt zum absoluten Pfad zurück.

Wenn extractFiledrive (aabsolute) <> extractFiledrive (Acurrent) dann

Ergebnis: = aabsolute

anders

Beginnen

tmpsimaLilarstring: = '';

Aoldfile: = Aabsolute;

Aabsolute: = extractFilepath (Aabsolute);

TMPPOS: = Ähnlichkeit (Aabsolute, Acurrent);

Löschen (Aoldfile, 1, tmppos - 1);

Löschen (acurrent, 1, tmppos - 1);

für i: = 0, um gotarnum (acurrent, '/') -1 zu machen

Beginnen

tmpsimaLarString: = tmpsimaLarstring + '../';

Ende;

Ergebnis: = tmpsimilarString + aoldfile;

Ende;

Klassenfunktion tstring.relatetoabSolute (Arate, Acurrent: String): String;

var

tmpsimaLilarstring: String;

TMPROOTCOUNT: Ganzzahl;

I: Ganzzahl;

Beginnen

Wenn Länge (Arelate)> 2 dann

Beginnen

Wenn Arelate [2] = ':' Dann

Beginnen

Ergebnis: = Arelate;

Ausfahrt;

Ende;

tmpsimaLilarstring: = '';

TMPROOTCOUNT: = 0;

Während wahr

Beginnen

Wenn link (Arelate, 3) = '../' dann

Beginnen

Inc (TMPROOTCOUNT);

Löschen (Arelate, 1, 3);

Ende

anders

brechen;

Ende;

tmpsimaLilarstring: = ReverSeScring (ExtractFilepath (Acurrent));

für i: = 0 bis tmproootcount tun

Beginnen

Löschen (tmpsimilarString, 1, pos ('/', tmpsimailarstring));

Ende;

Ergebnis: = ReverSeScring (tmpsimailarstring) + Arelat;

Ende;

Klassenfunktion Tstring.SIMilarPosition (Aone, Atwo: String): Integer;

var

I: Ganzzahl;

Max: Ganzzahl;

Beginnen

Wenn Länge (aOne) <Länge (ATWO) dann

Max: = Länge (aone)

anders

Max: = länge (atwo);

für i: = 1 bis maxe tun

Beginnen

Wenn aone [i] <> atwo [i] dann

Brechen;

Ende;

Ergebnisse: = i;

Ende;

Klassenfunktion tstring.getarnum (Astring: String; Achar: char): Integer;

var

I: Ganzzahl;

Beginnen

Ergebnisse: = 0;

für i: = 1 bis länge (adstring) tun

Beginnen

Wenn adstring [i] = achar dann

Inc (Ergebnis);

Ende;

Klassenprozedur tstring.getAllwordWithall (Avalue, ASeparator: String;

Astringliste: TStrings);

var

TMPI: Ganzzahl;

TMPPOS: Ganzzahl;

Beginnen

Wenn adstringlist = nil dann

Astringlist: = tstringlist.create;

tmppos: = 0;

während Länge (Avalue)> 0 tun

Beginnen

Für TMPI: = 1 bis Länge (Avalue) tun

Beginnen

tmppos: = pos (avalue [tmppos], Aseparator);

Wenn tmppos> 0 dann

Beginnen

Astringlist.add (kopieren (avalue, 1, tmppos - 1));

Astringlist.add (kopieren (avalue, tmppos, 1));

Löschen (avalue, 1, tmppos);

Brechen;

Ende

Ende;

Klassenfunktion tstring.tolowerCase (Astring: String): String;

Beginnen

Ergebnis: = Kleinbuchstaben (Astring);

Ende;

Klassenfunktion tstring.toUppercase (Astring: String): String;

Beginnen

Ergebnis: = Großbuchstaben (Astring);

Ende;

Klassenfunktion Tstring.Indexof (Astring, Asubstring: String): Integer;

Beginnen

Ergebnis: = pos (Asubstring, Adstring);

Ende;

Klassenfunktion Tstring.zerotoint (Astring: String): Integer;

Beginnen

Wenn Trim (adstring) = '' dann

Astring: = '0';

Ergebnis: = Strtoint (Astring);

Ende;

Klassenfunktion Tstring.zerotofLoat (Astring: String): doppelt;

Beginnen

Wenn Trim (adstring) = '' dann

Astring: = '0,0';

Ergebnis: = Strtofloat (Astring);

Ende;

Klassenfunktion tstring.sameText (Astring, Astring1: String): boolean;

Beginnen

Ergebnis: = sysutils.sametext (adstring, adstring1);

Ende;

Klassenfunktion Tstring.Reverse (Astring: String): String;

Beginnen

Ergebnis: = ReverSeScring (Astring);

Ende;

Klassenfunktion tstring.isvalidip (const s: String): boolean;

var

J, I: Ganzzahl;

LTMP: String;

Beginnen

Ergebnis: = wahr;

LTMP: = Trim (s);

Für i: = 1 bis 4 beginnen

J: = strtointdef (fetch (ltmp, '.'), -1);

Ergebnis: = Ergebnis und (j> -1) und (j <256);

Wenn nicht Ergebnisse, beginnen Sie dann

Brechen;

Ende;

Klassenfunktion tstring.zerotostr (Astring: String): String;

Beginnen

Wenn Trim (adstring) = '' dann

Ergebnis: = '0'

anders

Ergebnis: = Astring;

Ende;

Klassenfunktion Tstring.FillString (Achar: char; Alength: Ganzzahl): String;

var

I: Ganzzahl;

Beginnen

Ergebnisse: = '';

für i: = 1 zu länger do // iterate

Beginnen

Ergebnis: = Ergebnis + Achar;

Ende;

Klassenfunktion tstring.stuffstring (const Atext: String; Astart,

Alänge: Cardinal;

Beginnen

Ergebnis: = Strutils.stuffstring (Atetext, Astart, Alänge, Asubtext);

Ende;

Klassenfunktion tstring.getNextString (var Sourcestring: String;

Asplitchar: String): String;

var

TMPPOS: Ganzzahl;

Beginnen

TMPPOS: = POS (Asplitchar, Sourcestring);

Wenn tmppos = 0 dann

Beginnen

Ergebnis: = Sourcestring;

Sourcestring: = ''

Ende

anders

Beginnen

Ergebnis: = tstring.left (Sourcestring, tmppos -1);

Löschen (Sourcestring, 1, tmppos);

Ende;

{Tintenger}

Klassenfunktion Tinteger.inttoStr (Unleider: Integer): String;

Beginnen

Ergebnis: = sysutils.inttostr (terteger);

Ende;

Klassenfunktion Tinteger

Beginnen

Ergebnis: = Ainteger;

Ende;

Klassenfunktion Tinteger.inttoStr (Unleider: int64): String;

Beginnen

Ergebnis: = sysutils.inttostr (terteger);

Ende;

Klassenfunktion Tinteger.isvalidint (Astring: String): boolean;

Beginnen

Ergebnis: = wahr;

versuchen

Strtoint (Astring);

außer

Ergebnis: = falsch;

Ende;

Klassenfunktion Tinteger.isvalidint64 (Astring: String): boolean;

Beginnen

Ergebnis: = wahr;

versuchen

Strtoint (Astring);

außer

Ergebnis: = falsch;

Ende;

Klassenfunktion Tinteger.maxint: Ganzzahl;

Beginnen

Ergebnis: = System.Maxint;

Ende;

Klassenfunktion Tinteger.maxLongint: Integer;

Beginnen

Ergebnis: = system.maxlongint;

Ende;

Klassenfunktion Tinteger

var

I: Ganzzahl;

Beginnen

SetLength (Ergebnis, 32);

für i: = 1 bis 32 tun

Beginnen

if ((Achtel SHL (I-1)) SHR 31) = 0 dann

Ergebnis [i]: = '0'

anders

Ergebnis [i]: = '1';

Ende;

Klassenfunktion Tinteger

Beginnen

Ergebnis: = sysutils.inttohex (Assinger, 0);

Ende;

Klassenfunktion Tinteger.Hextoint (Astring: String): Integer;

Beginnen

Wenn tstring.left (adstring, 1) = '$' dann

Ergebnis: = Strtoint (Astring)

anders

Ergebnis: = strtoint ('$' + adstring);

Ende;

Klassenfunktion Tinteger

var

tmpstr: String;

I: Ganzzahl;

Beginnen

tmpstr: = '';

für i: = 0 bis hin zu adigit - 1 do // iterate

Beginnen

tmpstr: = tmpstr + '0';

Ende;

Ergebnis: = formatfloat (tmpstr, ackeger);

Ende;

{Tfloat}

Klassenfunktion tfloat.floattomoney (const value: double; rund: boolean): string;

Beginnen

// Der Betrag ist standardmäßig abgerundet

Ende;

Klassenfunktion tfloat.isvalidfloat (Astring: String): boolean;

Beginnen

Ergebnis: = wahr;

versuchen

Strtofloat (Adstring);

außer

Ergebnis: = falsch;

Ende;

Klassenfunktion tfloat.maxDouble: Double;

Beginnen

Ergebnis: = 1,7E+308;

Ende;

Klassenfunktion tfloat.maxextended: erweitert;

Beginnen

Ergebnis: = 1,1E+4932;

Ende;

Klassenfunktion tfloat.mindouble: double;

Beginnen

Ergebnis: = 5.0E-324;

Ende;

Klassenfunktion tfloat.Minextended: erweitert;

Beginnen

Ergebnisse: = 3,4e-4932;

Ende;

Klassenfunktion tfloat.SameValue (const a, b: Single;

Epsilon: Single): boolean;

Beginnen

Ergebnis: = math.SameValue (a, b, Epsilon);

Ende;

Klassenfunktion tfloat.SameValue (const a, b: double;

Epsilon: doppelt): boolean;

Beginnen

Ergebnis: = math.SameValue (a, b, Epsilon);

Ende;

Klassenfunktion tfloat.SameValue (const a, b: erweitert;

Epsilon: erweitert): Boolean;

Beginnen

Ergebnis: = math.SameValue (a, b, Epsilon);

Ende;

{Tboolean}

Klassenfunktion TBOOLEAN.BOOLTOSTR (ABEROLEAN: BOOLEAN): STING;

Beginnen

Wenn Aboolean dann

Ergebnis: = 'true'

anders

Ergebnis: = 'Falsch';

Ende;

Klassenfunktion TBOOLEAN.StrTOBOOL (Astring: String): boolean;

Beginnen

Wenn Großbuchstaben (adstring) = 'true' dann

Ergebnis: = wahr

anders

Ergebnis: = falsch;

Ende;

Ende.