paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-07-09 17:16:00 +02:00
Code Issues Packages Projects Releases Wiki Activity
d23fa5a87f
fpc/rtl/objpas/sysutils/syshelph.inc
Michael VAN CANNEYT 4336599c3a * Char -> AnsiChar
2023-07-14 17:26:10 +02:00

1229 lines
64 KiB
PHP
Raw Blame History

{%mainunit syshelpers.pp}
Type
TStringArray = Array of string;
TCharArray = Array of AnsiChar;
TEndian = ObjPas.TEndian;
TByteBitIndex = 0..7;
TShortIntBitIndex = 0..7;
TWordBitIndex = 0..15;
TSmallIntBitIndex = 0..15;
TCardinalBitIndex = 0..31;
{$if sizeof(Integer)=2}
TIntegerBitIndex = 0..15;
{$elseif sizeof(Integer)=4}
TIntegerBitIndex = 0..31;
{$else}
{$fatal Unsupported Integer type size}
{$endif}
TLongIntBitIndex = 0..31;
TQwordBitIndex = 0..63;
TInt64BitIndex = 0..63;
{$IFDEF cpu16}
TNativeUIntBitIndex = TWordBitIndex;
TNativeIntBitIndex = TSmallIntBitIndex;
{$ENDIF}
{$IFDEF cpu32}
TNativeUIntBitIndex = TCardinalBitIndex;
TNativeIntBitIndex = TIntegerBitIndex;
{$ENDIF}
{$IFDEF cpu64}
TNativeUIntBitIndex = TQWordBitIndex;
TNativeIntBitIndex = TInt64BitIndex;
{$ENDIF}
Const
CPUEndian = {$IFDEF FPC_LITTLE_ENDIAN}TEndian.Little{$ELSE}TEndian.Big{$ENDIF};
Type
TGuidHelper = record helper for TGUID
Class function Create(const Data; BigEndian: Boolean): TGUID; overload; static;
class function Create(const Data: array of Byte; AStartIndex: Cardinal; BigEndian: Boolean): TGUID; overload; static;
Class Function Create(const Data; DataEndian: TEndian = CPUEndian): TGUID; overload; static; inline;
Class Function Create(const B: TBytes; DataEndian: TEndian = CPUEndian): TGUID; overload; static; inline;
Class Function Create(const B: TBytes; AStartIndex: Cardinal; DataEndian: TEndian = CPUEndian): TGUID; overload; static;
Class Function Create(const S: string): TGUID; overload; static;
Class Function Create(A: Integer; B: SmallInt; C: SmallInt; const D: TBytes): TGUID; overload; static;
Class Function Create(A: Integer; B: SmallInt; C: SmallInt; D, E, F, G, H, I, J, K: Byte): TGUID; overload; static;
Class Function Create(A: Cardinal; B: Word; C: Word; D, E, F, G, H, I, J, K: Byte): TGUID; overload; static;
Class Function NewGuid: TGUID; static;
Function ToByteArray(DataEndian: TEndian = CPUEndian): TBytes;
Function ToString(SkipBrackets: Boolean = False): string;
end;
TCompareOption = system.TCompareOption;
TCompareOptions = system.TCompareOptions;
{$SCOPEDENUMS ON}
TStringSplitOptions = (None, ExcludeEmpty, ExcludeLastEmpty);
{$SCOPEDENUMS OFF}
{ TStringHelper }
TStringHelper = Type Helper for AnsiString
Private
Function GetChar(AIndex : SizeInt) : AnsiChar;
Function GetLength : SizeInt;
public
const Empty = '';
// Methods
Class Function Compare(const A: string; const B: string): Integer; overload; static; //inline;
Class Function Compare(const A: string; const B: string; IgnoreCase: Boolean): Integer; overload; static; //inline; //deprecated 'Use same with TCompareOptions';
Class Function Compare(const A: string; const B: string; Options: TCompareOptions): Integer; overload; static; // inline;
Class Function Compare(const A: string; IndexA: SizeInt; const B: string; IndexB: SizeInt; ALen: SizeInt): Integer; overload; static; // inline;
Class Function Compare(const A: string; IndexA: SizeInt; const B: string; IndexB: SizeInt; ALen: SizeInt; IgnoreCase: Boolean): Integer; overload; static; // inline; //deprecated 'Use same with TCompareOptions';
Class Function Compare(const A: string; IndexA: SizeInt; const B: string; IndexB: SizeInt; ALen: SizeInt; Options: TCompareOptions): Integer; overload; static;// inline;
Class Function CompareOrdinal(const A: string; const B: string): Integer; overload; static;
Class Function CompareOrdinal(const A: string; IndexA: SizeInt; const B: string; IndexB: SizeInt; ALen: SizeInt): Integer; overload; static;
Class Function CompareText(const A: string; const B: string): Integer; static; inline;
Class Function Copy(const Str: string): string; inline; static;
Class Function Create(AChar: AnsiChar; ACount: SizeInt): string; overload; inline; static;
Class Function Create(const AValue: array of AnsiChar): string; overload; static;
Class Function Create(const AValue: array of AnsiChar; StartIndex: SizeInt; ALen: SizeInt): string; overload; static;
Class Function EndsText(const ASubText, AText: string): Boolean; static;
Class Function Equals(const a: string; const b: string): Boolean; overload; static;
Class Function Format(const AFormat: string; const args: array of const): string; overload; static;
Class Function IsNullOrEmpty(const AValue: string): Boolean; static;
Class Function IsNullOrWhiteSpace(const AValue: string): Boolean; static;
Class Function Join(const Separator: string; const Values: array of const): string; overload; static;
Class Function Join(const Separator: string; const Values: array of string): string; overload; static;
Class Function Join(const Separator: string; const Values: array of string; StartIndex: SizeInt; ACount: SizeInt): string; overload; static;
Class Function LowerCase(const S: string): string; overload; static; inline;
Class Function Parse(const AValue: Boolean): string; overload; static; inline;
Class Function Parse(const AValue: Extended): string; overload; static;inline;
Class Function Parse(const AValue: Int64): string; overload; static; inline;
Class Function Parse(const AValue: Integer): string; overload; static; inline;
Class Function ToBoolean(const S: string): Boolean; overload; static; inline;
Class Function ToDouble(const S: string): Double; overload; static; inline;
Class Function ToExtended(const S: string): Extended; overload; static; inline;
Class Function ToInt64(const S: string): Int64; overload; static; inline;
Class Function ToInteger(const S: string): Integer; overload; static; inline;
Class Function ToSingle(const S: string): Single; overload; static; inline;
Class Function UpperCase(const S: string): string; overload; static; inline;
Function CompareTo(const B: string): Integer;
Function Contains(const AValue: string; IgnoreCase: Boolean = False): Boolean;
procedure CopyTo(SourceIndex: SizeInt; var destination: array of AnsiChar; DestinationIndex: SizeInt; ACount: SizeInt);
Function CountChar(const C: AnsiChar): SizeInt;
Function DeQuotedString: string; overload;
Function DeQuotedString(const AQuoteChar: AnsiChar): string; overload;
Function EndsWith(const AValue: string): Boolean; overload; inline;
Function EndsWith(const AValue: string; IgnoreCase: Boolean): Boolean; overload;
Function Equals(const AValue: string; IgnoreCase: Boolean = False): Boolean; overload;
Function Format(const args: array of const): string; overload;
Function GetHashCode: Integer;
Function IndexOf(AValue: AnsiChar): SizeInt; overload; inline;
Function IndexOf(const AValue: string): SizeInt; overload; inline;
Function IndexOf(AValue: AnsiChar; StartIndex: SizeInt): SizeInt; overload;
Function IndexOf(const AValue: string; StartIndex: SizeInt): SizeInt; overload;
Function IndexOf(AValue: AnsiChar; StartIndex: SizeInt; ACount: SizeInt): SizeInt; overload;
Function IndexOf(const AValue: string; StartIndex: SizeInt; ACount: SizeInt): SizeInt; overload;
Function IndexOfUnQuoted(const AValue: string; StartQuote, EndQuote: AnsiChar; StartIndex: SizeInt = 0): SizeInt; overload;
Function IndexOfAny(const AnyOf: array of AnsiChar): SizeInt; overload;
Function IndexOfAny(const AnyOf: array of AnsiChar; StartIndex: SizeInt): SizeInt; overload;
Function IndexOfAny(const AnyOf: array of AnsiChar; StartIndex: SizeInt; ACount: SizeInt): SizeInt; overload;
Function IndexOfAny(const AnyOf: array of String): SizeInt; overload;
Function IndexOfAny(const AnyOf: array of String; StartIndex: SizeInt): SizeInt; overload;
Function IndexOfAny(const AnyOf: array of String; StartIndex: SizeInt; ACount: SizeInt): SizeInt; overload;
Function IndexOfAny(const AnyOf: array of String; StartIndex: SizeInt; ACount: SizeInt; Out AMatch : SizeInt): SizeInt; overload;
Function IndexOfAnyUnquoted(const AnyOf: array of AnsiChar; StartQuote, EndQuote: AnsiChar): SizeInt; overload;
Function IndexOfAnyUnquoted(const AnyOf: array of AnsiChar; StartQuote, EndQuote: AnsiChar; StartIndex: SizeInt): SizeInt; overload;
Function IndexOfAnyUnquoted(const AnyOf: array of AnsiChar; StartQuote, EndQuote: AnsiChar; StartIndex: SizeInt; ACount: SizeInt): SizeInt; overload;
function IndexOfAnyUnquoted(const AnyOf: array of string; StartQuote, EndQuote: AnsiChar; StartIndex: SizeInt; Out Matched: SizeInt): SizeInt; overload;
Function Insert(StartIndex: SizeInt; const AValue: string): string;
Function IsDelimiter(const Delimiters: string; Index: SizeInt): Boolean;
Function IsEmpty: Boolean;
Function LastDelimiter(const Delims: string): SizeInt;
Function LastIndexOf(AValue: AnsiChar): SizeInt; overload;
Function LastIndexOf(const AValue: string): SizeInt; overload;
Function LastIndexOf(AValue: AnsiChar; AStartIndex: SizeInt): SizeInt; overload;
Function LastIndexOf(const AValue: string; AStartIndex: SizeInt): SizeInt; overload;
Function LastIndexOf(AValue: AnsiChar; AStartIndex: SizeInt; ACount: SizeInt): SizeInt; overload;
Function LastIndexOf(const AValue: string; AStartIndex: SizeInt; ACount: SizeInt): SizeInt; overload;
Function LastIndexOfAny(const AnyOf: array of AnsiChar): SizeInt; overload;
Function LastIndexOfAny(const AnyOf: array of AnsiChar; AStartIndex: SizeInt): SizeInt; overload;
Function LastIndexOfAny(const AnyOf: array of AnsiChar; AStartIndex: SizeInt; ACount: SizeInt): SizeInt; overload;
Function PadLeft(ATotalWidth: SizeInt): string; overload; inline;
Function PadLeft(ATotalWidth: SizeInt; PaddingChar: AnsiChar): string; overload; inline;
Function PadRight(ATotalWidth: SizeInt): string; overload; inline;
Function PadRight(ATotalWidth: SizeInt; PaddingChar: AnsiChar): string; overload; inline;
Function QuotedString: string; overload;
Function QuotedString(const AQuoteChar: AnsiChar): string; overload;
Function Remove(StartIndex: SizeInt): string; overload; inline;
Function Remove(StartIndex: SizeInt; ACount: SizeInt): string; overload; inline;
Function Replace(OldChar: AnsiChar; NewChar: AnsiChar): string; overload;
Function Replace(OldChar: AnsiChar; NewChar: AnsiChar; ReplaceFlags: TReplaceFlags): string; overload;
Function Replace(const OldValue: string; const NewValue: string): string; overload;
Function Replace(const OldValue: string; const NewValue: string; ReplaceFlags: TReplaceFlags): string; overload;
Function Split(const Separators: array of AnsiChar): TStringArray; overload;
Function Split(const Separators: array of AnsiChar; ACount: SizeInt): TStringArray; overload;
Function Split(const Separators: array of AnsiChar; Options: TStringSplitOptions): TStringArray; overload;
Function Split(const Separators: array of AnsiChar; ACount: SizeInt; Options: TStringSplitOptions): TStringArray; overload;
Function Split(const Separators: array of string): TStringArray; overload;
Function Split(const Separators: array of string; ACount: SizeInt): TStringArray; overload;
Function Split(const Separators: array of string; Options: TStringSplitOptions): TStringArray; overload;
Function Split(const Separators: array of string; ACount: SizeInt; Options: TStringSplitOptions): TStringArray; overload;
Function Split(const Separators: array of AnsiChar; AQuote: AnsiChar): TStringArray; overload;
Function Split(const Separators: array of AnsiChar; AQuoteStart, AQuoteEnd: AnsiChar): TStringArray; overload;
Function Split(const Separators: array of AnsiChar; AQuoteStart, AQuoteEnd: AnsiChar; Options: TStringSplitOptions): TStringArray; overload;
Function Split(const Separators: array of AnsiChar; AQuoteStart, AQuoteEnd: AnsiChar; ACount: SizeInt): TStringArray; overload;
Function Split(const Separators: array of AnsiChar; AQuoteStart, AQuoteEnd: AnsiChar; ACount: SizeInt; Options: TStringSplitOptions): TStringArray; overload;
Function Split(const Separators: array of string; AQuote: AnsiChar): TStringArray; overload;
Function Split(const Separators: array of string; AQuoteStart, AQuoteEnd: AnsiChar): TStringArray; overload;
Function Split(const Separators: array of string; AQuoteStart, AQuoteEnd: AnsiChar; Options: TStringSplitOptions): TStringArray; overload;
Function Split(const Separators: array of string; AQuoteStart, AQuoteEnd: AnsiChar; ACount: SizeInt): TStringArray; overload;
Function Split(const Separators: array of string; AQuoteStart, AQuoteEnd: AnsiChar; ACount: SizeInt; Options: TStringSplitOptions): TStringArray; overload;
Function StartsWith(const AValue: string): Boolean; overload; inline;
Function StartsWith(const AValue: string; IgnoreCase: Boolean): Boolean; overload;
Function Substring(AStartIndex: SizeInt): string; overload;
Function Substring(AStartIndex: SizeInt; ALen: SizeInt): string; overload;
Function ToBoolean: Boolean; overload; inline;
Function ToInteger: Integer; overload; inline;
Function ToInt64: Int64; overload; inline;
Function ToSingle: Single; overload; inline;
Function ToDouble: Double; overload; inline;
Function ToExtended: Extended; overload; inline;
Function ToCharArray: TCharArray; overload;
Function ToCharArray(AStartIndex: SizeInt; ALen: SizeInt): TCharArray; overload;
Function ToLower: string; overload; inline;
Function ToLowerInvariant: string;
Function ToUpper: string; overload; inline;
Function ToUpperInvariant: string; inline;
Function Trim: string; overload;
Function TrimLeft: string; overload;
Function TrimRight: string; overload;
Function Trim(const ATrimChars: array of AnsiChar): string; overload;
Function TrimLeft(const ATrimChars: array of AnsiChar): string; overload;
Function TrimRight(const ATrimChars: array of AnsiChar): string; overload;
Function TrimEnd(const ATrimChars: array of AnsiChar): string; deprecated 'Use TrimRight';
Function TrimStart(const ATrimChars: array of AnsiChar): string; deprecated 'Use TrimLeft';
property Chars[AIndex: SizeInt]: AnsiChar read GetChar;
property Length: SizeInt read GetLength;
end;
TCurrencyHelper = type helper for Currency
private
function GetMaxValue: Currency; inline;
function GetMinValue: Currency; inline;
public
function Ceil: Int64; inline;
function Floor: Int64; inline;
function Frac: Currency; inline;
class function Parse(const S: string; const AFormatSettings: TFormatSettings): Currency; overload; static;
class function Parse(const S: string): Currency; overload; inline; static;
class function Size: Integer; inline; static;
function ToString(const AFormatSettings: TFormatSettings): string; overload; inline;
function ToString: string; overload; inline;
class function ToString(const Value: Currency; const AFormatSettings: TFormatSettings): string; overload; inline; static;
class function ToString(const Value: Currency): string; overload; inline; static;
function Trunc: Int64; inline;
class function TryParse(const S: string; out Value: Currency; const AFormatSettings: TFormatSettings): Boolean; overload; inline; static;
class function TryParse(const S: string; out Value: Currency): Boolean; overload; inline; static;
property MaxValue: Currency read GetMaxValue;
property MinValue: Currency read GetMinValue;
end;
{$IFDEF FPC_HAS_TYPE_SINGLE}
TSingleHelper = Type Helper for Single
Private
Function GetB(AIndex: Cardinal): Byte;
Function GetW(AIndex: Cardinal): Word;
Function GetE: QWord; inline;
Function GetF: QWord; inline;
Function GetS: Boolean; inline;
procedure SetB(AIndex: Cardinal; const AValue: Byte);
procedure SetW(AIndex: Cardinal; const AValue: Word);
procedure SetE(AValue: QWord);
procedure SetF(AValue: QWord);
procedure SetS(AValue: Boolean);
public
{$push}
{$R-}
{$Q-}
const
Epsilon : Single = 1.4012984643248170709e-45;
MaxValue : Single = 340282346638528859811704183484516925440.0;
MinValue : Single = -340282346638528859811704183484516925440.0;
PositiveInfinity : Single = 1.0/0.0;
NegativeInfinity : Single = -1.0/0.0;
NaN : Single = 0.0/0.0;
{$POP}
Class Function IsNan(const AValue: Single): Boolean; overload; inline; static;
Class Function IsInfinity(const AValue: Single): Boolean; overload; inline; static;
Class Function IsNegativeInfinity(const AValue: Single): Boolean; overload; inline; static;
Class Function IsPositiveInfinity(const AValue: Single): Boolean; overload; inline; static;
Class Function Parse(const AString: string): Single; overload; inline; static;
Class Function Parse(const AString: string; const AFormatSettings: TFormatSettings): Single; overload; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Single): string; overload; inline; static;
Class Function ToString(const AValue: Single; const AFormatSettings: TFormatSettings): string; overload; inline; static;
Class Function ToString(const AValue: Single; const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline; static;
Class Function ToString(const AValue: Single; const AFormat: TFloatFormat; const APrecision, ADigits: Integer;
const AFormatSettings: TFormatSettings): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Single): Boolean; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Single; const AFormatSettings: TFormatSettings): Boolean; overload; inline; static;
Procedure BuildUp(const ASignFlag: Boolean; const AMantissa: QWord; const AExponent: Integer);
Function Exponent: Integer;
Function Fraction: Extended;
Function IsInfinity: Boolean; overload; inline;
Function IsNan: Boolean; overload; inline;
Function IsNegativeInfinity: Boolean; overload; inline;
Function IsPositiveInfinity: Boolean; overload; inline;
Function Mantissa: QWord;
Function SpecialType: TFloatSpecial;
Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline;
Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer; const AFormatSettings: TFormatSettings): string; overload; inline;
Function ToString(const AFormatSettings: TFormatSettings): string; overload; inline;
Function ToString: string; overload; inline;
property Bytes [AIndex: Cardinal]: Byte read GetB write SetB;
property Words[AIndex: Cardinal]: Word read GetW write SetW;
property Sign: Boolean read GetS write SetS;
property Exp: QWord read GetE write SetE;
property Frac: QWord read GetF write SetF;
end;
{$ENDIF FPC_HAS_TYPE_SINGLE}
{$IFDEF FPC_HAS_TYPE_DOUBLE}
TDoubleHelper = Type Helper for Double
private
Function GetB(AIndex: Cardinal): Byte;
Function GetW(AIndex: Cardinal): Word;
Function GetE: QWord; inline;
Function GetF: QWord; inline;
Function GetS: Boolean; inline;
procedure SetB(AIndex: Cardinal; const AValue: Byte);
procedure SetW(AIndex: Cardinal; const AValue: Word);
procedure SetE(AValue: QWord);
procedure SetF(AValue: QWord);
procedure SetS(AValue: Boolean);
public
const
{$push}
{$R-}
{$Q-}
Epsilon : Double = 4.9406564584124654418e-324;
MaxValue : Double = 1.7976931348623157081e+308;
MinValue : Double = -1.7976931348623157081e+308;
PositiveInfinity : Double = 1.0/0.0;
NegativeInfinity : Double = -1.0/0.0;
NaN : Double = 0.0/0.0;
{$POP}
Class Function IsInfinity(const AValue: Double): Boolean; overload; inline; static;
Class Function IsNan(const AValue: Double): Boolean; overload; inline; static;
Class Function IsNegativeInfinity(const AValue: Double): Boolean; overload; inline; static;
Class Function IsPositiveInfinity(const AValue: Double): Boolean; overload; inline; static;
Class Function Parse(const AString: string): Double; overload; inline; static;
Class Function Parse(const AString: string; const AFormatSettings: TFormatSettings): Double; overload; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Double): string; overload; inline; static;
Class Function ToString(const AValue: Double; const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline; static;
Class Function ToString(const AValue: Double; const AFormat: TFloatFormat; const APrecision, ADigits: Integer; const AFormatSettings: TFormatSettings): string; overload; inline; static;
Class Function ToString(const AValue: Double; const AFormatSettings: TFormatSettings): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Double): Boolean; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Double; const AFormatSettings: TFormatSettings): Boolean; overload; inline; static;
Procedure BuildUp(const ASignFlag: Boolean; const AMantissa: QWord; const AExponent: Integer);
Function Exponent: Integer;
Function Fraction: Extended;
Function IsInfinity: Boolean; overload; inline;
Function IsNan: Boolean; overload; inline;
Function IsNegativeInfinity: Boolean; overload; inline;
Function IsPositiveInfinity: Boolean; overload; inline;
Function Mantissa: QWord;
Function SpecialType: TFloatSpecial;
Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline;
Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer; const AFormatSettings: TFormatSettings): string; overload; inline;
Function ToString(const AFormatSettings: TFormatSettings): string; overload; inline;
Function ToString: string; overload; inline;
property Bytes [AIndex: Cardinal]: Byte read GetB write SetB; // 0..7
property Words [AIndex: Cardinal]: Word read GetW write SetW; // 0..3
property Sign: Boolean read GetS write SetS;
property Exp: QWord read GetE write SetE;
property Frac: QWord read GetF write SetF;
end;
{$ENDIF FPC_HAS_TYPE_DOUBLE}
{$ifdef FPC_HAS_TYPE_EXTENDED}
TExtendedHelper = Type Helper for Extended
private
Function GetB(AIndex: Cardinal): Byte;
Function GetW(AIndex: Cardinal): Word;
Function GetE: QWord; inline;
Function GetF: QWord; inline;
Function GetS: Boolean; inline;
procedure SetB(AIndex: Cardinal; const AValue: Byte);
procedure SetW(AIndex: Cardinal; const AValue: Word);
procedure SetE(AValue: QWord);
procedure SetF(AValue: QWord);
procedure SetS(AValue: Boolean);
public
{$push}
{$R-}
{$Q-}
const
Epsilon : Extended = 3.64519953188247460253e-4951;
MaxValue : Extended = 1.18973149535723176505e+4932;
MinValue : Extended = -1.18973149535723176505e+4932;
PositiveInfinity : Extended = 1.0/0.0;
NegativeInfinity : Extended = -1.0/0.0;
NaN : Extended = 0.0/0.0;
{$POP}
Class Function ToString(const AValue: Extended): string; overload; inline; static;
Class Function ToString(const AValue: Extended; const AFormatSettings: TFormatSettings): string; overload; inline; static;
Class Function ToString(const AValue: Extended; const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline; static;
Class Function ToString(const AValue: Extended; const AFormat: TFloatFormat; const APrecision, ADigits: Integer; const AFormatSettings: TFormatSettings): string; overload; inline; static;
Class Function Parse(const AString: string): Extended; overload; inline; static;
Class Function Parse(const AString: string; const AFormatSettings: TFormatSettings): Extended; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Extended): Boolean; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Extended; const AFormatSettings: TFormatSettings): Boolean; overload; inline; static;
Class Function IsNan(const AValue: Extended): Boolean; overload; inline; static;
Class Function IsInfinity(const AValue: Extended): Boolean; overload; inline; static;
Class Function IsNegativeInfinity(const AValue: Extended): Boolean; overload; inline; static;
Class Function IsPositiveInfinity(const AValue: Extended): Boolean; overload; inline; static;
Class Function Size: Integer; inline; static;
procedure BuildUp(const ASignFlag: Boolean; const AMantissa: QWord; Const AExponent: Integer);
Function Exponent: Integer;
Function Fraction: Extended;
Function IsInfinity: Boolean; overload; inline;
Function IsNan: Boolean; overload; inline;
Function IsNegativeInfinity: Boolean; overload; inline;
Function IsPositiveInfinity: Boolean; overload; inline;
Function Mantissa: QWord;
Function SpecialType: TFloatSpecial;
Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline;
Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer; const AFormatSettings: TFormatSettings): string; overload; inline;
Function ToString(const AFormatSettings: TFormatSettings): string; overload; inline;
Function ToString: string; overload; inline;
property Bytes [AIndex: Cardinal]: Byte read GetB write SetB;
property Words [AIndex: Cardinal]: Word read GetW write SetW;
property Sign: Boolean read GetS write SetS;
property Exp: QWord read GetE write SetE;
property Frac: QWord read GetF write SetF;
end;
{$ENDIF FPC_HAS_TYPE_EXTENDED}
nibble = 0..15;
TNibbleBitIndex = 0..3;
// TByteBitIndex is already defined
TByteNibbleIndex = 0..1;
TByteOverlay = bitpacked record case integer of // for fast extraction of bits
0: (AsBit: bitpacked array[TByteBitIndex] of boolean);
1: (AsNibble: bitpacked array[TByteNibbleIndex] of nibble);
2: (AsByte: byte);
end;
TByteHelper = Type Helper for Byte
const
MaxValue = High(byte);
MinValue = Low(byte);
MaxBit = High(TByteBitIndex);
MinBit = Low(TByteBitIndex);
MaxNibble = High(TByteNibbleIndex);
MinNibble = Low(TByteNibbleIndex);
public
Class Function Parse(const AString: string): Byte; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Byte): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Byte): Boolean; inline; static;
protected
function GetBit(const aIndex: TByteBitIndex): boolean; inline;
procedure PutBit(const aIndex: TByteBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TByteNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TByteNibbleIndex; const aNewValue: nibble); inline;
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TByteBitIndex) : Byte; inline;
Function ClearBit(const Index: TByteBitIndex) : Byte; inline;
Function ToggleBit(const Index: TByteBitIndex) : Byte; inline;
Function TestBit(const Index:TByteBitIndex):Boolean; inline;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TByteBitIndex]: boolean read GetBit write PutBit;
property Nibbles [aIndex: TByteNibbleIndex]: nibble read GetNibble write PutNibble;
end;
// TShortIntBitIndex is already defined
TShortIntNibbleIndex = TByteNibbleIndex;
TShortIntOverlay = TByteOverlay;
TShortIntHelper = Type Helper for ShortInt
const
MaxValue = High(shortint);
MinValue = Low(shortint);
MaxBit = High(TShortIntBitIndex);
MinBit = Low(TShortIntBitIndex);
MaxNibble = High(TShortIntNibbleIndex);
MinNibble = Low(TShortIntNibbleIndex);
public
Class Function Parse(const AString: string): ShortInt; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: ShortInt): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: ShortInt): Boolean; inline; static;
protected
function GetBit(const aIndex: TShortIntBitIndex): boolean; inline;
procedure PutBit(const aIndex: TShortIntBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TShortIntNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TShortIntNibbleIndex; const aNewValue: nibble); inline;
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TShortIntBitIndex): Shortint; inline;
Function ClearBit(const Index: TShortIntBitIndex): Shortint; inline;
Function ToggleBit(const Index: TShortIntBitIndex): Shortint; inline;
Function TestBit(const Index:TShortIntBitIndex):Boolean;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TShortIntBitIndex]: boolean read GetBit write PutBit;
property Nibbles [aIndex: TShortIntNibbleIndex]: nibble read GetNibble write PutNibble;
end;
// TWordBitIndex is already defined
TWordByteIndex = 0..1;
TWordNibbleIndex = 0..3;
TWordOverlay = bitpacked record case integer of // for fast extraction of bytes and bits
0: (AsBit: bitpacked array[TWordBitIndex] of boolean);
1: (AsNibble: bitpacked array[TWordNibbleIndex] of nibble);
2: (AsByte: array[TWordByteIndex] of byte);
3: (AsWord: word);
// recursive overlay:
4: (AsByteOverlay: array[TWordByteIndex] of TByteOverlay);
end;
TWordHelper = Type Helper for Word
const
MaxValue = High(word);
MinValue = Low(word);
MaxBit = High(TWordBitIndex);
MinBit = Low(TWordBitIndex);
MaxNibble = High(TWordNibbleIndex);
MinNibble = Low(TWordNibbleIndex);
MaxByte = High(TWordByteIndex);
MinByte = Low(TWordByteIndex);
public
Class Function Parse(const AString: string): Word; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Word): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Word): Boolean; inline; static;
protected
function GetBit(const aIndex: TWordBitIndex): boolean; inline;
procedure PutBit(const aIndex: TWordBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TWordNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TWordNibbleIndex; const aNewValue: nibble); inline;
function GetByte(const aIndex: TWordByteIndex): byte;
procedure PutByte(const aIndex: TWordByteIndex; const aNewValue: byte);
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TWordBitIndex) : Word; inline;
Function ClearBit(const Index: TWordBitIndex) : Word; inline;
Function ToggleBit(const Index: TWordBitIndex) : Word; inline;
Function TestBit(const Index:TWordBitIndex):Boolean; inline;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TWordBitIndex]: boolean read GetBit write PutBit;
property Nibbles [aIndex: TWordNibbleIndex]: nibble read GetNibble write PutNibble;
property Bytes [aIndex: TWordByteIndex]: byte read GetByte write PutByte;
end;
// TSmallIntBitIndex is already defined
TSmallIntByteIndex = TWordByteIndex;
TSmallIntNibbleIndex = TWordNibbleIndex;
TSmallIntOverlay = TWordOverlay;
TSmallIntHelper = Type Helper for SmallInt
const
MaxValue = High(SmallInt);
MinValue = Low(SmallInt);
MaxBit = High(TSmallIntBitIndex);
MinBit = Low(TSmallIntBitIndex);
MaxNibble = High(TSmallIntNibbleIndex);
MinNibble = Low(TSmallIntNibbleIndex);
MaxByte = High(TSmallIntByteIndex);
MinByte = Low(TSmallIntByteIndex);
public
Class Function Parse(const AString: string): SmallInt; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: SmallInt): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: SmallInt): Boolean; inline; static;
protected
function GetBit(const aIndex: TSmallIntBitIndex): boolean; inline;
procedure PutBit(const aIndex: TSmallIntBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TSmallIntNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TSmallIntNibbleIndex; const aNewValue: nibble); inline;
function GetByte(const aIndex: TSmallIntByteIndex): byte;
procedure PutByte(const aIndex: TSmallIntByteIndex; const aNewValue: byte);
public
Function ToString: string; overload; inline;
Function ToBoolean: Boolean; inline;
Function ToBinString:string; inline;
Function ToHexString: string; overload; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToSingle: Single; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function SetBit(const Index: TSmallIntBitIndex) : Smallint; inline;
Function ClearBit(const Index: TSmallIntBitIndex) : Smallint; inline;
Function ToggleBit(const Index: TSmallIntBitIndex) : Smallint; inline;
Function TestBit(const Index:TSmallIntBitIndex):Boolean;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TSmallIntBitIndex]: boolean read GetBit write PutBit;
property Nibbles [aIndex: TSmallIntNibbleIndex]: nibble read GetNibble write PutNibble;
property Bytes [aIndex: TSmallIntByteIndex]: byte read GetByte write PutByte;
end;
TDwordBitIndex = TCardinalBitIndex;
TDwordNibbleIndex = 0..7;
TDwordByteIndex = 0..3;
TDwordWordIndex = 0..1;
TDwordOverlay = bitpacked record case integer of // for fast extraction of words, bytes and bits
0: (AsBit: bitpacked array[TDwordBitIndex] of boolean);
1: (AsNibble: bitpacked array[TDwordNibbleIndex] of nibble);
2: (AsByte: array[TDwordByteIndex] of byte);
3: (AsWord: array[TDwordWordIndex] of word);
4: (AsDword: dword);
// recursive overlays:
5: (AsByteOverlay: array[TDwordByteIndex] of TByteOverlay);
6: (AsWordOverlay: array[TDwordWordIndex] of TWordOverlay);
end;
// TCardinalBitIndex is already defined
TCardinalNibbleIndex = TDwordNibbleIndex;
TCardinalByteIndex = TDwordByteIndex;
TCardinalWordIndex = TDwordWordIndex;
TCardinalOverlay = TDwordOverlay;
TCardinalHelper = Type Helper for Cardinal { for LongWord Type too }
const
MaxValue = High(Cardinal);
MinValue = Low(Cardinal);
MaxBit = High(TCardinalBitIndex);
MinBit = Low(TCardinalBitIndex);
MaxNibble = High(TCardinalNibbleIndex);
MinNibble = Low(TCardinalNibbleIndex);
MaxByte = High(TCardinalByteIndex);
MinByte = Low(TCardinalByteIndex);
MaxWord = High(TCardinalWordIndex);
MinWord = Low(TCardinalWordIndex);
public
Class Function Parse(const AString: string): Cardinal; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Cardinal): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Cardinal): Boolean; inline; static;
protected
function GetBit(const aIndex: TCardinalBitIndex): boolean; inline;
procedure PutBit(const aIndex: TCardinalBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TCardinalNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TCardinalNibbleIndex; const aNewValue: nibble); inline;
function GetByte(const aIndex: TCardinalByteIndex): byte;
procedure PutByte(const aIndex: TCardinalByteIndex; const aNewValue: byte);
function GetWord(const aIndex: TCardinalWordIndex): word;
procedure PutWord(const aIndex: TCardinalWordIndex; const aNewValue: word);
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TCardinalBitIndex) : Cardinal; inline;
Function ClearBit(const Index: TCardinalBitIndex) : Cardinal; inline;
Function ToggleBit(const Index: TCardinalBitIndex) : Cardinal; inline;
Function TestBit(const Index:TCardinalBitIndex):Boolean; inline;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TCardinalBitIndex]: boolean read GetBit write PutBit;
property Nibbles[aIndex: TCardinalNibbleIndex]: nibble read GetNibble write PutNibble;
property Bytes [aIndex: TCardinalByteIndex]: byte read GetByte write PutByte;
property Words [aIndex: TCardinalWordIndex]: word read GetWord write PutWord;
end;
// TIntegerBitIndex is already defined
{$if sizeof(Integer)=2}
TIntegerNibbleIndex = TWordNibbleIndex;
TIntegerByteIndex = TWordByteIndex;
TIntegerOverlay = TWordOverlay;
{$elseif sizeof(Integer)=4}
TIntegerNibbleIndex = TDwordNibbleIndex;
TIntegerByteIndex = TDwordByteIndex;
TIntegerWordIndex = TDwordWordIndex;
TIntegerOverlay = TDwordOverlay;
{$else}
{$fatal Unsupported Integer type size}
{$endif}
TIntegerHelper = Type Helper for Integer
const
MaxValue = High(integer);
MinValue = Low(integer);
MaxBit = High(TIntegerBitIndex);
MinBit = Low(TIntegerBitIndex);
MaxNibble = High(TIntegerNibbleIndex);
MinNibble = Low(TIntegerNibbleIndex);
MaxByte = High(TIntegerByteIndex);
MinByte = Low(TIntegerByteIndex);
{$if sizeof(Integer)>=4}
MaxWord = High(TIntegerWordIndex);
MinWord = Low(TIntegerWordIndex);
{$endif}
public
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Integer): string; overload; inline; static;
Class Function Parse(const AString: string): Integer; inline; static;
Class Function TryParse(const AString: string; out AValue: Integer): Boolean; inline; static;
protected
function GetBit(const aIndex: TIntegerBitIndex): boolean; inline;
procedure PutBit(const aIndex: TIntegerBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TIntegerNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TIntegerNibbleIndex; const aNewValue: nibble); inline;
function GetByte(const aIndex: TIntegerByteIndex): byte;
procedure PutByte(const aIndex: TIntegerByteIndex; const aNewValue: byte);
{$if sizeof(Integer)>=4}
function GetWord(const aIndex: TIntegerWordIndex): word;
procedure PutWord(const aIndex: TIntegerWordIndex; const aNewValue: word);
{$endif}
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TIntegerBitIndex) : Integer; inline;
Function ClearBit(const Index: TIntegerBitIndex) : Integer; inline;
Function ToggleBit(const Index: TIntegerBitIndex) : Integer; inline;
Function TestBit(const Index:TIntegerBitIndex):Boolean; inline;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TIntegerBitIndex]: boolean read GetBit write PutBit;
property Nibbles[aIndex: TIntegerNibbleIndex]: nibble read GetNibble write PutNibble;
property Bytes [aIndex: TIntegerByteIndex]: byte read GetByte write PutByte;
{$if sizeof(Integer)>=4}
property Words [aIndex: TIntegerWordIndex]: word read GetWord write PutWord;
{$endif}
end;
// TLongIntBitIndex is already defined
TLongIntNibbleIndex = TDwordNibbleIndex;
TLongIntByteIndex = TDwordByteIndex;
TLongIntWordIndex = TDwordWordIndex;
TLongIntOverlay = TDwordOverlay;
TLongIntHelper = Type Helper for LongInt
const
MaxValue = High(LongInt);
MinValue = Low(LongInt);
MaxBit = High(TLongIntBitIndex);
MinBit = Low(TLongIntBitIndex);
MaxNibble = High(TLongIntNibbleIndex);
MinNibble = Low(TLongIntNibbleIndex);
MaxByte = High(TLongIntByteIndex);
MinByte = Low(TLongIntByteIndex);
MaxWord = High(TLongIntWordIndex);
MinWord = Low(TLongIntWordIndex);
public
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: LongInt): string; overload; inline; static;
Class Function Parse(const AString: string): LongInt; inline; static;
Class Function TryParse(const AString: string; out AValue: LongInt): Boolean; inline; static;
protected
function GetBit(const aIndex: TLongIntBitIndex): boolean; inline;
procedure PutBit(const aIndex: TLongIntBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TLongIntNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TLongIntNibbleIndex; const aNewValue: nibble); inline;
function GetByte(const aIndex: TLongIntByteIndex): byte;
procedure PutByte(const aIndex: TLongIntByteIndex; const aNewValue: byte);
function GetWord(const aIndex: TLongIntWordIndex): word;
procedure PutWord(const aIndex: TLongIntWordIndex; const aNewValue: word);
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TLongIntBitIndex) : LongInt; inline;
Function ClearBit(const Index: TLongIntBitIndex) : LongInt; inline;
Function ToggleBit(const Index: TLongIntBitIndex) : LongInt; inline;
Function TestBit(const Index:TLongIntBitIndex):Boolean; inline;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TLongIntBitIndex]: boolean read GetBit write PutBit;
property Nibbles[aIndex: TLongIntNibbleIndex]: nibble read GetNibble write PutNibble;
property Bytes [aIndex: TLongIntByteIndex]: byte read GetByte write PutByte;
property Words [aIndex: TLongIntWordIndex]: word read GetWord write PutWord;
end;
// TQwordBitIndex is already defined
TQwordNibbleIndex = 0..15;
TQwordByteIndex = 0..7;
TQwordWordIndex = 0..3;
TQwordDwordIndex = 0..1;
TQwordOverlay = bitpacked record case integer of // for fast extraction of longwords, words, bytes and bits
0: (AsBit: bitpacked array[TQwordBitIndex] of boolean);
1: (AsNibble: bitpacked array[TQwordNibbleIndex] of nibble);
2: (AsByte: array[TQwordByteIndex] of byte);
3: (AsWord: array[TQwordWordIndex] of word);
4: (AsDword: array[TQwordDwordIndex] of dword);
5: (AsQword: qword);
// recursive overlays:
6: (AsByteOverlay: array[TQwordByteIndex] of TByteOverlay);
7: (AsWordOverlay: array[TQwordWordIndex] of TWordOverlay);
8: (AsDwordOverlay: array[TQwordDwordIndex] of TDwordOverlay);
end;
TQWordHelper = Type Helper for QWord
const
MaxValue = High(qword);
MinValue = Low(qword);
MaxBit = High(TQwordBitIndex);
MinBit = Low(TQwordBitIndex);
MaxNibble = High(TQwordNibbleIndex);
MinNibble = Low(TQwordNibbleIndex);
MaxByte = High(TQwordByteIndex);
MinByte = Low(TQwordByteIndex);
MaxWord = High(TQwordWordIndex);
MinWord = Low(TQwordWordIndex);
MaxDword = High(TQwordDwordIndex);
MinDword = Low(TQwordDwordIndex);
public
Class Function Parse(const AString: string): Qword; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Qword): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Qword): Boolean; inline; static;
protected
function GetBit(const aIndex: TQwordBitIndex): boolean; inline;
procedure PutBit(const aIndex: TQwordBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TQwordNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TQwordNibbleIndex; const aNewValue: nibble); inline;
function GetByte(const aIndex: TQwordByteIndex): byte;
procedure PutByte(const aIndex: TQwordByteIndex; const aNewValue: byte);
function GetWord(const aIndex: TQwordWordIndex): word;
procedure PutWord(const aIndex: TQwordWordIndex; const aNewValue: word);
function GetDword(const aIndex: TQwordDwordIndex): dword;
procedure PutDword(const aIndex: TQwordDwordIndex; const aNewValue: dword);
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TQwordBitIndex): Qword; inline;
Function ClearBit(const Index: TQwordBitIndex): Qword; inline;
Function ToggleBit(const Index: TQwordBitIndex): Qword; inline;
Function TestBit(const Index:TQwordBitIndex): Boolean; inline;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TQwordBitIndex]: boolean read GetBit write PutBit;
property Nibbles[aIndex: TQwordNibbleIndex]: nibble read GetNibble write PutNibble;
property Bytes [aIndex: TQwordByteIndex]: byte read GetByte write PutByte;
property Words [aIndex: TQwordWordIndex]: word read GetWord write PutWord;
property DWords [aIndex: TQwordDwordIndex]: dword read GetDWord write PutDWord;
end;
// TInt64BitIndex is already defined
TInt64NibbleIndex = TQwordNibbleIndex;
TInt64ByteIndex = TQwordByteIndex;
TInt64WordIndex = TQwordWordIndex;
TInt64DwordIndex = TQwordDwordIndex;
TInt64Overlay = TQwordOverlay;
TInt64Helper = Type Helper for Int64
const
MaxValue = High(int64);
MinValue = Low(int64);
MaxBit = High(TInt64BitIndex);
MinBit = Low(TInt64BitIndex);
MaxNibble = High(TInt64NibbleIndex);
MinNibble = Low(TInt64NibbleIndex);
MaxByte = High(TInt64ByteIndex);
MinByte = Low(TInt64ByteIndex);
MaxWord = High(TInt64WordIndex);
MinWord = Low(TInt64WordIndex);
MaxDword = High(TInt64DwordIndex);
MinDword = Low(TInt64DwordIndex);
public
Class Function Parse(const AString: string): Int64; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Int64): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: Int64): Boolean; inline; static;
protected
function GetBit(const aIndex: TInt64BitIndex): boolean; inline;
procedure PutBit(const aIndex: TInt64BitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TInt64NibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TInt64NibbleIndex; const aNewValue: nibble); inline;
function GetByte(const aIndex: TInt64ByteIndex): byte;
procedure PutByte(const aIndex: TInt64ByteIndex; const aNewValue: byte);
function GetWord(const aIndex: TInt64WordIndex): word;
procedure PutWord(const aIndex: TInt64WordIndex; const aNewValue: word);
function GetDword(const aIndex: TInt64DwordIndex): dword;
procedure PutDword(const aIndex: TInt64DwordIndex; const aNewValue: dword);
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TInt64BitIndex) : Int64; inline;
Function ClearBit(const Index: TInt64BitIndex) : Int64; inline;
Function ToggleBit(const Index: TInt64BitIndex) : Int64; inline;
Function TestBit(const Index: TInt64BitIndex): Boolean; inline;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TInt64BitIndex]: boolean read GetBit write PutBit;
property Nibbles[aIndex: TInt64NibbleIndex]: nibble read GetNibble write PutNibble;
property Bytes [aIndex: TInt64ByteIndex]: byte read GetByte write PutByte;
property Words [aIndex: TInt64WordIndex]: word read GetWord write PutWord;
property DWords [aIndex: TInt64DwordIndex]: dword read GetDWord write PutDWord;
end;
// TNativeIntBitIndex is already defined
{$if sizeof(NativeInt)=2}
TNativeIntNibbleIndex = TSmallIntNibbleIndex;
TNativeIntByteIndex = TSmallIntByteIndex;
TNativeIntOverlay = TSmallIntOverlay;
{$elseif sizeof(NativeInt)=4}
TNativeIntNibbleIndex = TLongIntNibbleIndex;
TNativeIntByteIndex = TLongIntByteIndex;
TNativeIntWordIndex = TLongIntWordIndex;
TNativeIntOverlay = TLongIntOverlay;
{$elseif sizeof(NativeInt)=8}
TNativeIntNibbleIndex = TInt64NibbleIndex;
TNativeIntByteIndex = TInt64ByteIndex;
TNativeIntWordIndex = TInt64WordIndex;
TNativeIntDwordIndex = TInt64DWordIndex;
TNativeIntOverlay = TInt64Overlay;
{$else}
{$fatal Unsupported NativeInt type size}
{$endif}
TNativeIntHelper = Type Helper for NativeInt
const
MaxValue = High(NativeInt);
MinValue = Low(NativeInt);
MaxBit = High(TNativeIntBitIndex);
MinBit = Low(TNativeIntBitIndex);
MaxNibble = High(TNativeIntNibbleIndex);
MinNibble = Low(TNativeIntNibbleIndex);
// NativeInt on cpu16 has 2 bytes, so no need for cpu16 check because we always need MaxByte and MinByte
MaxByte = High(TNativeIntByteIndex);
MinByte = Low(TNativeIntByteIndex);
{$if sizeof(NativeInt)>=4}
MaxWord = High(TNativeIntWordIndex);
MinWord = Low(TNativeIntWordIndex);
{$endif}
{$ifdef sizeof(NativeInt)>=8}
MaxDword = High(TNativeIntDwordIndex);
MinDword = Low(TNativeIntDwordIndex);
{$endif}
public
Class Function Parse(const AString: string): NativeInt; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: NativeInt): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: NativeInt): Boolean; inline; static;
protected
function GetBit(const aIndex: TNativeIntBitIndex): boolean; inline;
procedure PutBit(const aIndex: TNativeIntBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TNativeIntNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TNativeIntNibbleIndex; const aNewValue: nibble); inline;
// NativeInt on cpu16 has 2 bytes, so no need for cpu16 check because we always need GetByte and PutByte
function GetByte(const aIndex: TNativeIntByteIndex): byte;
procedure PutByte(const aIndex: TNativeIntByteIndex; const aNewValue: byte);
{$if sizeof(NativeInt)>=4}
function GetWord(const aIndex: TNativeIntWordIndex): word;
procedure PutWord(const aIndex: TNativeIntWordIndex; const aNewValue: word);
{$endif}
{$if sizeof(NativeInt)>=8}
function GetDword(const aIndex: TNativeIntDwordIndex): dword;
procedure PutDword(const aIndex: TNativeIntDwordIndex; const aNewValue: dword);
{$endif}
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TNativeIntBitIndex) : NativeInt; inline;
Function ClearBit(const Index: TNativeIntBitIndex) : NativeInt; inline;
Function ToggleBit(const Index: TNativeIntBitIndex) : NativeInt; inline;
Function TestBit(const Index:TNativeIntBitIndex):Boolean; inline;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TNativeIntBitIndex]: boolean read GetBit write PutBit;
property Nibbles [aIndex: TNativeIntNibbleIndex]: nibble read GetNibble write PutNibble;
// NativeInt on cpu16 has 2 bytes, so no need for cpu16 check because we always need Byte[]
property Bytes [aIndex: TNativeIntByteIndex]: byte read GetByte write PutByte;
{$if sizeof(NativeInt)>=4}
property Words [aIndex: TNativeIntWordIndex]: word read GetWord write PutWord;
{$endif}
{$if sizeof(NativeInt)>=8}
property DWords [aIndex: TNativeIntDwordIndex]: dword read GetDWord write PutDWord;
{$endif}
end;
// TNativeUIntBitIndex is already defined
{$if sizeof(NativeUInt)=2}
TNativeUIntNibbleIndex = TWordNibbleIndex;
TNativeUIntByteIndex = TWordByteIndex;
TNativeUIntOverlay = TWordOverlay;
{$elseif sizeof(NativeUInt)=4}
TNativeUIntNibbleIndex = TDwordNibbleIndex;
TNativeUIntByteIndex = TDwordByteIndex;
TNativeUIntWordIndex = TDwordWordIndex;
TNativeUIntOverlay = TDwordOverlay;
{$elseif sizeof(NativeUInt)=8}
TNativeUIntNibbleIndex = TQwordNibbleIndex;
TNativeUIntByteIndex = TQwordByteIndex;
TNativeUIntWordIndex = TQwordWordIndex;
TNativeUIntDwordIndex = TQwordDWordIndex;
TNativeUIntOverlay = TQwordOverlay;
{$else}
{$fatal Unsupported NativeUInt type size}
{$endif}
TNativeUIntHelper = Type Helper for NativeUInt
const
MaxValue = High(NativeUInt);
MinValue = 0;
MaxBit = High(TNativeUIntBitIndex);
MinBit = Low(TNativeUIntBitIndex);
MaxNibble = High(TNativeUIntNibbleIndex);
MinNibble = Low(TNativeUIntNibbleIndex);
// NativeInt on cpu16 has 2 bytes, so no need for cpu16 check because we always need MaxByte and MinByte
MaxByte = High(TNativeUIntByteIndex);
MinByte = Low(TNativeUIntByteIndex);
{$if sizeof(NativeUInt)>=4}
MaxWord = High(TNativeUIntWordIndex);
MinWord = Low(TNativeUIntWordIndex);
{$endif}
{$if sizeof(NativeUInt)>=8}
MaxDword = High(TNativeUIntDwordIndex);
MinDword = Low(TNativeUIntDwordIndex);
{$endif}
public
Class Function Parse(const AString: string): NativeUInt; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: NativeUInt): string; overload; inline; static;
Class Function TryParse(const AString: string; out AValue: NativeUInt): Boolean; inline; static;
protected
function GetBit(const aIndex: TNativeUIntBitIndex): boolean; inline;
procedure PutBit(const aIndex: TNativeUIntBitIndex; const aNewValue: boolean); inline;
function GetNibble(const aIndex: TNativeUIntNibbleIndex): nibble; inline;
procedure PutNibble(const aIndex: TNativeUIntNibbleIndex; const aNewValue: nibble); inline;
// NativeInt on cpu16 has 2 bytes, so no need for cpu16 check because we always need GetByte and PutByte
function GetByte(const aIndex: TNativeUIntByteIndex): byte;
procedure PutByte(const aIndex: TNativeUIntByteIndex; const aNewValue: byte);
{$if sizeof(NativeUInt)>=4}
function GetWord(const aIndex: TNativeUIntWordIndex): word;
procedure PutWord(const aIndex: TNativeUIntWordIndex; const aNewValue: word);
{$endif}
{$if sizeof(NativeUInt)>=8}
function GetDword(const aIndex: TNativeUIntDwordIndex): dword;
procedure PutDword(const aIndex: TNativeUIntDwordIndex; const aNewValue: dword);
{$endif}
public
Function ToBoolean: Boolean; inline;
Function ToDouble: Double; inline;
Function ToExtended: Extended; inline;
Function ToBinString:string; inline;
Function ToHexString(const AMinDigits: Integer): string; overload; inline;
Function ToHexString: string; overload; inline;
Function ToSingle: Single; inline;
Function ToString: string; overload; inline;
Function SetBit(const Index: TNativeUIntBitIndex) : NativeUint; inline;
Function ClearBit(const Index: TNativeUIntBitIndex): NativeUint; inline;
Function ToggleBit(const Index: TNativeUIntBitIndex) : NativeUint; inline;
Function TestBit(const Index:TNativeUIntBitIndex) :Boolean; inline;
procedure Clear; inline;
function HighestSetBitPos: int8; inline;
function LowestSetBitPos: int8; inline;
function SetBitsCount: byte; inline;
property Bits [aIndex: TNativeUIntBitIndex]: boolean read GetBit write PutBit;
property Nibbles [aIndex: TNativeUIntNibbleIndex]: nibble read GetNibble write PutNibble;
// NativeInt on cpu16 has 2 bytes, so no need for cpu16 check because we always need Byte[]
property Bytes [aIndex: TNativeUIntByteIndex]: byte read GetByte write PutByte;
{$if sizeof(NativeUInt)>=4}
property Words [aIndex: TNativeUIntWordIndex]: word read GetWord write PutWord;
{$endif}
{$if sizeof(NativeUInt)>=8}
property DWords [aIndex: TNativeUIntDwordIndex]: dword read GetDWord write PutDWord;
{$endif}
end;
{$SCOPEDENUMS ON}
TUseBoolStrs = (False, True);
{$SCOPEDENUMS OFF}
TBooleanHelper = Type Helper for Boolean
public
Class Function Parse(const S: string): Boolean; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
Public
Function ToInteger: Integer; inline;
Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
end;
TBoolean8Helper = Type Helper for Boolean8
public
Class Function Parse(const S: string): Boolean; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
Public
Function ToInteger: Integer; inline;
Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
end;
TBoolean16Helper = Type Helper for Boolean16
public
Class Function Parse(const S: string): Boolean; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
Public
Function ToInteger: Integer; inline;
Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
end;
TBoolean32Helper = Type Helper for Boolean32
public
Class Function Parse(const S: string): Boolean; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
Public
Function ToInteger: Integer; inline;
Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
end;
TBoolean64Helper = Type Helper for Boolean64
public
Class Function Parse(const S: string): Boolean; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
Public
Function ToInteger: Integer; inline;
Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
end;
TByteBoolHelper = Type Helper for ByteBool
public
Class Function Parse(const S: string): Boolean; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
Public
Function ToInteger: Integer; inline;
Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
end;
TWordBoolHelper = Type Helper for WordBool
public
Class Function Parse(const S: string): Boolean; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
Public
Function ToInteger: Integer; inline;
Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
end;
TLongBoolHelper = Type Helper for LongBool
public
Class Function Parse(const S: string): Boolean; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
public
Function ToInteger: Integer; inline;
Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
end;
TQWordBoolHelper = Type Helper for QWordBool
public
Class Function Parse(const S: string): Boolean; inline; static;
Class Function Size: Integer; inline; static;
Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
public
Function ToInteger: Integer; inline;
Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
end;
Reference in New Issue View Git Blame Copy Permalink