Global

class method Abs(Val: Double): Double

static Double Abs(Double Val)

static func Abs(_ Val: Double) -> Double

static Double Abs(Double Val)

Shared Function Abs(Val As Double) As Double

class method Abs(Val: Int32): Int32

static Int32 Abs(Int32 Val)

static func Abs(_ Val: Int32) -> Int32

static Integer Abs(Integer Val)

Shared Function Abs(Val As Int32) As Int32

class method Abs(Val: Int64): Int64

static Int64 Abs(Int64 Val)

static func Abs(_ Val: Int64) -> Int64

static Int64 Abs(Int64 Val)

Shared Function Abs(Val As Int64) As Int64

class method AnsiCompareStr(S1: DelphiString; S2: DelphiString): Int32

static Int32 AnsiCompareStr(DelphiString S1, DelphiString S2)

static func AnsiCompareStr(_ S1: DelphiString, _ S2: DelphiString) -> Int32

static Integer AnsiCompareStr(DelphiString S1, DelphiString S2)

Shared Function AnsiCompareStr(S1 As DelphiString, S2 As DelphiString) As Int32

class method AnsiCompareText(S1: DelphiString; S2: DelphiString): Int32

static Int32 AnsiCompareText(DelphiString S1, DelphiString S2)

static func AnsiCompareText(_ S1: DelphiString, _ S2: DelphiString) -> Int32

static Integer AnsiCompareText(DelphiString S1, DelphiString S2)

Shared Function AnsiCompareText(S1 As DelphiString, S2 As DelphiString) As Int32

class method AnsiDequotedStr(S: DelphiString; aQuote: Char): DelphiString

static DelphiString AnsiDequotedStr(DelphiString S, Char aQuote)

static func AnsiDequotedStr(_ S: DelphiString, _ aQuote: Char) -> DelphiString

static DelphiString AnsiDequotedStr(DelphiString S, Char aQuote)

Shared Function AnsiDequotedStr(S As DelphiString, aQuote As Char) As DelphiString

class method AnsiLowerCase(S: DelphiString): DelphiString

static DelphiString AnsiLowerCase(DelphiString S)

static func AnsiLowerCase(_ S: DelphiString) -> DelphiString

static DelphiString AnsiLowerCase(DelphiString S)

Shared Function AnsiLowerCase(S As DelphiString) As DelphiString

class method AnsiQuotedStr(S: DelphiString; Quote: Char): DelphiString

static DelphiString AnsiQuotedStr(DelphiString S, Char Quote)

static func AnsiQuotedStr(_ S: DelphiString, _ Quote: Char) -> DelphiString

static DelphiString AnsiQuotedStr(DelphiString S, Char Quote)

Shared Function AnsiQuotedStr(S As DelphiString, Quote As Char) As DelphiString

class method AnsiSameStr(S1: DelphiString; S2: DelphiString): Boolean

static Boolean AnsiSameStr(DelphiString S1, DelphiString S2)

static func AnsiSameStr(_ S1: DelphiString, _ S2: DelphiString) -> Boolean

static Boolean AnsiSameStr(DelphiString S1, DelphiString S2)

Shared Function AnsiSameStr(S1 As DelphiString, S2 As DelphiString) As Boolean

class method AnsiSameText(S1: DelphiString; S2: DelphiString): Boolean

static Boolean AnsiSameText(DelphiString S1, DelphiString S2)

static func AnsiSameText(_ S1: DelphiString, _ S2: DelphiString) -> Boolean

static Boolean AnsiSameText(DelphiString S1, DelphiString S2)

Shared Function AnsiSameText(S1 As DelphiString, S2 As DelphiString) As Boolean

class method AnsiStartsText(ASubText: DelphiString; AText: DelphiString): Boolean

static Boolean AnsiStartsText(DelphiString ASubText, DelphiString AText)

static func AnsiStartsText(_ ASubText: DelphiString, _ AText: DelphiString) -> Boolean

static Boolean AnsiStartsText(DelphiString ASubText, DelphiString AText)

Shared Function AnsiStartsText(ASubText As DelphiString, AText As DelphiString) As Boolean

class method AnsiUpperCase(S: DelphiString): DelphiString

static DelphiString AnsiUpperCase(DelphiString S)

static func AnsiUpperCase(_ S: DelphiString) -> DelphiString

static DelphiString AnsiUpperCase(DelphiString S)

Shared Function AnsiUpperCase(S As DelphiString) As DelphiString

class var ApproxDaysPerMonth: Double;

static Double ApproxDaysPerMonth

static var ApproxDaysPerMonth: Double

static Double ApproxDaysPerMonth

Shared FIELD ApproxDaysPerMonth() As Double

class var ApproxDaysPerYear: Double;

static Double ApproxDaysPerYear

static var ApproxDaysPerYear: Double

static Double ApproxDaysPerYear

Shared FIELD ApproxDaysPerYear() As Double

const arARM32: TArchitecture = TArchitecture.arARM32

const TArchitecture arARM32 = TArchitecture.arARM32

static let arARM32: TArchitecture = TArchitecture.arARM32

static final Integer arARM32 = 2

Const arARM32 As TArchitecture = TArchitecture.arARM32

const arARM64: TArchitecture = TArchitecture.arARM64

const TArchitecture arARM64 = TArchitecture.arARM64

static let arARM64: TArchitecture = TArchitecture.arARM64

static final Integer arARM64 = 3

Const arARM64 As TArchitecture = TArchitecture.arARM64

class method ArcCos(X: Double): Double

static Double ArcCos(Double X)

static func ArcCos(_ X: Double) -> Double

static Double ArcCos(Double X)

Shared Function ArcCos(X As Double) As Double

class method ArcSin(X: Double): Double

static Double ArcSin(Double X)

static func ArcSin(_ X: Double) -> Double

static Double ArcSin(Double X)

Shared Function ArcSin(X As Double) As Double

class method ArcTan(X: Double): Double

static Double ArcTan(Double X)

static func ArcTan(_ X: Double) -> Double

static Double ArcTan(Double X)

Shared Function ArcTan(X As Double) As Double

class method ArcTan2(Y: Double; X: Double): Double

static Double ArcTan2(Double Y, Double X)

static func ArcTan2(_ Y: Double, _ X: Double) -> Double

static Double ArcTan2(Double Y, Double X)

Shared Function ArcTan2(Y As Double, X As Double) As Double

const arIntelX64: TArchitecture = TArchitecture.arIntelX64

const TArchitecture arIntelX64 = TArchitecture.arIntelX64

static let arIntelX64: TArchitecture = TArchitecture.arIntelX64

static final Integer arIntelX64 = 1

Const arIntelX64 As TArchitecture = TArchitecture.arIntelX64

const arIntelX86: TArchitecture = TArchitecture.arIntelX86

const TArchitecture arIntelX86 = TArchitecture.arIntelX86

static let arIntelX86: TArchitecture = TArchitecture.arIntelX86

static final Integer arIntelX86 = 0

Const arIntelX86 As TArchitecture = TArchitecture.arIntelX86

const Basic: THighDPISupportLevel = THighDPISupportLevel.Basic

const THighDPISupportLevel Basic = THighDPISupportLevel.Basic

static let Basic: THighDPISupportLevel = THighDPISupportLevel.Basic

Const Basic As THighDPISupportLevel = THighDPISupportLevel.Basic

class method BoolToStr(B: Boolean; UseBoolStrs: Boolean := false): DelphiString

static DelphiString BoolToStr(Boolean B, Boolean UseBoolStrs = false)

static func BoolToStr(_ B: Boolean, _ UseBoolStrs: Boolean = false) -> DelphiString

static DelphiString BoolToStr(Boolean B, Boolean UseBoolStrs)

Shared Function BoolToStr(B As Boolean, UseBoolStrs As Boolean = false) As DelphiString

class method Ceil(X: Double): Int32

static Int32 Ceil(Double X)

static func Ceil(_ X: Double) -> Int32

static Integer Ceil(Double X)

Shared Function Ceil(X As Double) As Int32

class method ChangeFileExt(FileName: DelphiString; aExtension: DelphiString): DelphiString

static DelphiString ChangeFileExt(DelphiString FileName, DelphiString aExtension)

static func ChangeFileExt(_ FileName: DelphiString, _ aExtension: DelphiString) -> DelphiString

static DelphiString ChangeFileExt(DelphiString FileName, DelphiString aExtension)

Shared Function ChangeFileExt(FileName As DelphiString, aExtension As DelphiString) As DelphiString

class method ChangeFilePath(FileName: DelphiString; Path: DelphiString): DelphiString

static DelphiString ChangeFilePath(DelphiString FileName, DelphiString Path)

static func ChangeFilePath(_ FileName: DelphiString, _ Path: DelphiString) -> DelphiString

static DelphiString ChangeFilePath(DelphiString FileName, DelphiString Path)

Shared Function ChangeFilePath(FileName As DelphiString, Path As DelphiString) As DelphiString

const cnAdded: TCollectionNotification = TCollectionNotification.cnAdded

const TCollectionNotification cnAdded = TCollectionNotification.cnAdded

static let cnAdded: TCollectionNotification = TCollectionNotification.cnAdded

static final Integer cnAdded = 0

Const cnAdded As TCollectionNotification = TCollectionNotification.cnAdded

const cnExtracted: TCollectionNotification = TCollectionNotification.cnExtracted

const TCollectionNotification cnExtracted = TCollectionNotification.cnExtracted

static let cnExtracted: TCollectionNotification = TCollectionNotification.cnExtracted

static final Integer cnExtracted = 2

Const cnExtracted As TCollectionNotification = TCollectionNotification.cnExtracted

const cnRemoved: TCollectionNotification = TCollectionNotification.cnRemoved

const TCollectionNotification cnRemoved = TCollectionNotification.cnRemoved

static let cnRemoved: TCollectionNotification = TCollectionNotification.cnRemoved

static final Integer cnRemoved = 1

Const cnRemoved As TCollectionNotification = TCollectionNotification.cnRemoved

const coDigitAsNumbers: TCompareOption = TCompareOption.coDigitAsNumbers

const TCompareOption coDigitAsNumbers = TCompareOption.coDigitAsNumbers

static let coDigitAsNumbers: TCompareOption = TCompareOption.coDigitAsNumbers

static final Integer coDigitAsNumbers = 8

Const coDigitAsNumbers As TCompareOption = TCompareOption.coDigitAsNumbers

const coIgnoreCase: TCompareOption = TCompareOption.coIgnoreCase

const TCompareOption coIgnoreCase = TCompareOption.coIgnoreCase

static let coIgnoreCase: TCompareOption = TCompareOption.coIgnoreCase

static final Integer coIgnoreCase = 2

Const coIgnoreCase As TCompareOption = TCompareOption.coIgnoreCase

const coIgnoreKanatype: TCompareOption = TCompareOption.coIgnoreKanatype

const TCompareOption coIgnoreKanatype = TCompareOption.coIgnoreKanatype

static let coIgnoreKanatype: TCompareOption = TCompareOption.coIgnoreKanatype

static final Integer coIgnoreKanatype = 3

Const coIgnoreKanatype As TCompareOption = TCompareOption.coIgnoreKanatype

const coIgnoreNonSpace: TCompareOption = TCompareOption.coIgnoreNonSpace

const TCompareOption coIgnoreNonSpace = TCompareOption.coIgnoreNonSpace

static let coIgnoreNonSpace: TCompareOption = TCompareOption.coIgnoreNonSpace

static final Integer coIgnoreNonSpace = 4

Const coIgnoreNonSpace As TCompareOption = TCompareOption.coIgnoreNonSpace

const coIgnoreSymbols: TCompareOption = TCompareOption.coIgnoreSymbols

const TCompareOption coIgnoreSymbols = TCompareOption.coIgnoreSymbols

static let coIgnoreSymbols: TCompareOption = TCompareOption.coIgnoreSymbols

static final Integer coIgnoreSymbols = 5

Const coIgnoreSymbols As TCompareOption = TCompareOption.coIgnoreSymbols

const coIgnoreWidth: TCompareOption = TCompareOption.coIgnoreWidth

const TCompareOption coIgnoreWidth = TCompareOption.coIgnoreWidth

static let coIgnoreWidth: TCompareOption = TCompareOption.coIgnoreWidth

static final Integer coIgnoreWidth = 6

Const coIgnoreWidth As TCompareOption = TCompareOption.coIgnoreWidth

const coLingCasing: TCompareOption = TCompareOption.coLingCasing

const TCompareOption coLingCasing = TCompareOption.coLingCasing

static let coLingCasing: TCompareOption = TCompareOption.coLingCasing

static final Integer coLingCasing = 7

Const coLingCasing As TCompareOption = TCompareOption.coLingCasing

const coLingIgnoreCase: TCompareOption = TCompareOption.coLingIgnoreCase

const TCompareOption coLingIgnoreCase = TCompareOption.coLingIgnoreCase

static let coLingIgnoreCase: TCompareOption = TCompareOption.coLingIgnoreCase

static final Integer coLingIgnoreCase = 0

Const coLingIgnoreCase As TCompareOption = TCompareOption.coLingIgnoreCase

const coLingIgnoreDiacritic: TCompareOption = TCompareOption.coLingIgnoreDiacritic

const TCompareOption coLingIgnoreDiacritic = TCompareOption.coLingIgnoreDiacritic

static let coLingIgnoreDiacritic: TCompareOption = TCompareOption.coLingIgnoreDiacritic

static final Integer coLingIgnoreDiacritic = 1

Const coLingIgnoreDiacritic As TCompareOption = TCompareOption.coLingIgnoreDiacritic

class method CompareDate(A: TDateTime; B: TDateTime): TValueRelationship

static TValueRelationship CompareDate(TDateTime A, TDateTime B)

static func CompareDate(_ A: TDateTime, _ B: TDateTime) -> TValueRelationship

static TValueRelationship CompareDate(TDateTime A, TDateTime B)

Shared Function CompareDate(A As TDateTime, B As TDateTime) As TValueRelationship

class method CompareDateTime(A: TDateTime; B: TDateTime): TValueRelationship

static TValueRelationship CompareDateTime(TDateTime A, TDateTime B)

static func CompareDateTime(_ A: TDateTime, _ B: TDateTime) -> TValueRelationship

static TValueRelationship CompareDateTime(TDateTime A, TDateTime B)

Shared Function CompareDateTime(A As TDateTime, B As TDateTime) As TValueRelationship

// .NET
class method CompareMem(P1: ^void; P2: ^void; Length: Int32): Boolean
// Island
class method CompareMem(P1: Pointer; P2: Pointer; Length: Int32): Boolean

// .NET
static Boolean CompareMem(void* P1, void* P2, Int32 Length)
// Island
static Boolean CompareMem(Pointer P1, Pointer P2, Int32 Length)

static func CompareMem(_ P1: Pointer, _ P2: Pointer, _ Length: Int32) -> Boolean

// .NET
Shared Function CompareMem(P1 As Ptr(Of Void), P2 As Ptr(Of Void), Length As Int32) As Boolean
// Island
Shared Function CompareMem(P1 As Pointer, P2 As Pointer, Length As Int32) As Boolean

class method CompareStr(S1: AnsiString; S2: AnsiString): Int32

static Int32 CompareStr(AnsiString S1, AnsiString S2)

static func CompareStr(_ S1: AnsiString, _ S2: AnsiString) -> Int32

static Integer CompareStr(AnsiString S1, AnsiString S2)

Shared Function CompareStr(S1 As AnsiString, S2 As AnsiString) As Int32

class method CompareStr(S1: DelphiString; S2: DelphiString): Int32

static Int32 CompareStr(DelphiString S1, DelphiString S2)

static func CompareStr(_ S1: DelphiString, _ S2: DelphiString) -> Int32

static Integer CompareStr(DelphiString S1, DelphiString S2)

Shared Function CompareStr(S1 As DelphiString, S2 As DelphiString) As Int32

class method CompareStr(S1: DelphiString; S2: DelphiString; LocaleOptions: TLocaleOptions): Int32

static Int32 CompareStr(DelphiString S1, DelphiString S2, TLocaleOptions LocaleOptions)

static func CompareStr(_ S1: DelphiString, _ S2: DelphiString, _ LocaleOptions: TLocaleOptions) -> Int32

static Integer CompareStr(DelphiString S1, DelphiString S2, TLocaleOptions LocaleOptions)

Shared Function CompareStr(S1 As DelphiString, S2 As DelphiString, LocaleOptions As TLocaleOptions) As Int32

class method CompareStr(S1: PlatformString; S2: PlatformString): Int32

static Int32 CompareStr(PlatformString S1, PlatformString S2)

static func CompareStr(_ S1: PlatformString, _ S2: PlatformString) -> Int32

static Integer CompareStr(PlatformString S1, PlatformString S2)

Shared Function CompareStr(S1 As PlatformString, S2 As PlatformString) As Int32

class method CompareText(S1: AnsiString; S2: AnsiString): Int32

static Int32 CompareText(AnsiString S1, AnsiString S2)

static func CompareText(_ S1: AnsiString, _ S2: AnsiString) -> Int32

static Integer CompareText(AnsiString S1, AnsiString S2)

Shared Function CompareText(S1 As AnsiString, S2 As AnsiString) As Int32

class method CompareText(S1: DelphiString; S2: DelphiString): Int32

static Int32 CompareText(DelphiString S1, DelphiString S2)

static func CompareText(_ S1: DelphiString, _ S2: DelphiString) -> Int32

static Integer CompareText(DelphiString S1, DelphiString S2)

Shared Function CompareText(S1 As DelphiString, S2 As DelphiString) As Int32

class method CompareText(S1: DelphiString; S2: DelphiString; LocaleOptions: TLocaleOptions): Int32

static Int32 CompareText(DelphiString S1, DelphiString S2, TLocaleOptions LocaleOptions)

static func CompareText(_ S1: DelphiString, _ S2: DelphiString, _ LocaleOptions: TLocaleOptions) -> Int32

static Integer CompareText(DelphiString S1, DelphiString S2, TLocaleOptions LocaleOptions)

Shared Function CompareText(S1 As DelphiString, S2 As DelphiString, LocaleOptions As TLocaleOptions) As Int32

class method CompareText(S1: PlatformString; S2: PlatformString): Int32

static Int32 CompareText(PlatformString S1, PlatformString S2)

static func CompareText(_ S1: PlatformString, _ S2: PlatformString) -> Int32

static Integer CompareText(PlatformString S1, PlatformString S2)

Shared Function CompareText(S1 As PlatformString, S2 As PlatformString) As Int32

class method CompareTime(A: TDateTime; B: TDateTime): TValueRelationship

static TValueRelationship CompareTime(TDateTime A, TDateTime B)

static func CompareTime(_ A: TDateTime, _ B: TDateTime) -> TValueRelationship

static TValueRelationship CompareTime(TDateTime A, TDateTime B)

Shared Function CompareTime(A As TDateTime, B As TDateTime) As TValueRelationship

class method Concat<T>(params aArrays: array of array of T): nullable array of T

static T[]? Concat<T>(params T[][] aArrays)

static func Concat<T>(_ aArrays: T......) -> T...

static T[] Concat<T>(T[][]... aArrays)

Shared Function Concat<T>(ParamArray aArrays As T()()) As T()?

class method ContainsText(aText: AnsiString; aSubText: AnsiString): Boolean

static Boolean ContainsText(AnsiString aText, AnsiString aSubText)

static func ContainsText(_ aText: AnsiString, _ aSubText: AnsiString) -> Boolean

static Boolean ContainsText(AnsiString aText, AnsiString aSubText)

Shared Function ContainsText(aText As AnsiString, aSubText As AnsiString) As Boolean

class method Copy(aSource: AnsiString; aIndex: Int32; aCount: Int32): AnsiString

static AnsiString Copy(AnsiString aSource, Int32 aIndex, Int32 aCount)

static func Copy(_ aSource: AnsiString, _ aIndex: Int32, _ aCount: Int32) -> AnsiString

static AnsiString Copy(AnsiString aSource, Integer aIndex, Integer aCount)

Shared Function Copy(aSource As AnsiString, aIndex As Int32, aCount As Int32) As AnsiString

class method Copy(S: DelphiString; aIndex: Int32; aCount: Int32): DelphiString

static DelphiString Copy(DelphiString S, Int32 aIndex, Int32 aCount)

static func Copy(_ S: DelphiString, _ aIndex: Int32, _ aCount: Int32) -> DelphiString

static DelphiString Copy(DelphiString S, Integer aIndex, Integer aCount)

Shared Function Copy(S As DelphiString, aIndex As Int32, aCount As Int32) As DelphiString

class method Copy(S: PlatformString; aIndex: Int32; aCount: Int32): DelphiString

static DelphiString Copy(PlatformString S, Int32 aIndex, Int32 aCount)

static func Copy(_ S: PlatformString, _ aIndex: Int32, _ aCount: Int32) -> DelphiString

static DelphiString Copy(PlatformString S, Integer aIndex, Integer aCount)

Shared Function Copy(S As PlatformString, aIndex As Int32, aCount As Int32) As DelphiString

class method Copy<T>(aSource: nullable array of T): nullable array of T

static T[]? Copy<T>(T[]? aSource)

static func Copy<T>(_ aSource: T...) -> T...

static T[] Copy<T>(T[] aSource)

Shared Function Copy<T>(aSource As T()?) As T()?

class method Copy<T>(aSource: nullable array of T; aIndex: Int32; aCount: Int32): nullable array of T

static T[]? Copy<T>(T[]? aSource, Int32 aIndex, Int32 aCount)

static func Copy<T>(_ aSource: T..., _ aIndex: Int32, _ aCount: Int32) -> T...

static T[] Copy<T>(T[] aSource, Integer aIndex, Integer aCount)

Shared Function Copy<T>(aSource As T()?, aIndex As Int32, aCount As Int32) As T()?

class method Cos(X: Double): Double

static Double Cos(Double X)

static func Cos(_ X: Double) -> Double

static Double Cos(Double X)

Shared Function Cos(X As Double) As Double

const coStringSort: TCompareOption = TCompareOption.coStringSort

const TCompareOption coStringSort = TCompareOption.coStringSort

static let coStringSort: TCompareOption = TCompareOption.coStringSort

static final Integer coStringSort = 9

Const coStringSort As TCompareOption = TCompareOption.coStringSort

class method CreateDir(Dir: DelphiString): Boolean

static Boolean CreateDir(DelphiString Dir)

static func CreateDir(_ Dir: DelphiString) -> Boolean

static Boolean CreateDir(DelphiString Dir)

Shared Function CreateDir(Dir As DelphiString) As Boolean

class method CurrentYear: UInt16

static UInt16 CurrentYear()

static func CurrentYear() -> UInt16

static Word CurrentYear()

Shared Function CurrentYear() As UInt16

class method Date: TDateTime

static TDateTime Date()

static func Date() -> TDateTime

static TDateTime Date()

Shared Function Date() As TDateTime

const DateDelta: Int32 = 693594

const Int32 DateDelta = 693594

static let DateDelta: Int32 = 693594

static final Integer DateDelta = 693594

Const DateDelta As Int32 = 693594

class method DateInRange(aDate: TDate; aStartDate: TDate; aEndDate: TDate; aInclusive: Boolean := true): Boolean

static Boolean DateInRange(TDate aDate, TDate aStartDate, TDate aEndDate, Boolean aInclusive = true)

static func DateInRange(_ aDate: TDate, _ aStartDate: TDate, _ aEndDate: TDate, _ aInclusive: Boolean = true) -> Boolean

static Boolean DateInRange(TDate aDate, TDate aStartDate, TDate aEndDate, Boolean aInclusive)

Shared Function DateInRange(aDate As TDate, aStartDate As TDate, aEndDate As TDate, aInclusive As Boolean = true) As Boolean

class method DateOf(aValue: TDateTime): TDateTime

static TDateTime DateOf(TDateTime aValue)

static func DateOf(_ aValue: TDateTime) -> TDateTime

static TDateTime DateOf(TDateTime aValue)

Shared Function DateOf(aValue As TDateTime) As TDateTime

class method DateTimeInRange(aDateTime: TDateTime; aStartDateTime: TDateTime; aEndDateTime: TDateTime; aInclusive: Boolean := true): Boolean

static Boolean DateTimeInRange(TDateTime aDateTime, TDateTime aStartDateTime, TDateTime aEndDateTime, Boolean aInclusive = true)

static func DateTimeInRange(_ aDateTime: TDateTime, _ aStartDateTime: TDateTime, _ aEndDateTime: TDateTime, _ aInclusive: Boolean = true) -> Boolean

static Boolean DateTimeInRange(TDateTime aDateTime, TDateTime aStartDateTime, TDateTime aEndDateTime, Boolean aInclusive)

Shared Function DateTimeInRange(aDateTime As TDateTime, aStartDateTime As TDateTime, aEndDateTime As TDateTime, aInclusive As Boolean = true) As Boolean

class method DateTimeToMilliseconds(aDateTime: TDateTime): Int64

static Int64 DateTimeToMilliseconds(TDateTime aDateTime)

static func DateTimeToMilliseconds(_ aDateTime: TDateTime) -> Int64

static Int64 DateTimeToMilliseconds(TDateTime aDateTime)

Shared Function DateTimeToMilliseconds(aDateTime As TDateTime) As Int64

class method DateTimeToStr(DateTime: TDateTime): DelphiString

static DelphiString DateTimeToStr(TDateTime DateTime)

static func DateTimeToStr(_ DateTime: TDateTime) -> DelphiString

static DelphiString DateTimeToStr(TDateTime DateTime)

Shared Function DateTimeToStr(DateTime As TDateTime) As DelphiString

class method DateTimeToStr(DateTime: TDateTime; aFormatSettings: TFormatSettings): DelphiString

static DelphiString DateTimeToStr(TDateTime DateTime, TFormatSettings aFormatSettings)

static func DateTimeToStr(_ DateTime: TDateTime, _ aFormatSettings: TFormatSettings) -> DelphiString

static DelphiString DateTimeToStr(TDateTime DateTime, TFormatSettings aFormatSettings)

Shared Function DateTimeToStr(DateTime As TDateTime, aFormatSettings As TFormatSettings) As DelphiString

class method DateTimeToString(var aResult: DelphiString; Format: DelphiString; DateTime: TDateTime)

static void DateTimeToString(ref DelphiString aResult, DelphiString Format, TDateTime DateTime)

static func DateTimeToString(_ aResult: inout DelphiString, _ Format: DelphiString, _ DateTime: TDateTime)

static void DateTimeToString(__ref DelphiString aResult, DelphiString Format, TDateTime DateTime)

Shared Sub DateTimeToString(ByRef aResult As DelphiString, Format As DelphiString, DateTime As TDateTime)

class method DateTimeToString(var aResult: DelphiString; Format: DelphiString; DateTime: TDateTime; aFormatSettings: TFormatSettings)

static void DateTimeToString(ref DelphiString aResult, DelphiString Format, TDateTime DateTime, TFormatSettings aFormatSettings)

static func DateTimeToString(_ aResult: inout DelphiString, _ Format: DelphiString, _ DateTime: TDateTime, _ aFormatSettings: TFormatSettings)

static void DateTimeToString(__ref DelphiString aResult, DelphiString Format, TDateTime DateTime, TFormatSettings aFormatSettings)

Shared Sub DateTimeToString(ByRef aResult As DelphiString, Format As DelphiString, DateTime As TDateTime, aFormatSettings As TFormatSettings)

class method DateTimeToSystemTime(DateTime: TDateTime; var SystemTime: SYSTEMTIME)

static void DateTimeToSystemTime(TDateTime DateTime, ref SYSTEMTIME SystemTime)

static func DateTimeToSystemTime(_ DateTime: TDateTime, _ SystemTime: inout SYSTEMTIME)

Shared Sub DateTimeToSystemTime(DateTime As TDateTime, ByRef SystemTime As SYSTEMTIME)

class method DateTimeToTimeStamp(aDateTime: TDateTime): TTimeStamp

static TTimeStamp DateTimeToTimeStamp(TDateTime aDateTime)

static func DateTimeToTimeStamp(_ aDateTime: TDateTime) -> TTimeStamp

static TTimeStamp DateTimeToTimeStamp(TDateTime aDateTime)

Shared Function DateTimeToTimeStamp(aDateTime As TDateTime) As TTimeStamp

class method DateTimeToUnix(aValue: TDateTime): Int64

static Int64 DateTimeToUnix(TDateTime aValue)

static func DateTimeToUnix(_ aValue: TDateTime) -> Int64

static Int64 DateTimeToUnix(TDateTime aValue)

Shared Function DateTimeToUnix(aValue As TDateTime) As Int64

class method DateToStr(DateTime: TDateTime): DelphiString

static DelphiString DateToStr(TDateTime DateTime)

static func DateToStr(_ DateTime: TDateTime) -> DelphiString

static DelphiString DateToStr(TDateTime DateTime)

Shared Function DateToStr(DateTime As TDateTime) As DelphiString

class method DateToStr(DateTime: TDateTime; aFormatSettings: TFormatSettings): DelphiString

static DelphiString DateToStr(TDateTime DateTime, TFormatSettings aFormatSettings)

static func DateToStr(_ DateTime: TDateTime, _ aFormatSettings: TFormatSettings) -> DelphiString

static DelphiString DateToStr(TDateTime DateTime, TFormatSettings aFormatSettings)

Shared Function DateToStr(DateTime As TDateTime, aFormatSettings As TFormatSettings) As DelphiString

const DayFriday: Int32 = 5

const Int32 DayFriday = 5

static let DayFriday: Int32 = 5

static final Integer DayFriday = 5

Const DayFriday As Int32 = 5

const DayMonday: Int32 = 1

const Int32 DayMonday = 1

static let DayMonday: Int32 = 1

static final Integer DayMonday = 1

Const DayMonday As Int32 = 1

class method DayOf(aValue: TDateTime): UInt16

static UInt16 DayOf(TDateTime aValue)

static func DayOf(_ aValue: TDateTime) -> UInt16

static Word DayOf(TDateTime aValue)

Shared Function DayOf(aValue As TDateTime) As UInt16

class method DayOfTheMonth(aValue: TDateTime): UInt16

static UInt16 DayOfTheMonth(TDateTime aValue)

static func DayOfTheMonth(_ aValue: TDateTime) -> UInt16

static Word DayOfTheMonth(TDateTime aValue)

Shared Function DayOfTheMonth(aValue As TDateTime) As UInt16

class method DayOfTheWeek(aValue: TDateTime): UInt16

static UInt16 DayOfTheWeek(TDateTime aValue)

static func DayOfTheWeek(_ aValue: TDateTime) -> UInt16

static Word DayOfTheWeek(TDateTime aValue)

Shared Function DayOfTheWeek(aValue As TDateTime) As UInt16

class method DayOfTheYear(aValue: TDateTime): UInt16

static UInt16 DayOfTheYear(TDateTime aValue)

static func DayOfTheYear(_ aValue: TDateTime) -> UInt16

static Word DayOfTheYear(TDateTime aValue)

Shared Function DayOfTheYear(aValue As TDateTime) As UInt16

class method DayOfWeek(DateTime: TDateTime): UInt16

static UInt16 DayOfWeek(TDateTime DateTime)

static func DayOfWeek(_ DateTime: TDateTime) -> UInt16

static Word DayOfWeek(TDateTime DateTime)

Shared Function DayOfWeek(DateTime As TDateTime) As UInt16

const DaySaturday: Int32 = 6

const Int32 DaySaturday = 6

static let DaySaturday: Int32 = 6

static final Integer DaySaturday = 6

Const DaySaturday As Int32 = 6

class method DaysBetween(aNow: TDateTime; aThen: TDateTime): Int32

static Int32 DaysBetween(TDateTime aNow, TDateTime aThen)

static func DaysBetween(_ aNow: TDateTime, _ aThen: TDateTime) -> Int32

static Integer DaysBetween(TDateTime aNow, TDateTime aThen)

Shared Function DaysBetween(aNow As TDateTime, aThen As TDateTime) As Int32

class method DaysInAMonth(aYear: UInt16; aMonth: UInt16): UInt16

static UInt16 DaysInAMonth(UInt16 aYear, UInt16 aMonth)

static func DaysInAMonth(_ aYear: UInt16, _ aMonth: UInt16) -> UInt16

static Word DaysInAMonth(Word aYear, Word aMonth)

Shared Function DaysInAMonth(aYear As UInt16, aMonth As UInt16) As UInt16

class method DaysInAYear(aYear: UInt16): UInt16

static UInt16 DaysInAYear(UInt16 aYear)

static func DaysInAYear(_ aYear: UInt16) -> UInt16

static Word DaysInAYear(Word aYear)

Shared Function DaysInAYear(aYear As UInt16) As UInt16

class method DaysInMonth(aValue: TDateTime): UInt16

static UInt16 DaysInMonth(TDateTime aValue)

static func DaysInMonth(_ aValue: TDateTime) -> UInt16

static Word DaysInMonth(TDateTime aValue)

Shared Function DaysInMonth(aValue As TDateTime) As UInt16

class method DaysInYear(aValue: TDateTime): UInt16

static UInt16 DaysInYear(TDateTime aValue)

static func DaysInYear(_ aValue: TDateTime) -> UInt16

static Word DaysInYear(TDateTime aValue)

Shared Function DaysInYear(aValue As TDateTime) As UInt16

class method DaySpan(aNow: TDateTime; aThen: TDateTime): Double

static Double DaySpan(TDateTime aNow, TDateTime aThen)

static func DaySpan(_ aNow: TDateTime, _ aThen: TDateTime) -> Double

static Double DaySpan(TDateTime aNow, TDateTime aThen)

Shared Function DaySpan(aNow As TDateTime, aThen As TDateTime) As Double

const DaysPerWeek: Int32 = 7

const Int32 DaysPerWeek = 7

static let DaysPerWeek: Int32 = 7

static final Integer DaysPerWeek = 7

Const DaysPerWeek As Int32 = 7

class var DaysPerYear: array [0..1] of UInt16;

static array [0..1] of UInt16 DaysPerYear

static var DaysPerYear: array [0..1] of UInt16

static array [0..1] of Word DaysPerYear

Shared FIELD DaysPerYear() As array [0..1] of UInt16

const DaySunday: Int32 = 7

const Int32 DaySunday = 7

static let DaySunday: Int32 = 7

static final Integer DaySunday = 7

Const DaySunday As Int32 = 7

const DayThursday: Int32 = 4

const Int32 DayThursday = 4

static let DayThursday: Int32 = 4

static final Integer DayThursday = 4

Const DayThursday As Int32 = 4

const DayTuesday: Int32 = 2

const Int32 DayTuesday = 2

static let DayTuesday: Int32 = 2

static final Integer DayTuesday = 2

Const DayTuesday As Int32 = 2

const DayWednesday: Int32 = 3

const Int32 DayWednesday = 3

static let DayWednesday: Int32 = 3

static final Integer DayWednesday = 3

Const DayWednesday As Int32 = 3

class method DecodeDate(DateTime: TDateTime; var Year: UInt16; var Month: UInt16; var Day: UInt16)

static void DecodeDate(TDateTime DateTime, ref UInt16 Year, ref UInt16 Month, ref UInt16 Day)

static func DecodeDate(_ DateTime: TDateTime, _ Year: inout UInt16, _ Month: inout UInt16, _ Day: inout UInt16)

static void DecodeDate(TDateTime DateTime, __ref Word Year, __ref Word Month, __ref Word Day)

Shared Sub DecodeDate(DateTime As TDateTime, ByRef Year As UInt16, ByRef Month As UInt16, ByRef Day As UInt16)

class method DecodeDateDay(aValue: TDateTime; out aYear: UInt16; out aDayOfYear: UInt16)

static void DecodeDateDay(TDateTime aValue, out UInt16 aYear, out UInt16 aDayOfYear)

static func DecodeDateDay(_ aValue: TDateTime, _ aYear: inout UInt16, _ aDayOfYear: inout UInt16)

static void DecodeDateDay(TDateTime aValue, __out Word aYear, __out Word aDayOfYear)

Shared Sub DecodeDateDay(aValue As TDateTime, <OutAttribute> ByRef aYear As UInt16, <OutAttribute> ByRef aDayOfYear As UInt16)

class method DecodeDateFully(DateTime: TDateTime; var Year: UInt16; var Month: UInt16; var Day: UInt16; var DOW: UInt16): Boolean

static Boolean DecodeDateFully(TDateTime DateTime, ref UInt16 Year, ref UInt16 Month, ref UInt16 Day, ref UInt16 DOW)

static func DecodeDateFully(_ DateTime: TDateTime, _ Year: inout UInt16, _ Month: inout UInt16, _ Day: inout UInt16, _ DOW: inout UInt16) -> Boolean

static Boolean DecodeDateFully(TDateTime DateTime, __ref Word Year, __ref Word Month, __ref Word Day, __ref Word DOW)

Shared Function DecodeDateFully(DateTime As TDateTime, ByRef Year As UInt16, ByRef Month As UInt16, ByRef Day As UInt16, ByRef DOW As UInt16) As Boolean

class method DecodeDateTime(aValue: TDateTime; out aYear: UInt16; out aMonth: UInt16; out aDay: UInt16; out aHour: UInt16; out aMinute: UInt16; out aSecond: UInt16; out aMilliSecond: UInt16)

static void DecodeDateTime(TDateTime aValue, out UInt16 aYear, out UInt16 aMonth, out UInt16 aDay, out UInt16 aHour, out UInt16 aMinute, out UInt16 aSecond, out UInt16 aMilliSecond)

static func DecodeDateTime(_ aValue: TDateTime, _ aYear: inout UInt16, _ aMonth: inout UInt16, _ aDay: inout UInt16, _ aHour: inout UInt16, _ aMinute: inout UInt16, _ aSecond: inout UInt16, _ aMilliSecond: inout UInt16)

static void DecodeDateTime(TDateTime aValue, __out Word aYear, __out Word aMonth, __out Word aDay, __out Word aHour, __out Word aMinute, __out Word aSecond, __out Word aMilliSecond)

Shared Sub DecodeDateTime(aValue As TDateTime, <OutAttribute> ByRef aYear As UInt16, <OutAttribute> ByRef aMonth As UInt16, <OutAttribute> ByRef aDay As UInt16, <OutAttribute> ByRef aHour As UInt16, <OutAttribute> ByRef aMinute As UInt16, <OutAttribute> ByRef aSecond As UInt16, <OutAttribute> ByRef aMilliSecond As UInt16)

class method DecodeDayOfWeekInMonth(aValue: TDateTime; out aYear: UInt16; out aMonth: UInt16; out aNthDayOfWeek: UInt16; out aDayOfWeek: UInt16)

static void DecodeDayOfWeekInMonth(TDateTime aValue, out UInt16 aYear, out UInt16 aMonth, out UInt16 aNthDayOfWeek, out UInt16 aDayOfWeek)

static func DecodeDayOfWeekInMonth(_ aValue: TDateTime, _ aYear: inout UInt16, _ aMonth: inout UInt16, _ aNthDayOfWeek: inout UInt16, _ aDayOfWeek: inout UInt16)

static void DecodeDayOfWeekInMonth(TDateTime aValue, __out Word aYear, __out Word aMonth, __out Word aNthDayOfWeek, __out Word aDayOfWeek)

Shared Sub DecodeDayOfWeekInMonth(aValue As TDateTime, <OutAttribute> ByRef aYear As UInt16, <OutAttribute> ByRef aMonth As UInt16, <OutAttribute> ByRef aNthDayOfWeek As UInt16, <OutAttribute> ByRef aDayOfWeek As UInt16)

class method DecodeTime(DateTime: TDateTime; var aHour: UInt16; var aMin: UInt16; var aSec: UInt16; var aMSec: UInt16)

static void DecodeTime(TDateTime DateTime, ref UInt16 aHour, ref UInt16 aMin, ref UInt16 aSec, ref UInt16 aMSec)

static func DecodeTime(_ DateTime: TDateTime, _ aHour: inout UInt16, _ aMin: inout UInt16, _ aSec: inout UInt16, _ aMSec: inout UInt16)

static void DecodeTime(TDateTime DateTime, __ref Word aHour, __ref Word aMin, __ref Word aSec, __ref Word aMSec)

Shared Sub DecodeTime(DateTime As TDateTime, ByRef aHour As UInt16, ByRef aMin As UInt16, ByRef aSec As UInt16, ByRef aMSec As UInt16)

class method Delete(var S: DelphiString; aIndex: Int32; aCount: Int32)

static void Delete(ref DelphiString S, Int32 aIndex, Int32 aCount)

static func Delete(_ S: inout DelphiString, _ aIndex: Int32, _ aCount: Int32)

static void Delete(__ref DelphiString S, Integer aIndex, Integer aCount)

Shared Sub Delete(ByRef S As DelphiString, aIndex As Int32, aCount As Int32)

class method Delete<T>(var aDestination: array of T; aIndex: Int32; aCount: Int32 := 1)

static void Delete<T>(ref T[] aDestination, Int32 aIndex, Int32 aCount = 1)

static func Delete<T>(_ aDestination: inout T..., _ aIndex: Int32, _ aCount: Int32 = 1)

static void Delete<T>(__ref T[] aDestination, Integer aIndex, Integer aCount)

Shared Sub Delete<T>(ByRef aDestination As T(), aIndex As Int32, aCount As Int32 = 1)

class method DeleteA(var aString: AnsiString; aIndex: Int32; aCount: Int32)

static void DeleteA(ref AnsiString aString, Int32 aIndex, Int32 aCount)

static func DeleteA(_ aString: inout AnsiString, _ aIndex: Int32, _ aCount: Int32)

static void DeleteA(__ref AnsiString aString, Integer aIndex, Integer aCount)

Shared Sub DeleteA(ByRef aString As AnsiString, aIndex As Int32, aCount As Int32)

class method DeleteFile(FileName: DelphiString): Boolean

static Boolean DeleteFile(DelphiString FileName)

static func DeleteFile(_ FileName: DelphiString) -> Boolean

static Boolean DeleteFile(DelphiString FileName)

Shared Function DeleteFile(FileName As DelphiString) As Boolean

class method DirectoryExists(Directory: DelphiString; FollowLink: Boolean := true): Boolean

static Boolean DirectoryExists(DelphiString Directory, Boolean FollowLink = true)

static func DirectoryExists(_ Directory: DelphiString, _ FollowLink: Boolean = true) -> Boolean

static Boolean DirectoryExists(DelphiString Directory, Boolean FollowLink)

Shared Function DirectoryExists(Directory As DelphiString, FollowLink As Boolean = true) As Boolean

class method DiskFree(Drive: Byte): Int64

static Int64 DiskFree(Byte Drive)

static func DiskFree(_ Drive: Byte) -> Int64

Shared Function DiskFree(Drive As Byte) As Int64

class method DiskSize(Drive: Byte): Int64

static Int64 DiskSize(Byte Drive)

static func DiskSize(_ Drive: Byte) -> Int64

Shared Function DiskSize(Drive As Byte) As Int64

const doOwnsKeys: $Enum0 = 0

const $Enum0 doOwnsKeys = 0

static let doOwnsKeys: $Enum0 = 0

static final Integer doOwnsKeys = 0

Const doOwnsKeys As $Enum0 = 0

const doOwnsValues: $Enum0 = 1

const $Enum0 doOwnsValues = 1

static let doOwnsValues: $Enum0 = 1

static final Integer doOwnsValues = 1

Const doOwnsValues As $Enum0 = 1

// .NET, Island-Android, Island-iOS, Island-iOS Simulator, Island-Mac Catalyst, Island-macOS, Island-tvOS, Island-tvOS Simulator, Island-Ubuntu, Island-watchOS, Island-watchOS Simulator, Island-WebAssembly-wasm32
const DriveDelim: String = 
// Island-Windows
const DriveDelim: Char = ':'

// .NET, Island-Android, Island-iOS, Island-iOS Simulator, Island-Mac Catalyst, Island-macOS, Island-tvOS, Island-tvOS Simulator, Island-Ubuntu, Island-watchOS, Island-watchOS Simulator, Island-WebAssembly-wasm32
const String DriveDelim = ""
// Island-Windows
const Char DriveDelim = ':'

// .NET, Island-Android, Island-iOS, Island-iOS Simulator, Island-Mac Catalyst, Island-macOS, Island-tvOS, Island-tvOS Simulator, Island-Ubuntu, Island-watchOS, Island-watchOS Simulator, Island-WebAssembly-wasm32, Toffee
static let DriveDelim: String = ""
// Island-Windows
static let DriveDelim: Char = ':'

static final String DriveDelim

// .NET, Island-Android, Island-iOS, Island-iOS Simulator, Island-Mac Catalyst, Island-macOS, Island-tvOS, Island-tvOS Simulator, Island-Ubuntu, Island-watchOS, Island-watchOS Simulator, Island-WebAssembly-wasm32
Const DriveDelim As String = ""
// Island-Windows
Const DriveDelim As Char = ":"

const dupAccept: TDuplicates = TDuplicates.dupAccept

const TDuplicates dupAccept = TDuplicates.dupAccept

static let dupAccept: TDuplicates = TDuplicates.dupAccept

static final Integer dupAccept = 1

Const dupAccept As TDuplicates = TDuplicates.dupAccept

const dupError: TDuplicates = TDuplicates.dupError

const TDuplicates dupError = TDuplicates.dupError

static let dupError: TDuplicates = TDuplicates.dupError

static final Integer dupError = 2

Const dupError As TDuplicates = TDuplicates.dupError

const dupIgnore: TDuplicates = TDuplicates.dupIgnore

const TDuplicates dupIgnore = TDuplicates.dupIgnore

static let dupIgnore: TDuplicates = TDuplicates.dupIgnore

static final Integer dupIgnore = 0

Const dupIgnore As TDuplicates = TDuplicates.dupIgnore

class method EncodeDate(aYear: UInt16; aMonth: UInt16; aDay: UInt16): TDateTime

static TDateTime EncodeDate(UInt16 aYear, UInt16 aMonth, UInt16 aDay)

static func EncodeDate(_ aYear: UInt16, _ aMonth: UInt16, _ aDay: UInt16) -> TDateTime

static TDateTime EncodeDate(Word aYear, Word aMonth, Word aDay)

Shared Function EncodeDate(aYear As UInt16, aMonth As UInt16, aDay As UInt16) As TDateTime

class method EncodeDateDay(aYear: UInt16; aDayOfYear: UInt16): TDateTime

static TDateTime EncodeDateDay(UInt16 aYear, UInt16 aDayOfYear)

static func EncodeDateDay(_ aYear: UInt16, _ aDayOfYear: UInt16) -> TDateTime

static TDateTime EncodeDateDay(Word aYear, Word aDayOfYear)

Shared Function EncodeDateDay(aYear As UInt16, aDayOfYear As UInt16) As TDateTime

class method EncodeDateTime(aYear: UInt16; aMonth: UInt16; aDay: UInt16; aHour: UInt16; aMinute: UInt16; aSecond: UInt16; aMilliSecond: UInt16): TDateTime

static TDateTime EncodeDateTime(UInt16 aYear, UInt16 aMonth, UInt16 aDay, UInt16 aHour, UInt16 aMinute, UInt16 aSecond, UInt16 aMilliSecond)

static func EncodeDateTime(_ aYear: UInt16, _ aMonth: UInt16, _ aDay: UInt16, _ aHour: UInt16, _ aMinute: UInt16, _ aSecond: UInt16, _ aMilliSecond: UInt16) -> TDateTime

static TDateTime EncodeDateTime(Word aYear, Word aMonth, Word aDay, Word aHour, Word aMinute, Word aSecond, Word aMilliSecond)

Shared Function EncodeDateTime(aYear As UInt16, aMonth As UInt16, aDay As UInt16, aHour As UInt16, aMinute As UInt16, aSecond As UInt16, aMilliSecond As UInt16) As TDateTime

class method EncodeTime(aHour: UInt16; aMin: UInt16; aSec: UInt16; aMSec: UInt16): TDateTime

static TDateTime EncodeTime(UInt16 aHour, UInt16 aMin, UInt16 aSec, UInt16 aMSec)

static func EncodeTime(_ aHour: UInt16, _ aMin: UInt16, _ aSec: UInt16, _ aMSec: UInt16) -> TDateTime

static TDateTime EncodeTime(Word aHour, Word aMin, Word aSec, Word aMSec)

Shared Function EncodeTime(aHour As UInt16, aMin As UInt16, aSec As UInt16, aMSec As UInt16) As TDateTime

class method EndOfADay(aYear: UInt16; aDayOfYear: UInt16): TDateTime

static TDateTime EndOfADay(UInt16 aYear, UInt16 aDayOfYear)

static func EndOfADay(_ aYear: UInt16, _ aDayOfYear: UInt16) -> TDateTime

static TDateTime EndOfADay(Word aYear, Word aDayOfYear)

Shared Function EndOfADay(aYear As UInt16, aDayOfYear As UInt16) As TDateTime

class method EndOfADay(aYear: UInt16; aMonth: UInt16; aDay: UInt16): TDateTime

static TDateTime EndOfADay(UInt16 aYear, UInt16 aMonth, UInt16 aDay)

static func EndOfADay(_ aYear: UInt16, _ aMonth: UInt16, _ aDay: UInt16) -> TDateTime

static TDateTime EndOfADay(Word aYear, Word aMonth, Word aDay)

Shared Function EndOfADay(aYear As UInt16, aMonth As UInt16, aDay As UInt16) As TDateTime

class method EndOfAMonth(aYear: UInt16; aMonth: UInt16): TDateTime

static TDateTime EndOfAMonth(UInt16 aYear, UInt16 aMonth)

static func EndOfAMonth(_ aYear: UInt16, _ aMonth: UInt16) -> TDateTime

static TDateTime EndOfAMonth(Word aYear, Word aMonth)

Shared Function EndOfAMonth(aYear As UInt16, aMonth As UInt16) As TDateTime

class method EndOfAYear(aYear: UInt16): TDateTime

static TDateTime EndOfAYear(UInt16 aYear)

static func EndOfAYear(_ aYear: UInt16) -> TDateTime

static TDateTime EndOfAYear(Word aYear)

Shared Function EndOfAYear(aYear As UInt16) As TDateTime

class method EndOfTheDay(aValue: TDateTime): TDateTime

static TDateTime EndOfTheDay(TDateTime aValue)

static func EndOfTheDay(_ aValue: TDateTime) -> TDateTime

static TDateTime EndOfTheDay(TDateTime aValue)

Shared Function EndOfTheDay(aValue As TDateTime) As TDateTime

class method EndOfTheMonth(aValue: TDateTime): TDateTime

static TDateTime EndOfTheMonth(TDateTime aValue)

static func EndOfTheMonth(_ aValue: TDateTime) -> TDateTime

static TDateTime EndOfTheMonth(TDateTime aValue)

Shared Function EndOfTheMonth(aValue As TDateTime) As TDateTime

class method EndOfTheWeek(aValue: TDateTime): TDateTime

static TDateTime EndOfTheWeek(TDateTime aValue)

static func EndOfTheWeek(_ aValue: TDateTime) -> TDateTime

static TDateTime EndOfTheWeek(TDateTime aValue)

Shared Function EndOfTheWeek(aValue As TDateTime) As TDateTime

class method EndOfTheYear(aValue: TDateTime): TDateTime

static TDateTime EndOfTheYear(TDateTime aValue)

static func EndOfTheYear(_ aValue: TDateTime) -> TDateTime

static TDateTime EndOfTheYear(TDateTime aValue)

Shared Function EndOfTheYear(aValue As TDateTime) As TDateTime

class method EndsText(aSubText: AnsiString; aText: AnsiString): Boolean

static Boolean EndsText(AnsiString aSubText, AnsiString aText)

static func EndsText(_ aSubText: AnsiString, _ aText: AnsiString) -> Boolean

static Boolean EndsText(AnsiString aSubText, AnsiString aText)

Shared Function EndsText(aSubText As AnsiString, aText As AnsiString) As Boolean

const EpochAsJulianDate: Double = 2415018,5

const Double EpochAsJulianDate = 2415018,5

static let EpochAsJulianDate: Double = 2415018,5

static final Double EpochAsJulianDate = 2415018,5

Const EpochAsJulianDate As Double = 2415018,5

const EpochAsUnixDate: Int64 = -2209161600

const Int64 EpochAsUnixDate = -2209161600

static let EpochAsUnixDate: Int64 = -2209161600

static final Int64 EpochAsUnixDate = -2209161600

Const EpochAsUnixDate As Int64 = -2209161600

const EqualsValue: Int32 = 0

const Int32 EqualsValue = 0

static let EqualsValue: Int32 = 0

static final Integer EqualsValue = 0

Const EqualsValue As Int32 = 0

const ExcludeEmpty: TStringSplitOptions = TStringSplitOptions.ExcludeEmpty

const TStringSplitOptions ExcludeEmpty = TStringSplitOptions.ExcludeEmpty

static let ExcludeEmpty: TStringSplitOptions = TStringSplitOptions.ExcludeEmpty

static final Integer ExcludeEmpty = 1

Const ExcludeEmpty As TStringSplitOptions = TStringSplitOptions.ExcludeEmpty

class method ExcludeTrailingPathDelimiter(S: DelphiString): DelphiString

static DelphiString ExcludeTrailingPathDelimiter(DelphiString S)

static func ExcludeTrailingPathDelimiter(_ S: DelphiString) -> DelphiString

static DelphiString ExcludeTrailingPathDelimiter(DelphiString S)

Shared Function ExcludeTrailingPathDelimiter(S As DelphiString) As DelphiString

class method Exp(X: Double): Double

static Double Exp(Double X)

static func Exp(_ X: Double) -> Double

static Double Exp(Double X)

Shared Function Exp(X As Double) As Double

class method ExpandFileName(FileName: DelphiString): DelphiString

static DelphiString ExpandFileName(DelphiString FileName)

static func ExpandFileName(_ FileName: DelphiString) -> DelphiString

static DelphiString ExpandFileName(DelphiString FileName)

Shared Function ExpandFileName(FileName As DelphiString) As DelphiString

class method ExtractFileDir(FileName: DelphiString): DelphiString

static DelphiString ExtractFileDir(DelphiString FileName)

static func ExtractFileDir(_ FileName: DelphiString) -> DelphiString

static DelphiString ExtractFileDir(DelphiString FileName)

Shared Function ExtractFileDir(FileName As DelphiString) As DelphiString

class method ExtractFileDrive(FileName: DelphiString): DelphiString

static DelphiString ExtractFileDrive(DelphiString FileName)

static func ExtractFileDrive(_ FileName: DelphiString) -> DelphiString

static DelphiString ExtractFileDrive(DelphiString FileName)

Shared Function ExtractFileDrive(FileName As DelphiString) As DelphiString

class method ExtractFileExt(FileName: DelphiString): DelphiString

static DelphiString ExtractFileExt(DelphiString FileName)

static func ExtractFileExt(_ FileName: DelphiString) -> DelphiString

static DelphiString ExtractFileExt(DelphiString FileName)

Shared Function ExtractFileExt(FileName As DelphiString) As DelphiString

class method ExtractFileName(FileName: DelphiString): DelphiString

static DelphiString ExtractFileName(DelphiString FileName)

static func ExtractFileName(_ FileName: DelphiString) -> DelphiString

static DelphiString ExtractFileName(DelphiString FileName)

Shared Function ExtractFileName(FileName As DelphiString) As DelphiString

class method ExtractFilePath(FileName: DelphiString): DelphiString

static DelphiString ExtractFilePath(DelphiString FileName)

static func ExtractFilePath(_ FileName: DelphiString) -> DelphiString

static DelphiString ExtractFilePath(DelphiString FileName)

Shared Function ExtractFilePath(FileName As DelphiString) As DelphiString

class method FileClose(Handle: THandle)

static void FileClose(THandle Handle)

static func FileClose(_ Handle: THandle)

static void FileClose(THandle Handle)

Shared Sub FileClose(Handle As THandle)

class method FileCreate(FileName: String): THandle

static THandle FileCreate(String FileName)

static func FileCreate(_ FileName: String) -> THandle

static THandle FileCreate(String FileName)

Shared Function FileCreate(FileName As String) As THandle

class method FileCreate(FileName: String; Mode: UInt32; Rights: Int32): THandle

static THandle FileCreate(String FileName, UInt32 Mode, Int32 Rights)

static func FileCreate(_ FileName: String, _ Mode: UInt32, _ Rights: Int32) -> THandle

static THandle FileCreate(String FileName, Cardinal Mode, Integer Rights)

Shared Function FileCreate(FileName As String, Mode As UInt32, Rights As Int32) As THandle

class method FileCreate(FileName: String; Rights: Int32): THandle

static THandle FileCreate(String FileName, Int32 Rights)

static func FileCreate(_ FileName: String, _ Rights: Int32) -> THandle

static THandle FileCreate(String FileName, Integer Rights)

Shared Function FileCreate(FileName As String, Rights As Int32) As THandle

class method FileExists(FileName: DelphiString; FollowLink: Boolean := true): Boolean

static Boolean FileExists(DelphiString FileName, Boolean FollowLink = true)

static func FileExists(_ FileName: DelphiString, _ FollowLink: Boolean = true) -> Boolean

static Boolean FileExists(DelphiString FileName, Boolean FollowLink)

Shared Function FileExists(FileName As DelphiString, FollowLink As Boolean = true) As Boolean

class method FileGetAttr(FileName: DelphiString; FollowLink: Boolean := true): Int32

static Int32 FileGetAttr(DelphiString FileName, Boolean FollowLink = true)

static func FileGetAttr(_ FileName: DelphiString, _ FollowLink: Boolean = true) -> Int32

Shared Function FileGetAttr(FileName As DelphiString, FollowLink As Boolean = true) As Int32

class method FileOpen(FileName: DelphiString; Mode: UInt32): THandle

static THandle FileOpen(DelphiString FileName, UInt32 Mode)

static func FileOpen(_ FileName: DelphiString, _ Mode: UInt32) -> THandle

static THandle FileOpen(DelphiString FileName, Cardinal Mode)

Shared Function FileOpen(FileName As DelphiString, Mode As UInt32) As THandle

class method FileRead(Handle: THandle; var Buffer: array of Byte; Offset: UInt32; Count: UInt32): Int32

static Int32 FileRead(THandle Handle, ref Byte[] Buffer, UInt32 Offset, UInt32 Count)

static func FileRead(_ Handle: THandle, _ Buffer: inout Byte..., _ Offset: UInt32, _ Count: UInt32) -> Int32

static Integer FileRead(THandle Handle, __ref Byte[] Buffer, Cardinal Offset, Cardinal Count)

Shared Function FileRead(Handle As THandle, ByRef Buffer As Byte(), Offset As UInt32, Count As UInt32) As Int32

class method FileSeek(Handle: THandle; Offset: Int32; Origin: Int32): Int32

static Int32 FileSeek(THandle Handle, Int32 Offset, Int32 Origin)

static func FileSeek(_ Handle: THandle, _ Offset: Int32, _ Origin: Int32) -> Int32

static Integer FileSeek(THandle Handle, Integer Offset, Integer Origin)

Shared Function FileSeek(Handle As THandle, Offset As Int32, Origin As Int32) As Int32

class method FileSeek(Handle: THandle; Offset: Int64; Origin: Int32): Int64

static Int64 FileSeek(THandle Handle, Int64 Offset, Int32 Origin)

static func FileSeek(_ Handle: THandle, _ Offset: Int64, _ Origin: Int32) -> Int64

static Int64 FileSeek(THandle Handle, Int64 Offset, Integer Origin)

Shared Function FileSeek(Handle As THandle, Offset As Int64, Origin As Int32) As Int64

class method FileSetAttr(FileName: DelphiString; Attr: Int32; FollowLink: Boolean := true): Int32

static Int32 FileSetAttr(DelphiString FileName, Int32 Attr, Boolean FollowLink = true)

static func FileSetAttr(_ FileName: DelphiString, _ Attr: Int32, _ FollowLink: Boolean = true) -> Int32

Shared Function FileSetAttr(FileName As DelphiString, Attr As Int32, FollowLink As Boolean = true) As Int32

class method FileWrite(Handle: THandle; Buffer: array of Byte; Offset: UInt32; Count: UInt32): Int32

static Int32 FileWrite(THandle Handle, Byte[] Buffer, UInt32 Offset, UInt32 Count)

static func FileWrite(_ Handle: THandle, _ Buffer: Byte..., _ Offset: UInt32, _ Count: UInt32) -> Int32

static Integer FileWrite(THandle Handle, Byte[] Buffer, Cardinal Offset, Cardinal Count)

Shared Function FileWrite(Handle As THandle, Buffer As Byte(), Offset As UInt32, Count As UInt32) As Int32

class method FillChar(aDestination: ^Byte; aCount: Int32; aValue: Byte)

static void FillChar(Byte* aDestination, Int32 aCount, Byte aValue)

static func FillChar(_ aDestination: UnsafeMutablePointer<Byte>, _ aCount: Int32, _ aValue: Byte)

Shared Sub FillChar(aDestination As Ptr(Of Byte), aCount As Int32, aValue As Byte)

class method FillChar(var aArray: array of Byte; aValue: Byte)

static void FillChar(ref Byte[] aArray, Byte aValue)

static func FillChar(_ aArray: inout Byte..., _ aValue: Byte)

static void FillChar(__ref Byte[] aArray, Byte aValue)

Shared Sub FillChar(ByRef aArray As Byte(), aValue As Byte)

class method FillChar(var Dest: lifetimestrategy(void)Object; aCount: Int32; aValue: Byte)

static void FillChar(ref lifetimestrategy(void)Object Dest, Int32 aCount, Byte aValue)

static func FillChar(_ Dest: inout lifetimestrategy(void)NSObject, _ aCount: Int32, _ aValue: Byte)

Shared Sub FillChar(ByRef Dest As lifetimestrategy(void)Object, aCount As Int32, aValue As Byte)

class method FillChar(var Dest: Object; aCount: Int32; aValue: Byte)

static void FillChar(ref Object Dest, Int32 aCount, Byte aValue)

static func FillChar(_ Dest: inout Object, _ aCount: Int32, _ aValue: Byte)

static void FillChar(__ref Object Dest, Int32 aCount, Byte aValue)

Shared Sub FillChar(ByRef Dest As Object, aCount As Int32, aValue As Byte)

class method FillChar(var Dest: AnsiString; aCount: Int32; aValue: AnsiChar)

static void FillChar(ref AnsiString Dest, Int32 aCount, AnsiChar aValue)

static func FillChar(_ Dest: inout AnsiString, _ aCount: Int32, _ aValue: AnsiChar)

static void FillChar(__ref AnsiString Dest, Integer aCount, AnsiChar aValue)

Shared Sub FillChar(ByRef Dest As AnsiString, aCount As Int32, aValue As AnsiChar)

class method FillChar(var Dest: DelphiString; aCount: Int32; aValue: Char)

static void FillChar(ref DelphiString Dest, Int32 aCount, Char aValue)

static func FillChar(_ Dest: inout DelphiString, _ aCount: Int32, _ aValue: Char)

static void FillChar(__ref DelphiString Dest, Integer aCount, Char aValue)

Shared Sub FillChar(ByRef Dest As DelphiString, aCount As Int32, aValue As Char)

class method FloatToStr(Value: Double): String

static String FloatToStr(Double Value)

static func FloatToStr(_ Value: Double) -> String

static String FloatToStr(Double Value)

Shared Function FloatToStr(Value As Double) As String

class method Floor(X: Double): Int32

static Int32 Floor(Double X)

static func Floor(_ X: Double) -> Int32

static Integer Floor(Double X)

Shared Function Floor(X As Double) As Int32

const fmCreate: Int32 = 65280

const Int32 fmCreate = 65280

static let fmCreate: Int32 = 65280

static final Integer fmCreate = 65280

Const fmCreate As Int32 = 65280

const fmExclusive: Int32 = 4

const Int32 fmExclusive = 4

static let fmExclusive: Int32 = 4

static final Integer fmExclusive = 4

Const fmExclusive As Int32 = 4

const fmOpenRead: Int32 = 0

const Int32 fmOpenRead = 0

static let fmOpenRead: Int32 = 0

static final Integer fmOpenRead = 0

Const fmOpenRead As Int32 = 0

const fmOpenReadWrite: Int32 = 2

const Int32 fmOpenReadWrite = 2

static let fmOpenReadWrite: Int32 = 2

static final Integer fmOpenReadWrite = 2

Const fmOpenReadWrite As Int32 = 2

const fmOpenWrite: Int32 = 1

const Int32 fmOpenWrite = 1

static let fmOpenWrite: Int32 = 1

static final Integer fmOpenWrite = 1

Const fmOpenWrite As Int32 = 1

const FMSecsPerDay: Double = 86400000

const Double FMSecsPerDay = 86400000

static let FMSecsPerDay: Double = 86400000

static final Double FMSecsPerDay = 86400000

Const FMSecsPerDay As Double = 86400000

const fmShareCompat: Int32 = 0

const Int32 fmShareCompat = 0

static let fmShareCompat: Int32 = 0

static final Integer fmShareCompat = 0

Const fmShareCompat As Int32 = 0

const fmShareDenyNone: Int32 = 64

const Int32 fmShareDenyNone = 64

static let fmShareDenyNone: Int32 = 64

static final Integer fmShareDenyNone = 64

Const fmShareDenyNone As Int32 = 64

const fmShareDenyRead: Int32 = 48

const Int32 fmShareDenyRead = 48

static let fmShareDenyRead: Int32 = 48

static final Integer fmShareDenyRead = 48

Const fmShareDenyRead As Int32 = 48

const fmShareDenyWrite: Int32 = 32

const Int32 fmShareDenyWrite = 32

static let fmShareDenyWrite: Int32 = 32

static final Integer fmShareDenyWrite = 32

Const fmShareDenyWrite As Int32 = 32

const fmShareExclusive: Int32 = 16

const Int32 fmShareExclusive = 16

static let fmShareExclusive: Int32 = 16

static final Integer fmShareExclusive = 16

Const fmShareExclusive As Int32 = 16

class method ForceDirectories(Dir: DelphiString): Boolean

static Boolean ForceDirectories(DelphiString Dir)

static func ForceDirectories(_ Dir: DelphiString) -> Boolean

static Boolean ForceDirectories(DelphiString Dir)

Shared Function ForceDirectories(Dir As DelphiString) As Boolean

class method Format(AStr: String; Args: array of Object): String

static String Format(String AStr, Object[] Args)

static func Format(_ AStr: String, _ Args: Object...) -> String

static String Format(String AStr, Object[] Args)

Shared Function Format(AStr As String, Args As Object()) As String

class method FormatDateTime(Format: DelphiString; DateTime: TDateTime): DelphiString

static DelphiString FormatDateTime(DelphiString Format, TDateTime DateTime)

static func FormatDateTime(_ Format: DelphiString, _ DateTime: TDateTime) -> DelphiString

static DelphiString FormatDateTime(DelphiString Format, TDateTime DateTime)

Shared Function FormatDateTime(Format As DelphiString, DateTime As TDateTime) As DelphiString

class method FormatDateTime(Format: DelphiString; DateTime: TDateTime; aFormatSettings: TFormatSettings): DelphiString

static DelphiString FormatDateTime(DelphiString Format, TDateTime DateTime, TFormatSettings aFormatSettings)

static func FormatDateTime(_ Format: DelphiString, _ DateTime: TDateTime, _ aFormatSettings: TFormatSettings) -> DelphiString

static DelphiString FormatDateTime(DelphiString Format, TDateTime DateTime, TFormatSettings aFormatSettings)

Shared Function FormatDateTime(Format As DelphiString, DateTime As TDateTime, aFormatSettings As TFormatSettings) As DelphiString

class var FormatSettings: TFormatSettings;

static TFormatSettings FormatSettings

static var FormatSettings: TFormatSettings

static TFormatSettings FormatSettings

Shared FIELD FormatSettings() As TFormatSettings

class method Frac(X: Double): Double

static Double Frac(Double X)

static func Frac(_ X: Double) -> Double

static Double Frac(Double X)

Shared Function Frac(X As Double) As Double

class method FreeAndNil<T>(var AObject: T)

static void FreeAndNil<T>(ref T AObject)

static func FreeAndNil<T>(_ AObject: inout T)

static void FreeAndNil<T>(__ref +T AObject)

Shared Sub FreeAndNil<T>(ByRef AObject As T)

const FromBeginning: TDirection = TDirection.FromBeginning

const TDirection FromBeginning = TDirection.FromBeginning

static let FromBeginning: TDirection = TDirection.FromBeginning

static final Integer FromBeginning = 0

Const FromBeginning As TDirection = TDirection.FromBeginning

const FromEnd: TDirection = TDirection.FromEnd

const TDirection FromEnd = TDirection.FromEnd

static let FromEnd: TDirection = TDirection.FromEnd

static final Integer FromEnd = 1

Const FromEnd As TDirection = TDirection.FromEnd

class method GetCurrentDir: DelphiString

static DelphiString GetCurrentDir()

static func GetCurrentDir() -> DelphiString

static DelphiString GetCurrentDir()

Shared Function GetCurrentDir() As DelphiString

class method GetFormatSettings

static void GetFormatSettings()

static func GetFormatSettings()

static void GetFormatSettings()

Shared Sub GetFormatSettings()

class method GetHomePath: DelphiString

static DelphiString GetHomePath()

static func GetHomePath() -> DelphiString

static DelphiString GetHomePath()

Shared Function GetHomePath() As DelphiString

const GreaterThanValue: Int32 = 1

const Int32 GreaterThanValue = 1

static let GreaterThanValue: Int32 = 1

static final Integer GreaterThanValue = 1

Const GreaterThanValue As Int32 = 1

class method HourOf(aValue: TDateTime): UInt16

static UInt16 HourOf(TDateTime aValue)

static func HourOf(_ aValue: TDateTime) -> UInt16

static Word HourOf(TDateTime aValue)

Shared Function HourOf(aValue As TDateTime) As UInt16

class method HourOfTheDay(aValue: TDateTime): UInt16

static UInt16 HourOfTheDay(TDateTime aValue)

static func HourOfTheDay(_ aValue: TDateTime) -> UInt16

static Word HourOfTheDay(TDateTime aValue)

Shared Function HourOfTheDay(aValue As TDateTime) As UInt16

class method HourOfTheMonth(aValue: TDateTime): UInt16

static UInt16 HourOfTheMonth(TDateTime aValue)

static func HourOfTheMonth(_ aValue: TDateTime) -> UInt16

static Word HourOfTheMonth(TDateTime aValue)

Shared Function HourOfTheMonth(aValue As TDateTime) As UInt16

class method HourOfTheWeek(aValue: TDateTime): UInt16

static UInt16 HourOfTheWeek(TDateTime aValue)

static func HourOfTheWeek(_ aValue: TDateTime) -> UInt16

static Word HourOfTheWeek(TDateTime aValue)

Shared Function HourOfTheWeek(aValue As TDateTime) As UInt16

class method HourOfTheYear(aValue: TDateTime): UInt16

static UInt16 HourOfTheYear(TDateTime aValue)

static func HourOfTheYear(_ aValue: TDateTime) -> UInt16

static Word HourOfTheYear(TDateTime aValue)

Shared Function HourOfTheYear(aValue As TDateTime) As UInt16

class method HoursBetween(aNow: TDateTime; aThen: TDateTime): Int64

static Int64 HoursBetween(TDateTime aNow, TDateTime aThen)

static func HoursBetween(_ aNow: TDateTime, _ aThen: TDateTime) -> Int64

static Int64 HoursBetween(TDateTime aNow, TDateTime aThen)

Shared Function HoursBetween(aNow As TDateTime, aThen As TDateTime) As Int64

class method HourSpan(aNow: TDateTime; aThen: TDateTime): Double

static Double HourSpan(TDateTime aNow, TDateTime aThen)

static func HourSpan(_ aNow: TDateTime, _ aThen: TDateTime) -> Double

static Double HourSpan(TDateTime aNow, TDateTime aThen)

Shared Function HourSpan(aNow As TDateTime, aThen As TDateTime) As Double

const HoursPerDay: Int32 = 24

const Int32 HoursPerDay = 24

static let HoursPerDay: Int32 = 24

static final Integer HoursPerDay = 24

Const HoursPerDay As Int32 = 24

class method IncAMonth(var Year: UInt16; var Month: UInt16; var Day: UInt16; NumberOfMonths: Int32 := 1)

static void IncAMonth(ref UInt16 Year, ref UInt16 Month, ref UInt16 Day, Int32 NumberOfMonths = 1)

static func IncAMonth(_ Year: inout UInt16, _ Month: inout UInt16, _ Day: inout UInt16, _ NumberOfMonths: Int32 = 1)

static void IncAMonth(__ref Word Year, __ref Word Month, __ref Word Day, Integer NumberOfMonths)

Shared Sub IncAMonth(ByRef Year As UInt16, ByRef Month As UInt16, ByRef Day As UInt16, NumberOfMonths As Int32 = 1)

class method IncDay(aValue: TDateTime; aNumberOfDays: Int32 := 1): TDateTime

static TDateTime IncDay(TDateTime aValue, Int32 aNumberOfDays = 1)

static func IncDay(_ aValue: TDateTime, _ aNumberOfDays: Int32 = 1) -> TDateTime

static TDateTime IncDay(TDateTime aValue, Integer aNumberOfDays)

Shared Function IncDay(aValue As TDateTime, aNumberOfDays As Int32 = 1) As TDateTime

class method IncHour(aValue: TDateTime; aNumberOfHours: Int64 := 1): TDateTime

static TDateTime IncHour(TDateTime aValue, Int64 aNumberOfHours = 1)

static func IncHour(_ aValue: TDateTime, _ aNumberOfHours: Int64 = 1) -> TDateTime

static TDateTime IncHour(TDateTime aValue, Int64 aNumberOfHours)

Shared Function IncHour(aValue As TDateTime, aNumberOfHours As Int64 = 1) As TDateTime

class method IncludeTrailingPathDelimiter(S: DelphiString): DelphiString

static DelphiString IncludeTrailingPathDelimiter(DelphiString S)

static func IncludeTrailingPathDelimiter(_ S: DelphiString) -> DelphiString

static DelphiString IncludeTrailingPathDelimiter(DelphiString S)

Shared Function IncludeTrailingPathDelimiter(S As DelphiString) As DelphiString

class method IncMilliSecond(aValue: TDateTime; aNumberOfMilliSeconds: Int64 := 1): TDateTime

static TDateTime IncMilliSecond(TDateTime aValue, Int64 aNumberOfMilliSeconds = 1)

static func IncMilliSecond(_ aValue: TDateTime, _ aNumberOfMilliSeconds: Int64 = 1) -> TDateTime

static TDateTime IncMilliSecond(TDateTime aValue, Int64 aNumberOfMilliSeconds)

Shared Function IncMilliSecond(aValue As TDateTime, aNumberOfMilliSeconds As Int64 = 1) As TDateTime

class method IncMinute(aValue: TDateTime; aNumberOfMinutes: Int64 := 1): TDateTime

static TDateTime IncMinute(TDateTime aValue, Int64 aNumberOfMinutes = 1)

static func IncMinute(_ aValue: TDateTime, _ aNumberOfMinutes: Int64 = 1) -> TDateTime

static TDateTime IncMinute(TDateTime aValue, Int64 aNumberOfMinutes)

Shared Function IncMinute(aValue As TDateTime, aNumberOfMinutes As Int64 = 1) As TDateTime

class method IncMonth(DateTime: TDateTime; NumberOfMonths: Int32 := 1): TDateTime

static TDateTime IncMonth(TDateTime DateTime, Int32 NumberOfMonths = 1)

static func IncMonth(_ DateTime: TDateTime, _ NumberOfMonths: Int32 = 1) -> TDateTime

static TDateTime IncMonth(TDateTime DateTime, Integer NumberOfMonths)

Shared Function IncMonth(DateTime As TDateTime, NumberOfMonths As Int32 = 1) As TDateTime

class method IncSecond(aValue: TDateTime; aNumberOfSeconds: Int64 := 1): TDateTime

static TDateTime IncSecond(TDateTime aValue, Int64 aNumberOfSeconds = 1)

static func IncSecond(_ aValue: TDateTime, _ aNumberOfSeconds: Int64 = 1) -> TDateTime

static TDateTime IncSecond(TDateTime aValue, Int64 aNumberOfSeconds)

Shared Function IncSecond(aValue As TDateTime, aNumberOfSeconds As Int64 = 1) As TDateTime

class method IncWeek(aValue: TDateTime; aNumberOfWeeks: Int32 := 1): TDateTime

static TDateTime IncWeek(TDateTime aValue, Int32 aNumberOfWeeks = 1)

static func IncWeek(_ aValue: TDateTime, _ aNumberOfWeeks: Int32 = 1) -> TDateTime

static TDateTime IncWeek(TDateTime aValue, Integer aNumberOfWeeks)

Shared Function IncWeek(aValue As TDateTime, aNumberOfWeeks As Int32 = 1) As TDateTime

class method IncYear(aValue: TDateTime; aNumberOfYears: Int32 := 1): TDateTime

static TDateTime IncYear(TDateTime aValue, Int32 aNumberOfYears = 1)

static func IncYear(_ aValue: TDateTime, _ aNumberOfYears: Int32 = 1) -> TDateTime

static TDateTime IncYear(TDateTime aValue, Integer aNumberOfYears)

Shared Function IncYear(aValue As TDateTime, aNumberOfYears As Int32 = 1) As TDateTime

class method Insert(aSource: AnsiString; var aDest: AnsiString; aIndex: Int32)

static void Insert(AnsiString aSource, ref AnsiString aDest, Int32 aIndex)

static func Insert(_ aSource: AnsiString, _ aDest: inout AnsiString, _ aIndex: Int32)

static void Insert(AnsiString aSource, __ref AnsiString aDest, Integer aIndex)

Shared Sub Insert(aSource As AnsiString, ByRef aDest As AnsiString, aIndex As Int32)

class method Insert(aSource: DelphiString; var aTarget: DelphiString; aOffset: Int32)

static void Insert(DelphiString aSource, ref DelphiString aTarget, Int32 aOffset)

static func Insert(_ aSource: DelphiString, _ aTarget: inout DelphiString, _ aOffset: Int32)

static void Insert(DelphiString aSource, __ref DelphiString aTarget, Integer aOffset)

Shared Sub Insert(aSource As DelphiString, ByRef aTarget As DelphiString, aOffset As Int32)

class method Insert(aSource: PlatformString; var aTarget: PlatformString; aOffset: Int32)

static void Insert(PlatformString aSource, ref PlatformString aTarget, Int32 aOffset)

static func Insert(_ aSource: PlatformString, _ aTarget: inout PlatformString, _ aOffset: Int32)

static void Insert(PlatformString aSource, __ref PlatformString aTarget, Integer aOffset)

Shared Sub Insert(aSource As PlatformString, ByRef aTarget As PlatformString, aOffset As Int32)

class method Insert<T>(aSource: array of T; var aDestination: array of T; aIndex: Int32)

static void Insert<T>(T[] aSource, ref T[] aDestination, Int32 aIndex)

static func Insert<T>(_ aSource: T..., _ aDestination: inout T..., _ aIndex: Int32)

static void Insert<T>(T[] aSource, __ref T[] aDestination, Integer aIndex)

Shared Sub Insert<T>(aSource As T(), ByRef aDestination As T(), aIndex As Int32)

class method Insert<T>(aSource: T; var aDestination: array of T; aIndex: Int32)

static void Insert<T>(T aSource, ref T[] aDestination, Int32 aIndex)

static func Insert<T>(_ aSource: T, _ aDestination: inout T..., _ aIndex: Int32)

static void Insert<T>(T aSource, __ref T[] aDestination, Integer aIndex)

Shared Sub Insert<T>(aSource As T, ByRef aDestination As T(), aIndex As Int32)

class method InterlockedDecrement(var Addend: Int32): Int32

static Int32 InterlockedDecrement(ref Int32 Addend)

static func InterlockedDecrement(_ Addend: inout Int32) -> Int32

Shared Function InterlockedDecrement(ByRef Addend As Int32) As Int32

class method InterlockedIncrement(var Addend: Int32): Int32

static Int32 InterlockedIncrement(ref Int32 Addend)

static func InterlockedIncrement(_ Addend: inout Int32) -> Int32

Shared Function InterlockedIncrement(ByRef Addend As Int32) As Int32

class method IntToHex(Value: Int32; Digits: Int32 := 8): DelphiString

static DelphiString IntToHex(Int32 Value, Int32 Digits = 8)

static func IntToHex(_ Value: Int32, _ Digits: Int32 = 8) -> DelphiString

static DelphiString IntToHex(Integer Value, Integer Digits)

Shared Function IntToHex(Value As Int32, Digits As Int32 = 8) As DelphiString

class method IntToHex(Value: Int64; Digits: Int32 := 16): DelphiString

static DelphiString IntToHex(Int64 Value, Int32 Digits = 16)

static func IntToHex(_ Value: Int64, _ Digits: Int32 = 16) -> DelphiString

static DelphiString IntToHex(Int64 Value, Integer Digits)

Shared Function IntToHex(Value As Int64, Digits As Int32 = 16) As DelphiString

class method IntToHex(Value: UInt64; Digits: Int32 := 16): DelphiString

static DelphiString IntToHex(UInt64 Value, Int32 Digits = 16)

static func IntToHex(_ Value: UInt64, _ Digits: Int32 = 16) -> DelphiString

Shared Function IntToHex(Value As UInt64, Digits As Int32 = 16) As DelphiString

class method IntToStr(Value: Int32): DelphiString

static DelphiString IntToStr(Int32 Value)

static func IntToStr(_ Value: Int32) -> DelphiString

static DelphiString IntToStr(Integer Value)

Shared Function IntToStr(Value As Int32) As DelphiString

class method IntToStr(Value: Int64): DelphiString

static DelphiString IntToStr(Int64 Value)

static func IntToStr(_ Value: Int64) -> DelphiString

static DelphiString IntToStr(Int64 Value)

Shared Function IntToStr(Value As Int64) As DelphiString

// .NET
const INVALID_HANDLE_VALUE: Int64 = -1
// Island
const INVALID_HANDLE_VALUE: THandle = -1

// .NET
const Int64 INVALID_HANDLE_VALUE = -1
// Island
const THandle INVALID_HANDLE_VALUE = -1

// .NET
static let INVALID_HANDLE_VALUE: Int64 = -1
// Island, Toffee
static let INVALID_HANDLE_VALUE: THandle = -1

static final Int64 INVALID_HANDLE_VALUE = -1

// .NET
Const INVALID_HANDLE_VALUE As Int64 = -1
// Island
Const INVALID_HANDLE_VALUE As THandle = -1

class method IsAM(aValue: TDateTime): Boolean

static Boolean IsAM(TDateTime aValue)

static func IsAM(_ aValue: TDateTime) -> Boolean

static Boolean IsAM(TDateTime aValue)

Shared Function IsAM(aValue As TDateTime) As Boolean

class method IsDelimiter(Delimiters: DelphiString; S: DelphiString; aIndex: Int32): Boolean

static Boolean IsDelimiter(DelphiString Delimiters, DelphiString S, Int32 aIndex)

static func IsDelimiter(_ Delimiters: DelphiString, _ S: DelphiString, _ aIndex: Int32) -> Boolean

static Boolean IsDelimiter(DelphiString Delimiters, DelphiString S, Integer aIndex)

Shared Function IsDelimiter(Delimiters As DelphiString, S As DelphiString, aIndex As Int32) As Boolean

class method IsInfinite(AValue: Double): Boolean

static Boolean IsInfinite(Double AValue)

static func IsInfinite(_ AValue: Double) -> Boolean

static Boolean IsInfinite(Double AValue)

Shared Function IsInfinite(AValue As Double) As Boolean

class method IsInLeapYear(aValue: TDateTime): Boolean

static Boolean IsInLeapYear(TDateTime aValue)

static func IsInLeapYear(_ aValue: TDateTime) -> Boolean

static Boolean IsInLeapYear(TDateTime aValue)

Shared Function IsInLeapYear(aValue As TDateTime) As Boolean

class method IsLeapYear(Year: UInt16): Boolean

static Boolean IsLeapYear(UInt16 Year)

static func IsLeapYear(_ Year: UInt16) -> Boolean

static Boolean IsLeapYear(Word Year)

Shared Function IsLeapYear(Year As UInt16) As Boolean

class method IsPM(aValue: TDateTime): Boolean

static Boolean IsPM(TDateTime aValue)

static func IsPM(_ aValue: TDateTime) -> Boolean

static Boolean IsPM(TDateTime aValue)

Shared Function IsPM(aValue As TDateTime) As Boolean

class method IsRelativePath(Path: DelphiString): Boolean

static Boolean IsRelativePath(DelphiString Path)

static func IsRelativePath(_ Path: DelphiString) -> Boolean

static Boolean IsRelativePath(DelphiString Path)

Shared Function IsRelativePath(Path As DelphiString) As Boolean

class method IsSameDay(aValue: TDateTime; aBasis: TDateTime): Boolean

static Boolean IsSameDay(TDateTime aValue, TDateTime aBasis)

static func IsSameDay(_ aValue: TDateTime, _ aBasis: TDateTime) -> Boolean

static Boolean IsSameDay(TDateTime aValue, TDateTime aBasis)

Shared Function IsSameDay(aValue As TDateTime, aBasis As TDateTime) As Boolean

class method IsToday(aValue: TDateTime): Boolean

static Boolean IsToday(TDateTime aValue)

static func IsToday(_ aValue: TDateTime) -> Boolean

static Boolean IsToday(TDateTime aValue)

Shared Function IsToday(aValue As TDateTime) As Boolean

class method IsValidDate(aYear: UInt16; aMonth: UInt16; aDay: UInt16): Boolean

static Boolean IsValidDate(UInt16 aYear, UInt16 aMonth, UInt16 aDay)

static func IsValidDate(_ aYear: UInt16, _ aMonth: UInt16, _ aDay: UInt16) -> Boolean

static Boolean IsValidDate(Word aYear, Word aMonth, Word aDay)

Shared Function IsValidDate(aYear As UInt16, aMonth As UInt16, aDay As UInt16) As Boolean

class method IsValidDateDay(aYear: UInt16; aDayOfYear: UInt16): Boolean

static Boolean IsValidDateDay(UInt16 aYear, UInt16 aDayOfYear)

static func IsValidDateDay(_ aYear: UInt16, _ aDayOfYear: UInt16) -> Boolean

static Boolean IsValidDateDay(Word aYear, Word aDayOfYear)

Shared Function IsValidDateDay(aYear As UInt16, aDayOfYear As UInt16) As Boolean

class method IsValidDateMonthWeek(aYear: UInt16; aMonth: UInt16; aWeekOfMonth: UInt16; aDayOfWeek: UInt16): Boolean

static Boolean IsValidDateMonthWeek(UInt16 aYear, UInt16 aMonth, UInt16 aWeekOfMonth, UInt16 aDayOfWeek)

static func IsValidDateMonthWeek(_ aYear: UInt16, _ aMonth: UInt16, _ aWeekOfMonth: UInt16, _ aDayOfWeek: UInt16) -> Boolean

static Boolean IsValidDateMonthWeek(Word aYear, Word aMonth, Word aWeekOfMonth, Word aDayOfWeek)

Shared Function IsValidDateMonthWeek(aYear As UInt16, aMonth As UInt16, aWeekOfMonth As UInt16, aDayOfWeek As UInt16) As Boolean

class method IsValidDateTime(aYear: UInt16; aMonth: UInt16; aDay: UInt16; aHour: UInt16; aMinute: UInt16; aSecond: UInt16; aMilliSecond: UInt16): Boolean

static Boolean IsValidDateTime(UInt16 aYear, UInt16 aMonth, UInt16 aDay, UInt16 aHour, UInt16 aMinute, UInt16 aSecond, UInt16 aMilliSecond)

static func IsValidDateTime(_ aYear: UInt16, _ aMonth: UInt16, _ aDay: UInt16, _ aHour: UInt16, _ aMinute: UInt16, _ aSecond: UInt16, _ aMilliSecond: UInt16) -> Boolean

static Boolean IsValidDateTime(Word aYear, Word aMonth, Word aDay, Word aHour, Word aMinute, Word aSecond, Word aMilliSecond)

Shared Function IsValidDateTime(aYear As UInt16, aMonth As UInt16, aDay As UInt16, aHour As UInt16, aMinute As UInt16, aSecond As UInt16, aMilliSecond As UInt16) As Boolean

class method IsValidDateWeek(aYear: UInt16; aWeekOfYear: UInt16; aDayOfWeek: UInt16): Boolean

static Boolean IsValidDateWeek(UInt16 aYear, UInt16 aWeekOfYear, UInt16 aDayOfWeek)

static func IsValidDateWeek(_ aYear: UInt16, _ aWeekOfYear: UInt16, _ aDayOfWeek: UInt16) -> Boolean

static Boolean IsValidDateWeek(Word aYear, Word aWeekOfYear, Word aDayOfWeek)

Shared Function IsValidDateWeek(aYear As UInt16, aWeekOfYear As UInt16, aDayOfWeek As UInt16) As Boolean

class method IsValidTime(aHour: UInt16; aMinute: UInt16; aSecond: UInt16; aMilliSecond: UInt16): Boolean

static Boolean IsValidTime(UInt16 aHour, UInt16 aMinute, UInt16 aSecond, UInt16 aMilliSecond)

static func IsValidTime(_ aHour: UInt16, _ aMinute: UInt16, _ aSecond: UInt16, _ aMilliSecond: UInt16) -> Boolean

static Boolean IsValidTime(Word aHour, Word aMinute, Word aSecond, Word aMilliSecond)

Shared Function IsValidTime(aHour As UInt16, aMinute As UInt16, aSecond As UInt16, aMilliSecond As UInt16) As Boolean

class method LastDelimiter(Delimiters: DelphiString; S: DelphiString): Int32

static Int32 LastDelimiter(DelphiString Delimiters, DelphiString S)

static func LastDelimiter(_ Delimiters: DelphiString, _ S: DelphiString) -> Int32

static Integer LastDelimiter(DelphiString Delimiters, DelphiString S)

Shared Function LastDelimiter(Delimiters As DelphiString, S As DelphiString) As Int32

const LessThanValue: Int32 = -1

const Int32 LessThanValue = -1

static let LessThanValue: Int32 = -1

static final Integer LessThanValue = -1

Const LessThanValue As Int32 = -1

class method Log10(X: Double): Double

static Double Log10(Double X)

static func Log10(_ X: Double) -> Double

static Double Log10(Double X)

Shared Function Log10(X As Double) As Double

const loInvariantLocale: TLocaleOptions = TLocaleOptions.loInvariantLocale

const TLocaleOptions loInvariantLocale = TLocaleOptions.loInvariantLocale

static let loInvariantLocale: TLocaleOptions = TLocaleOptions.loInvariantLocale

static final Integer loInvariantLocale = 0

Const loInvariantLocale As TLocaleOptions = TLocaleOptions.loInvariantLocale

const loUserLocale: TLocaleOptions = TLocaleOptions.loUserLocale

const TLocaleOptions loUserLocale = TLocaleOptions.loUserLocale

static let loUserLocale: TLocaleOptions = TLocaleOptions.loUserLocale

static final Integer loUserLocale = 1

Const loUserLocale As TLocaleOptions = TLocaleOptions.loUserLocale

class method LowerCase(S: AnsiString): AnsiString

static AnsiString LowerCase(AnsiString S)

static func LowerCase(_ S: AnsiString) -> AnsiString

static AnsiString LowerCase(AnsiString S)

Shared Function LowerCase(S As AnsiString) As AnsiString

class method LowerCase(S: DelphiString): DelphiString

static DelphiString LowerCase(DelphiString S)

static func LowerCase(_ S: DelphiString) -> DelphiString

static DelphiString LowerCase(DelphiString S)

Shared Function LowerCase(S As DelphiString) As DelphiString

class method LowerCase(S: DelphiString; LocaleOptions: TLocaleOptions): DelphiString

static DelphiString LowerCase(DelphiString S, TLocaleOptions LocaleOptions)

static func LowerCase(_ S: DelphiString, _ LocaleOptions: TLocaleOptions) -> DelphiString

static DelphiString LowerCase(DelphiString S, TLocaleOptions LocaleOptions)

Shared Function LowerCase(S As DelphiString, LocaleOptions As TLocaleOptions) As DelphiString

class method LowerCase(S: PlatformString): DelphiString

static DelphiString LowerCase(PlatformString S)

static func LowerCase(_ S: PlatformString) -> DelphiString

static DelphiString LowerCase(PlatformString S)

Shared Function LowerCase(S As PlatformString) As DelphiString

class method Max(A: Double; B: Double): Double

static Double Max(Double A, Double B)

static func Max(_ A: Double, _ B: Double) -> Double

static Double Max(Double A, Double B)

Shared Function Max(A As Double, B As Double) As Double

class method Max(A: Int32; B: Int32): Int32

static Int32 Max(Int32 A, Int32 B)

static func Max(_ A: Int32, _ B: Int32) -> Int32

static Integer Max(Integer A, Integer B)

Shared Function Max(A As Int32, B As Int32) As Int32

class method Max(A: Int64; B: Int64): Int64

static Int64 Max(Int64 A, Int64 B)

static func Max(_ A: Int64, _ B: Int64) -> Int64

static Int64 Max(Int64 A, Int64 B)

Shared Function Max(A As Int64, B As Int64) As Int64

const mbLeft: TMouseButton = TMouseButton.mbLeft

const TMouseButton mbLeft = TMouseButton.mbLeft

static let mbLeft: TMouseButton = TMouseButton.mbLeft

static final Integer mbLeft = 0

Const mbLeft As TMouseButton = TMouseButton.mbLeft

const mbMiddle: TMouseButton = TMouseButton.mbMiddle

const TMouseButton mbMiddle = TMouseButton.mbMiddle

static let mbMiddle: TMouseButton = TMouseButton.mbMiddle

static final Integer mbMiddle = 2

Const mbMiddle As TMouseButton = TMouseButton.mbMiddle

const mbRight: TMouseButton = TMouseButton.mbRight

const TMouseButton mbRight = TMouseButton.mbRight

static let mbRight: TMouseButton = TMouseButton.mbRight

static final Integer mbRight = 1

Const mbRight As TMouseButton = TMouseButton.mbRight

class method MilliSecondOf(aValue: TDateTime): UInt16

static UInt16 MilliSecondOf(TDateTime aValue)

static func MilliSecondOf(_ aValue: TDateTime) -> UInt16

static Word MilliSecondOf(TDateTime aValue)

Shared Function MilliSecondOf(aValue As TDateTime) As UInt16

class method MilliSecondOfTheDay(aValue: TDateTime): UInt32

static UInt32 MilliSecondOfTheDay(TDateTime aValue)

static func MilliSecondOfTheDay(_ aValue: TDateTime) -> UInt32

static Cardinal MilliSecondOfTheDay(TDateTime aValue)

Shared Function MilliSecondOfTheDay(aValue As TDateTime) As UInt32

class method MilliSecondOfTheHour(aValue: TDateTime): UInt32

static UInt32 MilliSecondOfTheHour(TDateTime aValue)

static func MilliSecondOfTheHour(_ aValue: TDateTime) -> UInt32

static Cardinal MilliSecondOfTheHour(TDateTime aValue)

Shared Function MilliSecondOfTheHour(aValue As TDateTime) As UInt32

class method MilliSecondOfTheMinute(aValue: TDateTime): UInt32

static UInt32 MilliSecondOfTheMinute(TDateTime aValue)

static func MilliSecondOfTheMinute(_ aValue: TDateTime) -> UInt32

static Cardinal MilliSecondOfTheMinute(TDateTime aValue)

Shared Function MilliSecondOfTheMinute(aValue As TDateTime) As UInt32

class method MilliSecondOfTheMonth(aValue: TDateTime): UInt32

static UInt32 MilliSecondOfTheMonth(TDateTime aValue)

static func MilliSecondOfTheMonth(_ aValue: TDateTime) -> UInt32

static Cardinal MilliSecondOfTheMonth(TDateTime aValue)

Shared Function MilliSecondOfTheMonth(aValue As TDateTime) As UInt32

class method MilliSecondOfTheSecond(aValue: TDateTime): UInt16

static UInt16 MilliSecondOfTheSecond(TDateTime aValue)

static func MilliSecondOfTheSecond(_ aValue: TDateTime) -> UInt16

static Word MilliSecondOfTheSecond(TDateTime aValue)

Shared Function MilliSecondOfTheSecond(aValue As TDateTime) As UInt16

class method MilliSecondOfTheWeek(aValue: TDateTime): UInt32

static UInt32 MilliSecondOfTheWeek(TDateTime aValue)

static func MilliSecondOfTheWeek(_ aValue: TDateTime) -> UInt32

static Cardinal MilliSecondOfTheWeek(TDateTime aValue)

Shared Function MilliSecondOfTheWeek(aValue As TDateTime) As UInt32

class method MilliSecondOfTheYear(aValue: TDateTime): Int64

static Int64 MilliSecondOfTheYear(TDateTime aValue)

static func MilliSecondOfTheYear(_ aValue: TDateTime) -> Int64

static Int64 MilliSecondOfTheYear(TDateTime aValue)

Shared Function MilliSecondOfTheYear(aValue As TDateTime) As Int64

class method MilliSecondsBetween(aNow: TDateTime; aThen: TDateTime): Int64

static Int64 MilliSecondsBetween(TDateTime aNow, TDateTime aThen)

static func MilliSecondsBetween(_ aNow: TDateTime, _ aThen: TDateTime) -> Int64

static Int64 MilliSecondsBetween(TDateTime aNow, TDateTime aThen)

Shared Function MilliSecondsBetween(aNow As TDateTime, aThen As TDateTime) As Int64