// 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;
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;
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;
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;
Ende;
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;
Ende;
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;
Ende;
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;
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;
Ende;
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;
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;
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;
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;
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;
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;
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;
Ende;
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;
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;
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;
Ende;
Klassenfunktion Tinteger.isvalidint64 (Astring: String): boolean;
Beginnen
Ergebnis: = wahr;
versuchen
Strtoint (Astring);
außer
Ergebnis: = falsch;
Ende;
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;
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;
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.