//People who are used to java or C# may be very angry with DELPHI and do not even have basic types. In my daily work, I often try to gather some functions together and often make some functions of my own basic types. , Make them out here. If there is any inappropriateness, please comment.
unit BaseClass;
interface
uses
SysUtils, Classes, StrUtils, IdGlobal, Math;
type
TCharSet = set of char;
var
TNormalCharSet: TCharSet = [#13, #10, #32, '.', ',', ';'];
type
TString = class
PRivate
FText: string;
public
function CharAt(APosition: Integer): Char;
//The letters of the specified position
function toLowerCase: string; overload;
class function toLowerCase(AString: string): string; overload;
//lower case
function toUpperCase: string; overload;
class function toUpperCase(AString: string): string; overload;
//capital
class function ValueOf(AValue: string): Boolean; overload;
class function ValueOf(AValue: Boolean): string; overload;
class function StringIn(AValue: string; AValues: array of string): Boolean;
class function Left(AValue: string; ALength: Integer): string;
class function Right(AValue: string; ALength: Integer): string;
class function DeletePrefix(AValue: string; FixedString: TCharSet = [#32]): string; //Delete the prefix
class function DeleteSuffix(AValue: string; FixedString: TCharSet = [#32]): string; //Delete the suffix
//
class function CompareString(AValue1: string; AValue2: string): Boolean;
class function HashCode(AValue: string): Integer;
class function LastChar(AValue: string): Char;
class function StringReplace(const S, OldPattern, NewPattern: string;
Flags: TReplaceFlags): string;
class function StringOfChar(Ch: Char; Count: Integer): string;
class function SetString(var s: string; buffer: PChar; len: Integer): string;
class function GetPy(AStr: string): string;
//Get the corresponding pinyin.
class function IsAllChinese(AStr: string): Boolean;
class function IsAllEnglish(AStr: string): Boolean;
class function GetFirstWord(AValue: string; var AWord: string; ASeparator: TCharSet): Integer; overload;
class function GetFirstWord(AValue: string; var AWord: string; ASeparator: string): Integer; overload;
//The return value is the length from the beginning to the document.
class function GetAllWord(AValue: string; ASeparator: string): TStringList; overload;
//Return all keywords. After using it, please free the result set;
//Note: Please do not use this function in future use. Please use its reloaded version
//GetAllWord(AValue: string; ASeparator: string; AStringList: TStringList);
class procedure GetAllWord(AValue: string; ASeparator: string; AStringList: TStrings); overload;
//Load all result sets into AStringList;
class procedure GetAllWordWithAll(AValue: string; ASeparator: string; AStringList: TStrings);
class function StringToCharSet(AValue: string): TCharSet;
class function CharSetToString(AValue: TCharSet): string;
class function UpdateSentence(AOldString: string; // The string being operated
AUpdateSource: string; //The word found.
AUpdateString: string; //Replaced document.
ASentenceSeparator: string; //Sentence separator.
AWordSeparator: string //Document separator;
): string; //Return result.
//For example, the return value of 'dbarcode ASC, dname DESC', 'dbarcode', '', ',', ' ' is
//' dname DESC';
class function DeleteRepeat(AOldString: string; //To handle characters
ADeleteString: Char; //The character to be deleted
ARepeat: Char): string; //Repeat characters
class function IfThen(AExpression: Boolean; ATrue: string; AFalse: string): string;
//Return the corresponding string according to the value of the expression.
class function AbsoluteToRelate(AAbsolute: string; ACurrent: string): string;
//Given two files, convert the absolute path to the relative path.
class function RelateToAbsolute(ARate: string; ACurrent: string): string;
class function SimilarPosition(AOne, ATwo: string): Integer;
class function GetCharNum(AString: string; AChar: Char): Integer;
class function IndexOf(AString, ASubString: string): Integer;
class function ZeroToInt(AString: string): Integer;
class function ZeroToFloat(AString: string): Double;
class function ZeroToStr(AString: string): string;
class function SameText(AString, AString1: string): Boolean;
class function Reverse(AString: string): string;
class function IsValidip(const S: String): Boolean;
class function FillString(AChar: Char; ALength: Integer): string;
class function StuffString(const AText: string; AStart, ALength: Cardinal;
const ASubText: string): string;
class function GetNextString(var SourceString: string; asplitChar: string): string;
end;
//Integer type.
TInteger = class
class function IntToStr(AInteger: Integer): string; overload;
class function IntToStr(AInteger: Int64): string; overload;
class function IsValidInt(AString: string): Boolean;
class function IsValidInt64(AString: string): Boolean;
class function MaxInt: Integer;
class function MaxLongInt: Integer;
class function HashCode(AInteger: Integer): Integer;
class function IntToBin(AInteger: Cardinal): string;
class function IntToHex(AInteger: Integer): string;
class function HexToInt(AString: string): Integer;
class function MakeSerialNo(AInteger: Integer; ADigit: Integer): string;
end;
TFloat = class
class function IsValidFloat(AString: string): Boolean;
class function MaxDouble: Double;
class function MinDouble: Double;
class function MaxExtended: Extended;
class function MinExtended: Extended;
class function SameValue(const A, B: Single; Epsilon: Single = 0): Boolean; overload;
class function SameValue(const A, B: Double; Epsilon: Double = 0): Boolean; overload;
class function SameValue(const A, B: Extended; Epsilon: Extended = 0): Boolean; overload;
class function FloatToMoney(const Value: Double; Round: Boolean = True): string;
end;
TBoolean = class
class function BoolToStr(ABoolean: Boolean): string;
class function StrToBool(AString: string): Boolean; //If not 'true', false;
end;
Implementation
{ TString }
function GetPYIndexChar(AChar: string): Char;
Begin
case WORD(AChar[1]) shl 8 + WORD(AChar[2]) of
$B0A1..$B0C4: Result := 'A';
$B0C5..$B2C0: Result := 'B';
$B2C1..$B4ED: Result := 'C';
$B4EE..$B6E9: Result := 'D';
$B6EA..$B7A1: Result := 'E';
$B7A2..$B8C0: Result := 'F';
$B8C1..$B9FD: Result := 'G';
$B9FE..$BBF6: Result := 'H';
$BBF7..$BFA5: Result := 'J';
$BFA6..$C0AB: Result := 'K';
$C0AC..$C2E7: Result := 'L';
$C2E8..$C4C2: Result := 'M';
$C4C3..$C5B5: Result := 'N';
$C5B6..$C5BD: Result := 'O';
$C5BE..$C6D9: Result := 'P';
$C6DA..$C8BA: Result := 'Q';
$C8BB..$C8F5: Result := 'R';
$C8F6..$CBF9: Result := 'S';
$CBFA..$CDD9: Result := 'T';
$CDDA..$CEF3: Result := 'W';
$CEF4..$D188: Result := 'X';
$D1B9..$D4D0: Result := 'Y';
$D4D1..$D7F9: Result := 'Z';
else
Result := Char(0);
end;
end;
class function TString.GetPy(AStr: string): string;
var
I: Integer;
Begin
Results := '';
for I := 1 to Length(AStr) do
Begin
if ByteType(AStr, i) = mbTrailByte then
Result := Result + GetPYIndexChar(AStr[i - 1] + AStr[i])
else
if ByteType(AStr, i) = mbSingleByte then
Result := Result + AStr[i];
end;
end;
function TString.CharAt(APosition: Integer): Char;
Begin
Result := FText[APosition];
end;
class function TString.CharSetToString(AValue: TCharSet): string;
Begin
end;
class function TString.CompareString(AValue1, AValue2: string): Boolean;
Begin
Result := UpperCase(AValue1) = UpperCase(AValue2);
end;
class function TString.DeletePrefix(AValue: string;
FixedString: TCharSet): string;
Begin
while System.Length(AValue) > 0 do
Begin
if AValue[1] in FixedString then
Delete(AValue, 1, 1)
else
Break;
end;
Result := AValue;
end;
class function TString.GetFirstWord(AValue: string; var AWord: string; ASeparator: TCharSet
): Integer;
var
tmpStr: string;
tmpPos: Integer;
Begin
tmpStr := DeleteSuffix(AValue, ASeparator);
tmpStr := DeletePrefix(AValue, ASeparator);
Result := Length(AValue) - Length(tmpStr);
{ if Length(tmpStr) = 0 then Exit;
if (tmpStr[1] = '''') and (tmpStr[2] = '''')then
Begin
for tmpPos := 3 to Length(tmpStr) do
Begin
if tmpStr[tmpPos] in [''''] then
Break;
end;
end;
if tmpPos > 3 then tmpPos :=tmpPos + 2;
}
for tmpPos := 1 to Length(tmpStr) do
Begin
if tmpStr[tmpPos] in ASeparator then
Break;
end;
tmpPos := tmpPos -1;
// {TODO: -oghs Fixed the last parameter parsing incorrectly}
if (tmpPos = 0) and (AValue <> '') then
tmpPos := Length(AValue);
AWord := Copy(AValue, Result + 1, tmpPos);
Result := Result + tmpPos;
end;
class function TString.HashCode(AValue: string): Integer;
var
i: Integer;
tmpValue: Integer;
Begin
tmpValue := 0;
for I := 1 to System.Length(AValue) do
Begin
tmpValue := 3 * tmpValue + Ord(AValue[I]);
end;
Result := tmpValue;
end;
class function TString.IsAllChinese(ASt: string): Boolean;
var
I: Integer;
Begin
Result := True;
for I := 1 to Length(AStr) do
Begin
if ByteType(AStr, I) = mbSingleByte then
Begin
Result := False;
Break;
end;
end;
end;
class function TString.IsAllEnglish(AStr: string): Boolean;
var
I: Integer;
Begin
Result := True;
for I := 1 to Length(AStr) do
Begin
if ByteType(AStr, I) <> mbSingleByte then
Begin
Result := False;
Break;
end;
end;
end;
class function TString.LastChar(AValue: string): Char;
Begin
Result := AValue[System.Length(AValue)];
end;
class function TString.Left(AValue: string; ALength: Integer): string;
Begin
Result := Copy(AValue, 1, ALength);
end;
class function TString.Right(AValue: string; ALength: Integer): string;
Begin
Result := StrUtils.RightStr(AValue, ALength);
end;
class function TString.SetString(var s: string; buffer: PChar;
len: Integer): string;
Begin
System.SetString(s, buffer, len);
Results := s;
end;
class function TString.StringIn(AValue: string;
AValues: array of string): Boolean;
var
I: Integer;
Begin
Result := False;
for I := Low(AValues) to High(AValues) do
Begin
if UpperCase(AValue) = UpperCase(AValues[I]) then
Begin
Result := True;
Break;
end;
end;
end;
class function TString.StringOfChar(Ch: Char; Count: Integer): string;
Begin
Result := System.StringOfChar(Ch, Count);
end;
class function TString.StringReplace(const S, OldPattern,
NewPattern: string; Flags: TReplaceFlags): string;
Begin
Result := Sysutils.StringReplace(S, OldPattern, NewPattern, Flags);
end;
class function TString.StringToCharSet(AValue: string): TCharSet;
var
I: Integer;
Begin
Results := [];
for I := 1 to Length(AValue) do
Begin
Result := Result + [AValue[I]];
end;
end;
function TString.toLowerCase: string;
Begin
Result := LowerCase(FText);
end;
function TString.toUpperCase: string;
Begin
Result := Uppercase(FText);
end;
class function TString.ValueOf(AValue: Boolean): string;
Begin
if AValue then
Result := 'Yes'
else
Result := 'No';
end;
class function TString.ValueOf(AValue: string): Boolean;
Begin
Result := StringIn(AValue, ['Yes', 'yes', 'ok']);
end;
class function TString.GetFirstWord(AValue: string; var AWord: string;
ASeparator: string): Integer;
Begin
Result := GetFirstWord(AValue, AWord, StringToCharSet(ASeparator));
end;
class function TString.GetAllWord(AValue, ASeparator: string): TStringList;
var
tmpList: TStringList;
tmpWord: string;
Begin
tmpList := TStringList.Create;
while Length(AValue) > 0 do
Begin
tmpWord := '';
Delete(AValue, 1, GetFirstWord(AValue, tmpWord, ASeparator));
if tmpWord <> '' then
tmpList.Add(tmpWord)
else
Break;
end;
Result := tmpList;
end;
class function TString.UpdateSentence(AOldString, AUpdateSource,
AUpdateString, ASentenceSeparator, AWordSeparator: string): string;
var
tmpSentence: string;
tmpWord: string;
tmpWord1: string;
i: Integer;
tmpResult: string;
Begin
//Get the first sentence
tmpSentence := AOldString;
tmpResult := '';
while Length(tmpSentence) > 0 do
Begin
i := GetFirstWord(tmpSentence, tmpWord, ASentenceSeparator);
tmpResult := tmpResult + Left(tmpSentence, i - Length(tmpWord));
Delete(tmpSentence, 1, I);
if tmpWord <> '' then
Begin
i := GetFirstWord(tmpWord, tmpWord1, AWordSeparator);
tmpResult := tmpResult + Left(tmpWord, i - Length(tmpWord1));
if CompareString(tmpWord1, AUpdateSource) then
Begin
tmpResult := tmpResult + AUpdateString;
end
else
Begin
tmpResult := tmpResult + tmpWord;
end;
end;
end;
tmpResult := DeletePrefix(tmpResult, [' ', ',']);
tmpResult := DeleteSuffix(tmpResult, [' ', ',']);
tmpResult := DeleteRepeat(tmpResult, ',', ' ');
tmpResult := DeleteRepeat(tmpResult, ' ', ' ');
Result := tmpResult;
end;
class function TString.DeleteRepeat(AOldString: string; ADeleteString,
ARepeat: Char): string;
var
I: Integer;
tmpfind1: Boolean;
Begin
tmpfind1 := False;
for I := Length(AOldString) downto 1 do
Begin
if tmpfind1 then
Begin
if AOldString[I] = ADeleteString then
Delete(AOldString, I, 1)
else
Begin
if AOldString[I] = ARepeat then
Continue;
tmpfind1 := AOldString[I] = ADeleteString;
end;
end
else
Begin
if ADeleteString <> ARepeat then
if AOldString[I] = ARepeat then
Continue;
tmpfind1 := AOldString[I] = ADeleteString
end;
end;
Result := AOldString;
end;
class function TString.DeleteSuffix(AValue: string;
FixedString: TCharSet): string;
Begin
while System.Length(AValue) > 0 do
Begin
if AValue[System.Length(AValue)] in FixedString then
Delete(AValue, System.Length(AValue), 1)
else
Break;
end;
Result := AValue;
end;
class procedure TString.GetAllWord(AValue, ASeparator: string;
AStringList: TStrings);
var
tmpWord: string;
Begin
if AStringList = nil then
AStringList := TStringList.Create;
while Length(AValue) > 0 do
Begin
tmpWord := '';
Delete(AValue, 1, GetFirstWord(AValue, tmpWord, ASeparator));
if tmpWord <> '' then
AStringList.Add(tmpWord)
else
Break;
end;
end;
class function TString.IfThen(AExpression: Boolean; ATrue,
AFalse: string): string;
Begin
if AExpression then
Result := ATrue
else
Result := AFalse;
end;
class function TString.AbsoluteToRelate(AAbsolute,
ACurrent: string): string;
var
tmpSimilarString: string;
AOldFile: string;
i: Integer;
tmpPos: Integer;
Begin
// After conversion, it forms.../../a.ini;
//If it is not on the same drive, it will directly return to the absolute path.
if ExtractFileDrive(AAbsolute) <> ExtractFileDrive(ACurrent) then
Result := AAbsolute
else
Begin
tmpSimilarString := '';
AOldFile := AAbsolute;
AAbsolute := ExtractFilePath(AAbsolute);
tmpPos := SimilarPosition(AAbsolute, ACurrent);
Delete(AOldFile, 1, tmpPos - 1);
Delete(ACurrent, 1, tmpPos - 1);
for i := 0 to GetCharNum(ACurrent, '/') -1 do
Begin
tmpSimilarString := tmpSimilarString + '../';
end;
Result := tmpSimilarString + AOldFile;
end;
end;
class function TString.RelateToAbsolute(ARate, ACurrent: string): string;
var
tmpSimilarString: string;
tmpRootCount: Integer;
i: Integer;
Begin
if Length(ARelate) > 2 then
Begin
if ARelate[2] = ':' then
Begin
Result := ARelate;
Exit;
end;
end;
tmpSimilarString := '';
tmpRootCount := 0;
While True do
Begin
if LeftStr(ARelate, 3) = '../' then
Begin
Inc(tmpRootCount);
Delete(ARelate, 1, 3);
end
else
break;
end;
tmpSimilarString := ReverseString(ExtractFilePath(ACurrent));
for i := 0 to tmpRootCount do
Begin
Delete(tmpSimilarString, 1, Pos('/', tmpSimilarString));
end;
Result := ReverseString(tmpSimilarString) + ARelate;
end;
class function TString.SimilarPosition(AOne, ATwo: string): Integer;
var
i: Integer;
Max: Integer;
Begin
if Length(AOne) < Length(ATwo) then
Max := Length(AOne)
else
Max := Length(ATwo);
for i := 1 to Max do
Begin
if AOne[i] <> ATwo[i] then
Break;
end;
Results := i;
end;
class function TString.GetCharNum(AString: string; AChar: Char): Integer;
var
i: Integer;
Begin
Results := 0;
for i := 1 to Length(AString) do
Begin
if AString[i] = AChar then
Inc(Result);
end;
end;
class procedure TString.GetAllWordWithAll(AValue, ASeparator: string;
AStringList: TStrings);
var
tmpI: Integer;
tmpPos: Integer;
Begin
if AStringList = nil then
AStringList := TStringList.Create;
tmpPos := 0;
while Length(AValue) > 0 do
Begin
for tmpI := 1 to Length(AValue) do
Begin
tmpPos := Pos(AValue[tmpPos], ASeparator);
if tmpPos > 0 then
Begin
AStringList.Add(Copy(AValue, 1, tmpPos - 1));
AStringList.Add(Copy(AValue, tmpPos, 1));
Delete(AValue, 1, tmpPos);
Break;
end
end;
end; // while
end;
class function TString.toLowerCase(AString: string): string;
Begin
Result := LowerCase(AString);
end;
class function TString.toUpperCase(AString: string): string;
Begin
Result := Uppercase(AString);
end;
class function TString.IndexOf(AString, ASubString: string): Integer;
Begin
Result := Pos(ASubstring, AString);
end;
class function TString.ZeroToInt(AString: string): Integer;
Begin
if Trim(AString) = '' then
AString := '0';
Result := StrToInt(AString);
end;
class function TString.ZeroToFloat(AString: string): Double;
Begin
if Trim(AString) = '' then
AString := '0.0';
Result := StrToFloat(AString);
end;
class function TString.SameText(AString, AString1: string): Boolean;
Begin
Result := SysUtils.SameText(AString, AString1);
end;
class function TString.Reverse(AString: string): string;
Begin
Result := ReverseString(AString);
end;
class function TString.IsValidIP(const S: String): Boolean;
var
j, i: Integer;
LTmp: String;
Begin
Result := True;
LTmp := Trim(S);
for i := 1 to 4 do begin
j := StrToIntDef(Fetch(LTmp, '.'), -1);
Result := Result and (j > -1) and (j < 256);
If NOT Results then begin
Break;
end;
end;
end;
class function TString.ZeroToStr(AString: string): string;
Begin
if Trim(AString) = '' then
Result := '0'
else
Result := AString;
end;
class function TString.FillString(AChar: Char; ALength: Integer): string;
var
i: Integer;
Begin
Results := '';
for I := 1 to ALength do // Iterate
Begin
Result := Result + AChar;
end; // for
end;
class function TString.StuffString(const AText: string; AStart,
ALength: Cardinal; const ASubText: string): string;
Begin
Result := StrUtils.StuffString(AText, AStart, ALength, ASubText);
end;
class function TString.GetNextString(var SourceString: string;
ASplitChar: string): string;
var
tmpPos: Integer;
Begin
tmpPos := Pos(ASplitChar, SourceString);
if tmpPos = 0 then
Begin
Result := SourceString;
SourceString := ''
end
else
Begin
Result := TString.Left(SourceString, tmpPos -1);
Delete(SourceString, 1, tmpPos);
end;
end;
{ TInteger }
class function TInteger.IntToStr(AInteger: Integer): string;
Begin
Result := Sysutils.IntToStr(AInteger);
end;
class function TInteger.HashCode(AInteger: Integer): Integer;
Begin
Result := AInteger;
end;
class function TInteger.IntToStr(AInteger: Int64): string;
Begin
Result := Sysutils.IntToStr(AInteger);
end;
class function TInteger.IsValidInt(AString: string): Boolean;
Begin
Result := True;
try
StrToInt(AString);
except
Result := False;
end;
end;
class function TInteger.IsValidInt64(AString: string): Boolean;
Begin
Result := True;
try
StrToInt(AString);
except
Result := False;
end;
end;
class function TInteger.MaxInt: Integer;
Begin
Result := System.MaxInt;
end;
class function TInteger.MaxLongInt: Integer;
Begin
Result := System.MaxLongint;
end;
class function TInteger.IntToBin(AInteger: Cardinal): string;
var
i: Integer;
Begin
SetLength(Result, 32);
for i := 1 to 32 do
Begin
if ((AInteger shl (i-1)) shr 31) = 0 then
Result[i] := '0'
else
Result[i] := '1';
end;
end;
class function TInteger.IntToHex(AInteger: Integer): string;
Begin
Result := SysUtils.IntToHex(AInteger, 0);
end;
class function TInteger.HexToInt(AString: string): Integer;
Begin
if TString.Left(AString, 1) = '$' then
Result := StrToInt(AString)
else
Result := StrToInt('$' + AString);
end;
class function TInteger.MakeSerialNo(AInteger, ADigit: Integer): string;
var
tmpStr: string;
i: Integer;
Begin
tmpStr := '';
for I := 0 to ADigit - 1 do // Iterate
Begin
tmpStr := tmpStr + '0';
end; // for
Result := FormatFloat(tmpStr, AInteger);
end;
{ TFloat }
class function TFloat.FloatToMoney(const Value: Double; Round: Boolean): string;
Begin
//The amount is rounded by default
end;
class function TFloat.IsValidFloat(AString: string): Boolean;
Begin
Result := True;
try
StrToFloat(AString);
except
Result := False;
end;
end;
class function TFloat.MaxDouble: Double;
Begin
Result := 1.7e+308;
end;
class function TFloat.MaxExtended: Extended;
Begin
Result := 1.1e+4932;
end;
class function TFloat.MinDouble: Double;
Begin
Result := 5.0e-324;
end;
class function TFloat.MinExtended: Extended;
Begin
Results := 3.4e-4932;
end;
class function TFloat.SameValue(const A, B: Single;
Epsilon: Single): Boolean;
Begin
Result := Math.SameValue(A, B, Epsilon);
end;
class function TFloat.SameValue(const A, B: Double;
Epsilon: Double): Boolean;
Begin
Result := Math.SameValue(A, B, Epsilon);
end;
class function TFloat.SameValue(const A, B: Extended;
Epsilon: Extended): Boolean;
Begin
Result := Math.SameValue(A, B, Epsilon);
end;
{ TBoolean }
class function TBoolean.BoolToStr(ABoolean: Boolean): string;
Begin
if ABoolean then
Result := 'True'
else
Result := 'False';
end;
class function TBoolean.StrToBool(AString: string): Boolean;
Begin
if UpperCase(AString) = 'TRUE' then
Result := True
else
Result := False;
end;
end.