david
13eee3f7f4
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.jcl@20 c37d764d-f447-7644-a108-883140d013fb
4528 lines
187 KiB
ObjectPascal
4528 lines
187 KiB
ObjectPascal
{**************************************************************************************************}
|
|
{ WARNING: JEDI preprocessor generated unit. Do not edit. }
|
|
{**************************************************************************************************}
|
|
|
|
{**************************************************************************************************}
|
|
{ }
|
|
{ Project JEDI Code Library (JCL) }
|
|
{ }
|
|
{ The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); }
|
|
{ you may not use this file except in compliance with the License. You may obtain a copy of the }
|
|
{ License at http://www.mozilla.org/MPL/ }
|
|
{ }
|
|
{ Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF }
|
|
{ ANY KIND, either express or implied. See the License for the specific language governing rights }
|
|
{ and limitations under the License. }
|
|
{ }
|
|
{ The Original Code is DCL_intf.pas. }
|
|
{ }
|
|
{ The Initial Developer of the Original Code is Jean-Philippe BEMPEL aka RDM. Portions created by }
|
|
{ Jean-Philippe BEMPEL are Copyright (C) Jean-Philippe BEMPEL (rdm_30 att yahoo dott com) }
|
|
{ All rights reserved. }
|
|
{ }
|
|
{ Contributors: }
|
|
{ Robert Marquardt (marquardt) }
|
|
{ Robert Rossmair (rrossmair) }
|
|
{ Florent Ouchet (outchy) }
|
|
{ }
|
|
{**************************************************************************************************}
|
|
{ }
|
|
{ The Delphi Container Library }
|
|
{ }
|
|
{**************************************************************************************************}
|
|
{ }
|
|
{ Last modified: $Date:: 2009-08-10 19:54:31 +0200 (lun., 10 août 2009) $ }
|
|
{ Revision: $Rev:: 2940 $ }
|
|
{ Author: $Author:: outchy $ }
|
|
{ }
|
|
{**************************************************************************************************}
|
|
|
|
unit JclContainerIntf;
|
|
|
|
{$I jcl.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
{$IFDEF UNITVERSIONING}
|
|
JclUnitVersioning,
|
|
{$ENDIF UNITVERSIONING}
|
|
Classes,
|
|
JclBase,
|
|
JclAnsiStrings,
|
|
JclWideStrings;
|
|
|
|
{$IFDEF BCB6}
|
|
{$DEFINE BUGGY_DEFAULT_INDEXED_PROP}
|
|
{$ENDIF BCB6}
|
|
{$IFDEF BCB10}
|
|
{$DEFINE BUGGY_DEFAULT_INDEXED_PROP}
|
|
{$ENDIF BCB10}
|
|
{$IFDEF BCB11}
|
|
{$DEFINE BUGGY_DEFAULT_INDEXED_PROP}
|
|
{$ENDIF BCB11}
|
|
|
|
const
|
|
DefaultContainerCapacity = 16;
|
|
|
|
type
|
|
// function pointer types
|
|
|
|
// apply functions Type -> Type
|
|
TIntfApplyFunction = function(const AInterface: IInterface): IInterface;
|
|
TAnsiStrApplyFunction = function(const AString: AnsiString): AnsiString;
|
|
TWideStrApplyFunction = function(const AString: WideString): WideString;
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
TUnicodeStrApplyFunction = function(const AString: UnicodeString): UnicodeString;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
TStrApplyFunction = TAnsiStrApplyFunction;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
TStrApplyFunction = TWideStrApplyFunction;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
TStrApplyFunction = TUnicodeStrApplyFunction;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
TSingleApplyFunction = function(const AValue: Single): Single;
|
|
TDoubleApplyFunction = function(const AValue: Double): Double;
|
|
TExtendedApplyFunction = function(const AValue: Extended): Extended;
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
TFloatApplyFunction = TSingleApplyFunction;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
TFloatApplyFunction = TDoubleApplyFunction;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
TFloatApplyFunction = TExtendedApplyFunction;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
TIntegerApplyFunction = function(AValue: Integer): Integer;
|
|
TCardinalApplyFunction = function(AValue: Cardinal): Cardinal;
|
|
TInt64ApplyFunction = function(const AValue: Int64): Int64;
|
|
TPtrApplyFunction = function(APtr: Pointer): Pointer;
|
|
TApplyFunction = function(AObject: TObject): TObject;
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
TApplyFunction<T> = function(const AItem: T): T;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
// comparison functions Type -> Type -> Integer
|
|
TIntfCompare = function(const Obj1, Obj2: IInterface): Integer;
|
|
TAnsiStrCompare = function(const Obj1, Obj2: AnsiString): Integer;
|
|
TWideStrCompare = function(const Obj1, Obj2: WideString): Integer;
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
TUnicodeStrCompare = function(const Obj1, Obj2: UnicodeString): Integer;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
TStrCompare = TAnsiStrCompare;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
TStrCompare = TWideStrCompare;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
TStrCompare = TUnicodeStrCompare;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
TSingleCompare = function(const Obj1, Obj2: Single): Integer;
|
|
TDoubleCompare = function(const Obj1, Obj2: Double): Integer;
|
|
TExtendedCompare = function(const Obj1, Obj2: Extended): Integer;
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
TFloatCompare = TSingleCompare;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
TFloatCompare = TDoubleCompare;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
TFloatCompare = TExtendedCompare;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
TIntegerCompare = function(Obj1, Obj2: Integer): Integer;
|
|
TCardinalCompare = function(Obj1, Obj2: Cardinal): Integer;
|
|
TInt64Compare = function(Obj1, Obj2: Int64): Integer;
|
|
TPtrCompare = function(Obj1, Obj2: Pointer): Integer;
|
|
TCompare = function(Obj1, Obj2: TObject): Integer;
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
TCompare<T> = function(const Obj1, Obj2: T): Integer;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
// comparison for equality functions Type -> Type -> Boolean
|
|
TIntfEqualityCompare = function(const Obj1, Obj2: IInterface): Boolean;
|
|
TAnsiStrEqualityCompare = function(const Obj1, Obj2: AnsiString): Boolean;
|
|
TWideStrEqualityCompare = function(const Obj1, Obj2: WideString): Boolean;
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
TUnicodeStrEqualityCompare = function(const Obj1, Obj2: UnicodeString): Boolean;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
TStrEqualityCompare = TAnsiStrEqualityCompare;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
TStrEqualityCompare = TWideStrEqualityCompare;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
TStrEqualityCompare = TUnicodeStrEqualityCompare;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
TSingleEqualityCompare = function(const Obj1, Obj2: Single): Boolean;
|
|
TDoubleEqualityCompare = function(const Obj1, Obj2: Double): Boolean;
|
|
TExtendedEqualityCompare = function(const Obj1, Obj2: Extended): Boolean;
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
TFloatEqualityCompare = TSingleEqualityCompare;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
TFloatEqualityCompare = TDoubleEqualityCompare;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
TFloatEqualityCompare = TExtendedEqualityCompare;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
TIntegerEqualityCompare = function(Obj1, Obj2: Integer): Boolean;
|
|
TCardinalEqualityCompare = function(Obj1, Obj2: Cardinal): Boolean;
|
|
TInt64EqualityCompare = function(const Obj1, Obj2: Int64): Boolean;
|
|
TPtrEqualityCompare = function(Obj1, Obj2: Pointer): Boolean;
|
|
TEqualityCompare = function(Obj1, Obj2: TObject): Boolean;
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
TEqualityCompare<T> = function(const Obj1, Obj2: T): Boolean;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
// hash functions Type -> Integer
|
|
TIntfHashConvert = function(const AInterface: IInterface): Integer;
|
|
TAnsiStrHashConvert = function(const AString: AnsiString): Integer;
|
|
TWideStrHashConvert = function(const AString: WideString): Integer;
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
TUnicodeStrHashConvert = function(const AString: UnicodeString): Integer;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
TStrHashConvert = TAnsiStrHashConvert;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
TStrHashConvert = TWideStrHashConvert;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
TStrHashConvert = TUnicodeStrHashConvert;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
TSingleHashConvert = function(const AValue: Single): Integer;
|
|
TDoubleHashConvert = function(const AValue: Double): Integer;
|
|
TExtendedHashConvert = function(const AValue: Extended): Integer;
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
TFloatHashConvert = TSingleHashConvert;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
TFloatHashConvert = TDoubleHashConvert;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
TFloatHashConvert = TExtendedHashConvert;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
TIntegerHashConvert = function(AValue: Integer): Integer;
|
|
TCardinalHashConvert = function(AValue: Cardinal): Integer;
|
|
TInt64HashConvert = function(const AValue: Int64): Integer;
|
|
TPtrHashConvert = function(APtr: Pointer): Integer;
|
|
THashConvert = function(AObject: TObject): Integer;
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
THashConvert<T> = function(const AItem: T): Integer;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclLockable = interface
|
|
['{524AD65E-AE1B-4BC6-91C8-8181F0198BA9}']
|
|
procedure ReadLock;
|
|
procedure ReadUnlock;
|
|
procedure WriteLock;
|
|
procedure WriteUnlock;
|
|
end;
|
|
|
|
IJclAbstractIterator = interface{$IFDEF THREADSAFE}(IJclLockable){$ENDIF THREADSAFE}
|
|
['{1064D0B4-D9FC-475D-88BE-520490013B46}']
|
|
procedure Assign(const Source: IJclAbstractIterator);
|
|
procedure AssignTo(const Dest: IJclAbstractIterator);
|
|
function GetIteratorReference: TObject;
|
|
end;
|
|
|
|
IJclContainer = interface{$IFDEF THREADSAFE}(IJclLockable){$ENDIF THREADSAFE}
|
|
['{C517175A-028E-486A-BF27-5EF7FC3101D9}']
|
|
procedure Assign(const Source: IJclContainer);
|
|
procedure AssignTo(const Dest: IJclContainer);
|
|
function GetAllowDefaultElements: Boolean;
|
|
function GetContainerReference: TObject;
|
|
function GetDuplicates: TDuplicates;
|
|
function GetReadOnly: Boolean;
|
|
function GetRemoveSingleElement: Boolean;
|
|
function GetReturnDefaultElements: Boolean;
|
|
function GetThreadSafe: Boolean;
|
|
procedure SetAllowDefaultElements(Value: Boolean);
|
|
procedure SetDuplicates(Value: TDuplicates);
|
|
procedure SetReadOnly(Value: Boolean);
|
|
procedure SetRemoveSingleElement(Value: Boolean);
|
|
procedure SetReturnDefaultElements(Value: Boolean);
|
|
procedure SetThreadSafe(Value: Boolean);
|
|
property AllowDefaultElements: Boolean read GetAllowDefaultElements write SetAllowDefaultElements;
|
|
property Duplicates: TDuplicates read GetDuplicates write SetDuplicates;
|
|
property ReadOnly: Boolean read GetReadOnly write SetReadOnly;
|
|
property RemoveSingleElement: Boolean read GetRemoveSingleElement write SetRemoveSingleElement;
|
|
property ReturnDefaultElements: Boolean read GetReturnDefaultElements write SetReturnDefaultElements;
|
|
property ThreadSafe: Boolean read GetThreadSafe write SetThreadSafe;
|
|
end;
|
|
|
|
IJclStrContainer = interface(IJclContainer)
|
|
['{9753E1D7-F093-4D5C-8B32-40403F6F700E}']
|
|
function GetCaseSensitive: Boolean;
|
|
procedure SetCaseSensitive(Value: Boolean);
|
|
property CaseSensitive: Boolean read GetCaseSensitive write SetCaseSensitive;
|
|
end;
|
|
|
|
TJclAnsiStrEncoding = (seISO, seUTF8);
|
|
|
|
IJclAnsiStrContainer = interface(IJclStrContainer)
|
|
['{F8239357-B96F-46F1-A48E-B5DF25B5F1FA}']
|
|
function GetEncoding: TJclAnsiStrEncoding;
|
|
procedure SetEncoding(Value: TJclAnsiStrEncoding);
|
|
property Encoding: TJclAnsiStrEncoding read GetEncoding write SetEncoding;
|
|
end;
|
|
|
|
IJclAnsiStrFlatContainer = interface(IJclAnsiStrContainer)
|
|
['{8A45A4D4-6317-4CDF-8314-C3E5CC6899F4}']
|
|
procedure LoadFromStrings(Strings: TJclAnsiStrings);
|
|
procedure SaveToStrings(Strings: TJclAnsiStrings);
|
|
procedure AppendToStrings(Strings: TJclAnsiStrings);
|
|
procedure AppendFromStrings(Strings: TJclAnsiStrings);
|
|
function GetAsStrings: TJclAnsiStrings;
|
|
function GetAsDelimited(const Separator: AnsiString = AnsiLineBreak): AnsiString;
|
|
procedure AppendDelimited(const AString: AnsiString; const Separator: AnsiString = AnsiLineBreak);
|
|
procedure LoadDelimited(const AString: AnsiString; const Separator: AnsiString = AnsiLineBreak);
|
|
end;
|
|
|
|
TJclWideStrEncoding = (seUTF16);
|
|
|
|
IJclWideStrContainer = interface(IJclStrContainer)
|
|
['{875E1AC4-CA22-46BC-8999-048E5B9BF11D}']
|
|
function GetEncoding: TJclWideStrEncoding;
|
|
procedure SetEncoding(Value: TJclWideStrEncoding);
|
|
property Encoding: TJclWideStrEncoding read GetEncoding write SetEncoding;
|
|
end;
|
|
|
|
IJclWideStrFlatContainer = interface(IJclWideStrContainer)
|
|
['{5B001B93-CA1C-47A8-98B8-451CCB444930}']
|
|
procedure LoadFromStrings(Strings: TJclWideStrings);
|
|
procedure SaveToStrings(Strings: TJclWideStrings);
|
|
procedure AppendToStrings(Strings: TJclWideStrings);
|
|
procedure AppendFromStrings(Strings: TJclWideStrings);
|
|
function GetAsStrings: TJclWideStrings;
|
|
function GetAsDelimited(const Separator: WideString = WideLineBreak): WideString;
|
|
procedure AppendDelimited(const AString: WideString; const Separator: WideString = WideLineBreak);
|
|
procedure LoadDelimited(const AString: WideString; const Separator: WideString = WideLineBreak);
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrContainer = interface(IJclStrContainer)
|
|
['{619BA29F-5E05-464D-B472-1C8453DBC707}']
|
|
end;
|
|
|
|
IJclUnicodeStrFlatContainer = interface(IJclUnicodeStrContainer)
|
|
['{3343D73E-4ADC-458E-8289-A4B83D1479D1}']
|
|
procedure LoadFromStrings(Strings: TJclUnicodeStrings);
|
|
procedure SaveToStrings(Strings: TJclUnicodeStrings);
|
|
procedure AppendToStrings(Strings: TJclUnicodeStrings);
|
|
procedure AppendFromStrings(Strings: TJclUnicodeStrings);
|
|
function GetAsStrings: TJclUnicodeStrings;
|
|
function GetAsDelimited(const Separator: UnicodeString = WideLineBreak): UnicodeString;
|
|
procedure AppendDelimited(const AString: UnicodeString; const Separator: UnicodeString = WideLineBreak);
|
|
procedure LoadDelimited(const AString: UnicodeString; const Separator: UnicodeString = WideLineBreak);
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
IJclSingleContainer = interface(IJclContainer)
|
|
['{22BE88BD-87D1-4B4D-9FAB-F1B6D555C6A9}']
|
|
function GetPrecision: Single;
|
|
procedure SetPrecision(const Value: Single);
|
|
property Precision: Single read GetPrecision write SetPrecision;
|
|
end;
|
|
|
|
IJclDoubleContainer = interface(IJclContainer)
|
|
['{372B9354-DF6D-4CAA-A5A9-C50E1FEE5525}']
|
|
function GetPrecision: Double;
|
|
procedure SetPrecision(const Value: Double);
|
|
property Precision: Double read GetPrecision write SetPrecision;
|
|
end;
|
|
|
|
IJclExtendedContainer = interface(IJclContainer)
|
|
['{431A6482-FD5C-45A7-BE53-339A3CF75AC9}']
|
|
function GetPrecision: Extended;
|
|
procedure SetPrecision(const Value: Extended);
|
|
property Precision: Extended read GetPrecision write SetPrecision;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatContainer = IJclExtendedContainer;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatContainer = IJclDoubleContainer;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatContainer = IJclSingleContainer;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntfEqualityComparer = interface
|
|
['{5CC2DF51-BE56-4D02-A171-31BAAC097632}']
|
|
function GetEqualityCompare: TIntfEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TIntfEqualityCompare);
|
|
function ItemsEqual(const A, B: IInterface): Boolean;
|
|
property EqualityCompare: TIntfEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
IJclAnsiStrEqualityComparer = interface
|
|
['{E3DB9016-F0D0-4CE0-B156-4C5DCA47FD3B}']
|
|
function GetEqualityCompare: TAnsiStrEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TAnsiStrEqualityCompare);
|
|
function ItemsEqual(const A, B: AnsiString): Boolean;
|
|
property EqualityCompare: TAnsiStrEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
IJclWideStrEqualityComparer = interface
|
|
['{2E5696C9-8374-4347-9DC9-B3722F47F5FB}']
|
|
function GetEqualityCompare: TWideStrEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TWideStrEqualityCompare);
|
|
function ItemsEqual(const A, B: WideString): Boolean;
|
|
property EqualityCompare: TWideStrEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrEqualityComparer = interface
|
|
['{EDFCC1C7-79DB-4F58-BD64-5016B44EEAC0}']
|
|
function GetEqualityCompare: TUnicodeStrEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TUnicodeStrEqualityCompare);
|
|
function ItemsEqual(const A, B: UnicodeString): Boolean;
|
|
property EqualityCompare: TUnicodeStrEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrEqualityComparer = IJclAnsiStrEqualityComparer;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrEqualityComparer = IJclWideStrEqualityComparer;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrEqualityComparer = IJclUnicodeStrEqualityComparer;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleEqualityComparer = interface
|
|
['{4835BC5B-1A87-4864-BFE1-778F3BAF26B1}']
|
|
function GetEqualityCompare: TSingleEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TSingleEqualityCompare);
|
|
function ItemsEqual(const A, B: Single): Boolean;
|
|
property EqualityCompare: TSingleEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
IJclDoubleEqualityComparer = interface
|
|
['{15F0A9F0-D5DC-4978-8CDB-53B6E510262C}']
|
|
function GetEqualityCompare: TDoubleEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TDoubleEqualityCompare);
|
|
function ItemsEqual(const A, B: Double): Boolean;
|
|
property EqualityCompare: TDoubleEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
IJclExtendedEqualityComparer = interface
|
|
['{149883D5-4138-4570-8C5C-99F186B7E646}']
|
|
function GetEqualityCompare: TExtendedEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TExtendedEqualityCompare);
|
|
function ItemsEqual(const A, B: Extended): Boolean;
|
|
property EqualityCompare: TExtendedEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatEqualityComparer = IJclExtendedEqualityComparer;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatEqualityComparer = IJclDoubleEqualityComparer;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatEqualityComparer = IJclSingleEqualityComparer;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerEqualityComparer = interface
|
|
['{AABC35E6-A779-4A44-B748-27BFCB34FDFB}']
|
|
function GetEqualityCompare: TIntegerEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TIntegerEqualityCompare);
|
|
function ItemsEqual(A, B: Integer): Boolean;
|
|
property EqualityCompare: TIntegerEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
IJclCardinalEqualityComparer = interface
|
|
['{B2DECF81-6ECE-4D9F-80E1-C8C884DB407C}']
|
|
function GetEqualityCompare: TCardinalEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TCardinalEqualityCompare);
|
|
function ItemsEqual(A, B: Cardinal): Boolean;
|
|
property EqualityCompare: TCardinalEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
IJclInt64EqualityComparer = interface
|
|
['{8B2825E2-0C81-42BA-AC0D-104344CE7E56}']
|
|
function GetEqualityCompare: TInt64EqualityCompare;
|
|
procedure SetEqualityCompare(Value: TInt64EqualityCompare);
|
|
function ItemsEqual(const A, B: Int64): Boolean;
|
|
property EqualityCompare: TInt64EqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
IJclPtrEqualityComparer = interface
|
|
['{C6B7CBF9-ECD9-4D70-85CC-4E2367A1D806}']
|
|
function GetEqualityCompare: TPtrEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TPtrEqualityCompare);
|
|
function ItemsEqual(A, B: Pointer): Boolean;
|
|
property EqualityCompare: TPtrEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
IJclEqualityComparer = interface
|
|
['{82C67986-8365-44AB-8D56-7B0CF4F6B918}']
|
|
function GetEqualityCompare: TEqualityCompare;
|
|
procedure SetEqualityCompare(Value: TEqualityCompare);
|
|
function ItemsEqual(A, B: TObject): Boolean;
|
|
property EqualityCompare: TEqualityCompare read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclEqualityComparer<T> = interface
|
|
['{4AF79AD6-D9F4-424B-BEAA-68857F9222B4}']
|
|
function GetEqualityCompare: TEqualityCompare<T>;
|
|
procedure SetEqualityCompare(Value: TEqualityCompare<T>);
|
|
function ItemsEqual(const A, B: T): Boolean;
|
|
property EqualityCompare: TEqualityCompare<T> read GetEqualityCompare write SetEqualityCompare;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfComparer = interface
|
|
['{EB41B843-184B-420D-B5DA-27D055B4CD55}']
|
|
function GetCompare: TIntfCompare;
|
|
procedure SetCompare(Value: TIntfCompare);
|
|
function ItemsCompare(const A, B: IInterface): Integer;
|
|
property Compare: TIntfCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
IJclAnsiStrComparer = interface
|
|
['{09063CBB-9226-4734-B2A0-A178C2343176}']
|
|
function GetCompare: TAnsiStrCompare;
|
|
procedure SetCompare(Value: TAnsiStrCompare);
|
|
function ItemsCompare(const A, B: AnsiString): Integer;
|
|
property Compare: TAnsiStrCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
IJclWideStrComparer = interface
|
|
['{7A24AEDA-25B1-4E73-B2E9-5D74011E4C9C}']
|
|
function GetCompare: TWideStrCompare;
|
|
procedure SetCompare(Value: TWideStrCompare);
|
|
function ItemsCompare(const A, B: WideString): Integer;
|
|
property Compare: TWideStrCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrComparer = interface
|
|
['{E81E2705-0CA0-4DBD-BECC-5F9AA623A6E4}']
|
|
function GetCompare: TUnicodeStrCompare;
|
|
procedure SetCompare(Value: TUnicodeStrCompare);
|
|
function ItemsCompare(const A, B: UnicodeString): Integer;
|
|
property Compare: TUnicodeStrCompare read GetCompare write SetCompare;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrComparer = IJclAnsiStrComparer;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrComparer = IJclWideStrComparer;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrComparer = IJclUnicodeStrComparer;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleComparer = interface
|
|
['{008225CE-075E-4450-B9DE-9863CB6D347C}']
|
|
function GetCompare: TSingleCompare;
|
|
procedure SetCompare(Value: TSingleCompare);
|
|
function ItemsCompare(const A, B: Single): Integer;
|
|
property Compare: TSingleCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
IJclDoubleComparer = interface
|
|
['{BC245D7F-7EB9-43D0-81B4-EE215486A5AA}']
|
|
function GetCompare: TDoubleCompare;
|
|
procedure SetCompare(Value: TDoubleCompare);
|
|
function ItemsCompare(const A, B: Double): Integer;
|
|
property Compare: TDoubleCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
IJclExtendedComparer = interface
|
|
['{92657C66-C18D-4BF8-A538-A3B0140320BB}']
|
|
function GetCompare: TExtendedCompare;
|
|
procedure SetCompare(Value: TExtendedCompare);
|
|
function ItemsCompare(const A, B: Extended): Integer;
|
|
property Compare: TExtendedCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatComparer = IJclExtendedComparer;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatComparer = IJclDoubleComparer;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatComparer = IJclSingleComparer;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerComparer = interface
|
|
['{362C3A6A-CBC1-4D5F-8652-158913DC9865}']
|
|
function GetCompare: TIntegerCompare;
|
|
procedure SetCompare(Value: TIntegerCompare);
|
|
function ItemsCompare(A, B: Integer): Integer;
|
|
property Compare: TIntegerCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
IJclCardinalComparer = interface
|
|
['{56E44725-00B9-4530-8CC2-72DCA9171EE0}']
|
|
function GetCompare: TCardinalCompare;
|
|
procedure SetCompare(Value: TCardinalCompare);
|
|
function ItemsCompare(A, B: Cardinal): Integer;
|
|
property Compare: TCardinalCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
IJclInt64Comparer = interface
|
|
['{87C935BF-3A42-4F1F-A474-9C823939EE1C}']
|
|
function GetCompare: TInt64Compare;
|
|
procedure SetCompare(Value: TInt64Compare);
|
|
function ItemsCompare(const A, B: Int64): Integer;
|
|
property Compare: TInt64Compare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
IJclPtrComparer = interface
|
|
['{85557D4C-A036-477E-BA73-B5EEF43A8696}']
|
|
function GetCompare: TPtrCompare;
|
|
procedure SetCompare(Value: TPtrCompare);
|
|
function ItemsCompare(A, B: Pointer): Integer;
|
|
property Compare: TPtrCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
IJclComparer = interface
|
|
['{7B376028-56DC-4C4A-86A9-1AC19E3EDF75}']
|
|
function GetCompare: TCompare;
|
|
procedure SetCompare(Value: TCompare);
|
|
function ItemsCompare(A, B: TObject): Integer;
|
|
property Compare: TCompare read GetCompare write SetCompare;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclComparer<T> = interface
|
|
['{830AFC8C-AA06-46F5-AABD-8EB46B2A9986}']
|
|
function GetCompare: TCompare<T>;
|
|
procedure SetCompare(Value: TCompare<T>);
|
|
function ItemsCompare(const A, B: T): Integer;
|
|
property Compare: TCompare<T> read GetCompare write SetCompare;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfHashConverter = interface
|
|
['{7BAA0791-3B45-4D0F-9CD8-D13B81694786}']
|
|
function GetHashConvert: TIntfHashConvert;
|
|
procedure SetHashConvert(Value: TIntfHashConvert);
|
|
function Hash(const AInterface: IInterface): Integer;
|
|
property HashConvert: TIntfHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
IJclAnsiStrHashConverter = interface
|
|
['{9841014E-8A31-4C79-8AD5-EB03C4E85533}']
|
|
function GetHashConvert: TAnsiStrHashConvert;
|
|
procedure SetHashConvert(Value: TAnsiStrHashConvert);
|
|
function Hash(const AString: AnsiString): Integer;
|
|
property HashConvert: TAnsiStrHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
IJclWideStrHashConverter = interface
|
|
['{2584118F-19AE-443E-939B-0DB18BCD0117}']
|
|
function GetHashConvert: TWideStrHashConvert;
|
|
procedure SetHashConvert(Value: TWideStrHashConvert);
|
|
function Hash(const AString: WideString): Integer;
|
|
property HashConvert: TWideStrHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrHashConverter = interface
|
|
['{08CD8171-DBAF-405F-9802-46D955C8BBE6}']
|
|
function GetHashConvert: TUnicodeStrHashConvert;
|
|
procedure SetHashConvert(Value: TUnicodeStrHashConvert);
|
|
function Hash(const AString: UnicodeString): Integer;
|
|
property HashConvert: TUnicodeStrHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrHashConverter = IJclAnsiStrHashConverter;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrHashConverter = IJclWideStrHashConverter;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrHashConverter = IJclUnicodeStrHashConverter;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleHashConverter = interface
|
|
['{20F0E481-F1D2-48B6-A95D-FBB56AF119F5}']
|
|
function GetHashConvert: TSingleHashConvert;
|
|
procedure SetHashConvert(Value: TSingleHashConvert);
|
|
function Hash(const AValue: Single): Integer;
|
|
property HashConvert: TSingleHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
IJclDoubleHashConverter = interface
|
|
['{193A2881-535B-4AF4-B0C3-6845A2800F80}']
|
|
function GetHashConvert: TDoubleHashConvert;
|
|
procedure SetHashConvert(Value: TDoubleHashConvert);
|
|
function Hash(const AValue: Double): Integer;
|
|
property HashConvert: TDoubleHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
IJclExtendedHashConverter = interface
|
|
['{77CECDB9-2774-4FDC-8E5A-A80325626434}']
|
|
function GetHashConvert: TExtendedHashConvert;
|
|
procedure SetHashConvert(Value: TExtendedHashConvert);
|
|
function Hash(const AValue: Extended): Integer;
|
|
property HashConvert: TExtendedHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatHashConverter = IJclExtendedHashConverter;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatHashConverter = IJclDoubleHashConverter;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatHashConverter = IJclSingleHashConverter;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerHashConverter = interface
|
|
['{92C540B2-C16C-47E4-995A-644BE71878B1}']
|
|
function GetHashConvert: TIntegerHashConvert;
|
|
procedure SetHashConvert(Value: TIntegerHashConvert);
|
|
function Hash(AValue: Integer): Integer;
|
|
property HashConvert: TIntegerHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
IJclCardinalHashConverter = interface
|
|
['{2DF04C8A-16B8-4712-BC5D-AD35014EC9F7}']
|
|
function GetHashConvert: TCardinalHashConvert;
|
|
procedure SetHashConvert(Value: TCardinalHashConvert);
|
|
function Hash(AValue: Cardinal): Integer;
|
|
property HashConvert: TCardinalHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
IJclInt64HashConverter = interface
|
|
['{96CF2A71-9185-4E26-B283-457ABC3584E7}']
|
|
function GetHashConvert: TInt64HashConvert;
|
|
procedure SetHashConvert(Value: TInt64HashConvert);
|
|
function Hash(const AValue: Int64): Integer;
|
|
property HashConvert: TInt64HashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
IJclPtrHashConverter = interface
|
|
['{D704CC67-CFED-44E6-9504-65D5E468FCAF}']
|
|
function GetHashConvert: TPtrHashConvert;
|
|
procedure SetHashConvert(Value: TPtrHashConvert);
|
|
function Hash(Ptr: Pointer): Integer;
|
|
property HashConvert: TPtrHashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
IJclHashConverter = interface
|
|
['{2D0DD6F4-162E-41D6-8A34-489E7EACABCD}']
|
|
function GetHashConvert: THashConvert;
|
|
procedure SetHashConvert(Value: THashConvert);
|
|
function Hash(AObject: TObject): Integer;
|
|
property HashConvert: THashConvert read GetHashConvert write SetHashConvert;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclHashConverter<T> = interface
|
|
['{300AEA0E-7433-4C3E-99A6-E533212ACF42}']
|
|
function GetHashConvert: THashConvert<T>;
|
|
procedure SetHashConvert(Value: THashConvert<T>);
|
|
function Hash(const AItem: T): Integer;
|
|
property HashConvert: THashConvert<T> read GetHashConvert write SetHashConvert;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfCloneable = interface
|
|
['{BCF77740-FB60-4306-9BD1-448AADE5FF4E}']
|
|
function IntfClone: IInterface;
|
|
end;
|
|
|
|
IJclCloneable = interface
|
|
['{D224AE70-2C93-4998-9479-1D513D75F2B2}']
|
|
function ObjectClone: TObject;
|
|
end;
|
|
|
|
TJclAutoPackStrategy = (apsDisabled, apsAgressive, apsProportional, apsIncremental);
|
|
|
|
// parameter signification depends on strategy
|
|
// - Disabled = unused (arrays are never packed)
|
|
// - Agressive = unused (arrays are always packed)
|
|
// - Proportional = ratio of empty slots before the array is packed
|
|
// number of empty slots is computed by this formula: Capacity div Parameter
|
|
// - Incremental = amount of empty slots before the array is packed
|
|
|
|
IJclPackable = interface
|
|
['{03802D2B-E0AB-4300-A777-0B8A2BD993DF}']
|
|
function CalcGrowCapacity(ACapacity, ASize: Integer): Integer;
|
|
function GetAutoPackParameter: Integer;
|
|
function GetAutoPackStrategy: TJclAutoPackStrategy;
|
|
function GetCapacity: Integer;
|
|
procedure Pack; // reduce used memory by eliminating empty storage area (force)
|
|
procedure SetAutoPackParameter(Value: Integer);
|
|
procedure SetAutoPackStrategy(Value: TJclAutoPackStrategy);
|
|
procedure SetCapacity(Value: Integer);
|
|
property AutoPackParameter: Integer read GetAutoPackParameter write SetAutoPackParameter;
|
|
property AutoPackStrategy: TJclAutoPackStrategy read GetAutoPackStrategy write SetAutoPackStrategy;
|
|
property Capacity: Integer read GetCapacity write SetCapacity;
|
|
end;
|
|
|
|
TJclAutoGrowStrategy = (agsDisabled, agsAgressive, agsProportional, agsIncremental);
|
|
|
|
// parameter signification depends on strategy
|
|
// - Disabled = unused (arrays never grow)
|
|
// - Agressive = unused (arrays always grow by 1 element)
|
|
// - Proportional = ratio of empty slots to add to the array
|
|
// number of empty slots is computed by this formula: Capacity div Parameter
|
|
// - Incremental = amount of empty slots to add to the array
|
|
|
|
IJclGrowable = interface(IJclPackable)
|
|
['{C71E8586-5688-444C-9BDD-9969D988123B}']
|
|
function CalcPackCapacity(ACapacity, ASize: Integer): Integer;
|
|
function GetAutoGrowParameter: Integer;
|
|
function GetAutoGrowStrategy: TJclAutoGrowStrategy;
|
|
procedure Grow;
|
|
procedure SetAutoGrowParameter(Value: Integer);
|
|
procedure SetAutoGrowStrategy(Value: TJclAutoGrowStrategy);
|
|
property AutoGrowParameter: Integer read GetAutoGrowParameter write SetAutoGrowParameter;
|
|
property AutoGrowStrategy: TJclAutoGrowStrategy read GetAutoGrowStrategy write SetAutoGrowStrategy;
|
|
end;
|
|
|
|
IJclObjectOwner = interface
|
|
['{5157EA13-924E-4A56-995D-36956441025C}']
|
|
function FreeObject(var AObject: TObject): TObject;
|
|
function GetOwnsObjects: Boolean;
|
|
property OwnsObjects: Boolean read GetOwnsObjects;
|
|
end;
|
|
|
|
IJclKeyOwner = interface
|
|
['{8BE209E6-2F85-44FD-B0CD-A8363C95349A}']
|
|
function FreeKey(var Key: TObject): TObject;
|
|
function GetOwnsKeys: Boolean;
|
|
property OwnsKeys: Boolean read GetOwnsKeys;
|
|
end;
|
|
|
|
IJclValueOwner = interface
|
|
['{3BCD98CE-7056-416A-A9E7-AE3AB2A62E54}']
|
|
function FreeValue(var Value: TObject): TObject;
|
|
function GetOwnsValues: Boolean;
|
|
property OwnsValues: Boolean read GetOwnsValues;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclItemOwner<T> = interface
|
|
['{0CC220C1-E705-4B21-9F53-4AD340952165}']
|
|
function FreeItem(var AItem: T): T;
|
|
function GetOwnsItems: Boolean;
|
|
property OwnsItems: Boolean read GetOwnsItems;
|
|
end;
|
|
|
|
IJclPairOwner<TKey, TValue> = interface
|
|
['{321C1FF7-AA2E-4229-966A-7EC6417EA16D}']
|
|
function FreeKey(var Key: TKey): TKey;
|
|
function FreeValue(var Value: TValue): TValue;
|
|
function GetOwnsKeys: Boolean;
|
|
function GetOwnsValues: Boolean;
|
|
property OwnsKeys: Boolean read GetOwnsKeys;
|
|
property OwnsValues: Boolean read GetOwnsValues;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfIterator = interface(IJclAbstractIterator)
|
|
['{E121A98A-7C43-4587-806B-9189E8B2F106}']
|
|
function Add(const AInterface: IInterface): Boolean;
|
|
procedure Extract;
|
|
function GetObject: IInterface;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(const AInterface: IInterface): Boolean;
|
|
function IteratorEquals(const AIterator: IJclIntfIterator): Boolean;
|
|
function Next: IInterface;
|
|
function NextIndex: Integer;
|
|
function Previous: IInterface;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetObject(const AInterface: IInterface);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: IInterface read GetObject;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclAnsiStrIterator = interface(IJclAbstractIterator)
|
|
['{D5D4B681-F902-49C7-B9E1-73007C9D64F0}']
|
|
function Add(const AString: AnsiString): Boolean;
|
|
procedure Extract;
|
|
function GetString: AnsiString;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(const AString: AnsiString): Boolean;
|
|
function IteratorEquals(const AIterator: IJclAnsiStrIterator): Boolean;
|
|
function Next: AnsiString;
|
|
function NextIndex: Integer;
|
|
function Previous: AnsiString;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetString(const AString: AnsiString);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: AnsiString read GetString;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclWideStrIterator = interface(IJclAbstractIterator)
|
|
['{F03BC7D4-CCDA-4C4A-AF3A-E51FDCDE8ADE}']
|
|
function Add(const AString: WideString): Boolean;
|
|
procedure Extract;
|
|
function GetString: WideString;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(const AString: WideString): Boolean;
|
|
function IteratorEquals(const AIterator: IJclWideStrIterator): Boolean;
|
|
function Next: WideString;
|
|
function NextIndex: Integer;
|
|
function Previous: WideString;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetString(const AString: WideString);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: WideString read GetString;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrIterator = interface(IJclAbstractIterator)
|
|
['{B913FFDC-792A-48FB-B58E-763EFDEBA15C}']
|
|
function Add(const AString: UnicodeString): Boolean;
|
|
procedure Extract;
|
|
function GetString: UnicodeString;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(const AString: UnicodeString): Boolean;
|
|
function IteratorEquals(const AIterator: IJclUnicodeStrIterator): Boolean;
|
|
function Next: UnicodeString;
|
|
function NextIndex: Integer;
|
|
function Previous: UnicodeString;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetString(const AString: UnicodeString);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: UnicodeString read GetString;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrIterator = IJclAnsiStrIterator;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrIterator = IJclWideStrIterator;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrIterator = IJclUnicodeStrIterator;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleIterator = interface(IJclAbstractIterator)
|
|
['{FD1124F8-CB2B-4AD7-B12D-C05702F4204B}']
|
|
function Add(const AValue: Single): Boolean;
|
|
procedure Extract;
|
|
function GetValue: Single;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(const AValue: Single): Boolean;
|
|
function IteratorEquals(const AIterator: IJclSingleIterator): Boolean;
|
|
function Next: Single;
|
|
function NextIndex: Integer;
|
|
function Previous: Single;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetValue(const AValue: Single);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: Single read GetValue;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclDoubleIterator = interface(IJclAbstractIterator)
|
|
['{004C154A-281C-4DA7-BF64-F3EE80ACF640}']
|
|
function Add(const AValue: Double): Boolean;
|
|
procedure Extract;
|
|
function GetValue: Double;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(const AValue: Double): Boolean;
|
|
function IteratorEquals(const AIterator: IJclDoubleIterator): Boolean;
|
|
function Next: Double;
|
|
function NextIndex: Integer;
|
|
function Previous: Double;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetValue(const AValue: Double);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: Double read GetValue;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclExtendedIterator = interface(IJclAbstractIterator)
|
|
['{B89877A5-DED4-4CD9-AB90-C7D062111DE0}']
|
|
function Add(const AValue: Extended): Boolean;
|
|
procedure Extract;
|
|
function GetValue: Extended;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(const AValue: Extended): Boolean;
|
|
function IteratorEquals(const AIterator: IJclExtendedIterator): Boolean;
|
|
function Next: Extended;
|
|
function NextIndex: Integer;
|
|
function Previous: Extended;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetValue(const AValue: Extended);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: Extended read GetValue;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatIterator = IJclExtendedIterator;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatIterator = IJclDoubleIterator;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatIterator = IJclSingleIterator;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerIterator = interface(IJclAbstractIterator)
|
|
['{1406A991-4574-48A1-83FE-2EDCA03908BE}']
|
|
function Add(AValue: Integer): Boolean;
|
|
procedure Extract;
|
|
function GetValue: Integer;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(AValue: Integer): Boolean;
|
|
function IteratorEquals(const AIterator: IJclIntegerIterator): Boolean;
|
|
function Next: Integer;
|
|
function NextIndex: Integer;
|
|
function Previous: Integer;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetValue(AValue: Integer);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: Integer read GetValue;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclCardinalIterator = interface(IJclAbstractIterator)
|
|
['{72847A34-C8C4-4592-9447-CEB8161E33AD}']
|
|
function Add(AValue: Cardinal): Boolean;
|
|
procedure Extract;
|
|
function GetValue: Cardinal;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(AValue: Cardinal): Boolean;
|
|
function IteratorEquals(const AIterator: IJclCardinalIterator): Boolean;
|
|
function Next: Cardinal;
|
|
function NextIndex: Integer;
|
|
function Previous: Cardinal;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetValue(AValue: Cardinal);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: Cardinal read GetValue;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclInt64Iterator = interface(IJclAbstractIterator)
|
|
['{573E5A51-BF76-43D7-9F93-46305BED20A8}']
|
|
function Add(const AValue: Int64): Boolean;
|
|
procedure Extract;
|
|
function GetValue: Int64;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(const AValue: Int64): Boolean;
|
|
function IteratorEquals(const AIterator: IJclInt64Iterator): Boolean;
|
|
function Next: Int64;
|
|
function NextIndex: Integer;
|
|
function Previous: Int64;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetValue(const AValue: Int64);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: Int64 read GetValue;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclPtrIterator = interface(IJclAbstractIterator)
|
|
['{62B5501C-07AA-4D00-A85B-713B39912CDF}']
|
|
function Add(APtr: Pointer): Boolean;
|
|
procedure Extract;
|
|
function GetPointer: Pointer;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(APtr: Pointer): Boolean;
|
|
function IteratorEquals(const AIterator: IJclPtrIterator): Boolean;
|
|
function Next: Pointer;
|
|
function NextIndex: Integer;
|
|
function Previous: Pointer;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetPointer(APtr: Pointer);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: Pointer read GetPointer;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclIterator = interface(IJclAbstractIterator)
|
|
['{997DF9B7-9AA2-4239-8B94-14DFFD26D790}']
|
|
function Add(AObject: TObject): Boolean;
|
|
procedure Extract;
|
|
function GetObject: TObject;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(AObject: TObject): Boolean;
|
|
function IteratorEquals(const AIterator: IJclIterator): Boolean;
|
|
function Next: TObject;
|
|
function NextIndex: Integer;
|
|
function Previous: TObject;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetObject(AObject: TObject);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: TObject read GetObject;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclIterator<T> = interface(IJclAbstractIterator)
|
|
['{6E8547A4-5B5D-4831-8AE3-9C6D04071B11}']
|
|
function Add(const AItem: T): Boolean;
|
|
procedure Extract;
|
|
function GetItem: T;
|
|
function HasNext: Boolean;
|
|
function HasPrevious: Boolean;
|
|
function Insert(const AItem: T): Boolean;
|
|
function IteratorEquals(const AIterator: IJclIterator<T>): Boolean;
|
|
function Next: T;
|
|
function NextIndex: Integer;
|
|
function Previous: T;
|
|
function PreviousIndex: Integer;
|
|
procedure Remove;
|
|
procedure Reset;
|
|
procedure SetItem(const AItem: T);
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function MoveNext: Boolean;
|
|
property Current: T read GetItem;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfTreeIterator = interface(IJclIntfIterator)
|
|
['{C97379BF-C6A9-4A90-9D7A-152E9BAD314F}']
|
|
function AddChild(const AInterface: IInterface): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): IInterface;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(const AInterface: IInterface): Integer;
|
|
function InsertChild(Index: Integer; const AInterface: IInterface): Boolean;
|
|
function Parent: IInterface;
|
|
procedure SetChild(Index: Integer; const AInterface: IInterface);
|
|
property Children[Index: Integer]: IInterface read GetChild write SetChild;
|
|
end;
|
|
|
|
IJclAnsiStrTreeIterator = interface(IJclAnsiStrIterator)
|
|
['{66BC5C76-758C-4E72-ABF1-EB02CF851C6D}']
|
|
function AddChild(const AString: AnsiString): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): AnsiString;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(const AString: AnsiString): Integer;
|
|
function InsertChild(Index: Integer; const AString: AnsiString): Boolean;
|
|
function Parent: AnsiString;
|
|
procedure SetChild(Index: Integer; const AString: AnsiString);
|
|
property Children[Index: Integer]: AnsiString read GetChild write SetChild;
|
|
end;
|
|
|
|
IJclWideStrTreeIterator = interface(IJclWideStrIterator)
|
|
['{B3168A3B-5A90-4ABF-855F-3D2B3AB6EE7F}']
|
|
function AddChild(const AString: WideString): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): WideString;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(const AString: WideString): Integer;
|
|
function InsertChild(Index: Integer; const AString: WideString): Boolean;
|
|
function Parent: WideString;
|
|
procedure SetChild(Index: Integer; const AString: WideString);
|
|
property Children[Index: Integer]: WideString read GetChild write SetChild;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrTreeIterator = interface(IJclUnicodeStrIterator)
|
|
['{0B0A60DE-0403-4EE1-B1F0-10D849924CF8}']
|
|
function AddChild(const AString: UnicodeString): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): UnicodeString;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(const AString: UnicodeString): Integer;
|
|
function InsertChild(Index: Integer; const AString: UnicodeString): Boolean;
|
|
function Parent: UnicodeString;
|
|
procedure SetChild(Index: Integer; const AString: UnicodeString);
|
|
property Children[Index: Integer]: UnicodeString read GetChild write SetChild;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrTreeIterator = IJclAnsiStrTreeIterator;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrTreeIterator = IJclWideStrTreeIterator;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrTreeIterator = IJclUnicodeStrTreeIterator;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleTreeIterator = interface(IJclSingleIterator)
|
|
['{17BFDE9D-DBF7-4DC8-AC74-919C717B4726}']
|
|
function AddChild(const AValue: Single): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): Single;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(const AValue: Single): Integer;
|
|
function InsertChild(Index: Integer; const AValue: Single): Boolean;
|
|
function Parent: Single;
|
|
procedure SetChild(Index: Integer; const AValue: Single);
|
|
property Children[Index: Integer]: Single read GetChild write SetChild;
|
|
end;
|
|
|
|
IJclDoubleTreeIterator = interface(IJclDoubleIterator)
|
|
['{EB39B84E-D3C5-496E-A521-B8BF24579252}']
|
|
function AddChild(const AValue: Double): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): Double;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(const AValue: Double): Integer;
|
|
function InsertChild(Index: Integer; const AValue: Double): Boolean;
|
|
function Parent: Double;
|
|
procedure SetChild(Index: Integer; const AValue: Double);
|
|
property Children[Index: Integer]: Double read GetChild write SetChild;
|
|
end;
|
|
|
|
IJclExtendedTreeIterator = interface(IJclExtendedIterator)
|
|
['{1B40A544-FC5D-454C-8E42-CE17B015E65C}']
|
|
function AddChild(const AValue: Extended): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): Extended;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(const AValue: Extended): Integer;
|
|
function InsertChild(Index: Integer; const AValue: Extended): Boolean;
|
|
function Parent: Extended;
|
|
procedure SetChild(Index: Integer; const AValue: Extended);
|
|
property Children[Index: Integer]: Extended read GetChild write SetChild;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatTreeIterator = IJclExtendedTreeIterator;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatTreeIterator = IJclDoubleTreeIterator;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatTreeIterator = IJclSingleTreeIterator;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerTreeIterator = interface(IJclIntegerIterator)
|
|
['{88EDC5C5-CA41-41AF-9838-AA19D07E69F5}']
|
|
function AddChild(AValue: Integer): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): Integer;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(AValue: Integer): Integer;
|
|
function InsertChild(Index: Integer; AValue: Integer): Boolean;
|
|
function Parent: Integer;
|
|
procedure SetChild(Index: Integer; AValue: Integer);
|
|
property Children[Index: Integer]: Integer read GetChild write SetChild;
|
|
end;
|
|
|
|
IJclCardinalTreeIterator = interface(IJclCardinalIterator)
|
|
['{FDBF493F-F79D-46EB-A59D-7193B6E6A860}']
|
|
function AddChild(AValue: Cardinal): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): Cardinal;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(AValue: Cardinal): Integer;
|
|
function InsertChild(Index: Integer; AValue: Cardinal): Boolean;
|
|
function Parent: Cardinal;
|
|
procedure SetChild(Index: Integer; AValue: Cardinal);
|
|
property Children[Index: Integer]: Cardinal read GetChild write SetChild;
|
|
end;
|
|
|
|
IJclInt64TreeIterator = interface(IJclInt64Iterator)
|
|
['{C5A5E504-E19B-43AC-90B9-E4B8984BFA23}']
|
|
function AddChild(const AValue: Int64): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): Int64;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(const AValue: Int64): Integer;
|
|
function InsertChild(Index: Integer; const AValue: Int64): Boolean;
|
|
function Parent: Int64;
|
|
procedure SetChild(Index: Integer; const AValue: Int64);
|
|
property Children[Index: Integer]: Int64 read GetChild write SetChild;
|
|
end;
|
|
|
|
IJclPtrTreeIterator = interface(IJclPtrIterator)
|
|
['{ED4C08E6-60FC-4ED3-BD19-E6605B9BD943}']
|
|
function AddChild(APtr: Pointer): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): Pointer;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(APtr: Pointer): Integer;
|
|
function InsertChild(Index: Integer; APtr: Pointer): Boolean;
|
|
function Parent: Pointer;
|
|
procedure SetChild(Index: Integer; APtr: Pointer);
|
|
property Children[Index: Integer]: Pointer read GetChild write SetChild;
|
|
end;
|
|
|
|
IJclTreeIterator = interface(IJclIterator)
|
|
['{8B4863B0-B6B9-426E-B5B8-7AF71D264237}']
|
|
function AddChild(AObject: TObject): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): TObject;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(AObject: TObject): Integer;
|
|
function InsertChild(Index: Integer; AObject: TObject): Boolean;
|
|
function Parent: TObject;
|
|
procedure SetChild(Index: Integer; AObject: TObject);
|
|
property Children[Index: Integer]: TObject read GetChild write SetChild;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclTreeIterator<T> = interface(IJclIterator<T>)
|
|
['{29A06DA4-D93A-40A5-8581-0FE85BC8384B}']
|
|
function AddChild(const AItem: T): Boolean;
|
|
function ChildrenCount: Integer;
|
|
procedure DeleteChild(Index: Integer);
|
|
procedure DeleteChildren;
|
|
procedure ExtractChild(Index: Integer);
|
|
procedure ExtractChildren;
|
|
function GetChild(Index: Integer): T;
|
|
function HasChild(Index: Integer): Boolean;
|
|
function HasParent: Boolean;
|
|
function IndexOfChild(const AItem: T): Integer;
|
|
function InsertChild(Index: Integer; const AItem: T): Boolean;
|
|
function Parent: T;
|
|
procedure SetChild(Index: Integer; const AItem: T);
|
|
property Children[Index: Integer]: T read GetChild write SetChild;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfBinaryTreeIterator = interface(IJclIntfTreeIterator)
|
|
['{8BE874B2-0075-4EE0-8F49-665FC894D923}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: IInterface;
|
|
function Right: IInterface;
|
|
end;
|
|
|
|
IJclAnsiStrBinaryTreeIterator = interface(IJclAnsiStrTreeIterator)
|
|
['{34A4A300-042C-43A9-AC23-8FC1B76BFB25}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: AnsiString;
|
|
function Right: AnsiString;
|
|
end;
|
|
|
|
IJclWideStrBinaryTreeIterator = interface(IJclWideStrTreeIterator)
|
|
['{17C08EB9-6880-469E-878A-8F5EBFE905B1}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: WideString;
|
|
function Right: WideString;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrBinaryTreeIterator = interface(IJclUnicodeStrTreeIterator)
|
|
['{CA32B126-AD4B-4C33-BC47-52B09FE093BE}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: UnicodeString;
|
|
function Right: UnicodeString;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrBinaryTreeIterator = IJclAnsiStrBinaryTreeIterator;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrBinaryTreeIterator = IJclWideStrBinaryTreeIterator;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrBinaryTreeIterator = IJclUnicodeStrBinaryTreeIterator;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleBinaryTreeIterator = interface(IJclSingleTreeIterator)
|
|
['{BC6FFB13-FA1C-4077-8273-F25A3119168B}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: Single;
|
|
function Right: Single;
|
|
end;
|
|
|
|
IJclDoubleBinaryTreeIterator = interface(IJclDoubleTreeIterator)
|
|
['{CE48083C-D60C-4315-BC14-8CE77AC3269E}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: Double;
|
|
function Right: Double;
|
|
end;
|
|
|
|
IJclExtendedBinaryTreeIterator = interface(IJclExtendedTreeIterator)
|
|
['{8A9FAE2A-5EF5-4165-8E8D-51F2102A4580}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: Extended;
|
|
function Right: Extended;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatBinaryTreeIterator = IJclExtendedBinaryTreeIterator;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatBinaryTreeIterator = IJclDoubleBinaryTreeIterator;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatBinaryTreeIterator = IJclSingleBinaryTreeIterator;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerBinaryTreeIterator = interface(IJclIntegerTreeIterator)
|
|
['{FE2BF57D-D10D-4B0C-903D-BB61700FBA0A}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: Integer;
|
|
function Right: Integer;
|
|
end;
|
|
|
|
IJclCardinalBinaryTreeIterator = interface(IJclCardinalTreeIterator)
|
|
['{AAA358F5-95A1-480F-8E2A-09028BA6C397}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: Cardinal;
|
|
function Right: Cardinal;
|
|
end;
|
|
|
|
IJclInt64BinaryTreeIterator = interface(IJclInt64TreeIterator)
|
|
['{5605E164-5CDD-40B1-9323-DE1CB584E289}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: Int64;
|
|
function Right: Int64;
|
|
end;
|
|
|
|
IJclPtrBinaryTreeIterator = interface(IJclPtrTreeIterator)
|
|
['{75D3DF0D-C491-43F7-B078-E658197E8051}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: Pointer;
|
|
function Right: Pointer;
|
|
end;
|
|
|
|
IJclBinaryTreeIterator = interface(IJclTreeIterator)
|
|
['{821DE28D-631C-4F23-A0B2-CC0F35B4C64D}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: TObject;
|
|
function Right: TObject;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclBinaryTreeIterator<T> = interface(IJclTreeIterator<T>)
|
|
['{0CF5B0FC-C644-458C-BF48-2E093DAFEC26}']
|
|
function HasLeft: Boolean;
|
|
function HasRight: Boolean;
|
|
function Left: T;
|
|
function Right: T;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfCollection = interface(IJclContainer)
|
|
['{8E178463-4575-487A-B4D5-DC2AED3C7ACA}']
|
|
function Add(const AInterface: IInterface): Boolean;
|
|
function AddAll(const ACollection: IJclIntfCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(const AInterface: IInterface): Boolean;
|
|
function ContainsAll(const ACollection: IJclIntfCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclIntfCollection): Boolean;
|
|
function Extract(const AInterface: IInterface): Boolean;
|
|
function ExtractAll(const ACollection: IJclIntfCollection): Boolean;
|
|
function First: IJclIntfIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclIntfIterator;
|
|
function Remove(const AInterface: IInterface): Boolean;
|
|
function RemoveAll(const ACollection: IJclIntfCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclIntfCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclIntfIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclAnsiStrCollection = interface(IJclAnsiStrFlatContainer)
|
|
['{3E3CFC19-E8AF-4DD7-91FA-2DF2895FC7B9}']
|
|
function Add(const AString: AnsiString): Boolean;
|
|
function AddAll(const ACollection: IJclAnsiStrCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(const AString: AnsiString): Boolean;
|
|
function ContainsAll(const ACollection: IJclAnsiStrCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclAnsiStrCollection): Boolean;
|
|
function Extract(const AString: AnsiString): Boolean;
|
|
function ExtractAll(const ACollection: IJclAnsiStrCollection): Boolean;
|
|
function First: IJclAnsiStrIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclAnsiStrIterator;
|
|
function Remove(const AString: AnsiString): Boolean;
|
|
function RemoveAll(const ACollection: IJclAnsiStrCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclAnsiStrCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclAnsiStrIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclWideStrCollection = interface(IJclWideStrFlatContainer)
|
|
['{CDCC0F94-4DD0-4F25-B441-6AE55D5C7466}']
|
|
function Add(const AString: WideString): Boolean;
|
|
function AddAll(const ACollection: IJclWideStrCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(const AString: WideString): Boolean;
|
|
function ContainsAll(const ACollection: IJclWideStrCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclWideStrCollection): Boolean;
|
|
function Extract(const AString: WideString): Boolean;
|
|
function ExtractAll(const ACollection: IJclWideStrCollection): Boolean;
|
|
function First: IJclWideStrIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclWideStrIterator;
|
|
function Remove(const AString: WideString): Boolean;
|
|
function RemoveAll(const ACollection: IJclWideStrCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclWideStrCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclWideStrIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrCollection = interface(IJclUnicodeStrFlatContainer)
|
|
['{82EA7DDE-4EBF-4E0D-A380-CAF8A24C1A0D}']
|
|
function Add(const AString: UnicodeString): Boolean;
|
|
function AddAll(const ACollection: IJclUnicodeStrCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(const AString: UnicodeString): Boolean;
|
|
function ContainsAll(const ACollection: IJclUnicodeStrCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclUnicodeStrCollection): Boolean;
|
|
function Extract(const AString: UnicodeString): Boolean;
|
|
function ExtractAll(const ACollection: IJclUnicodeStrCollection): Boolean;
|
|
function First: IJclUnicodeStrIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclUnicodeStrIterator;
|
|
function Remove(const AString: UnicodeString): Boolean;
|
|
function RemoveAll(const ACollection: IJclUnicodeStrCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclUnicodeStrCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclUnicodeStrIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrCollection = IJclAnsiStrCollection;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrCollection = IJclWideStrCollection;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrCollection = IJclUnicodeStrCollection;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleCollection = interface(IJclSingleContainer)
|
|
['{1D34D474-6588-441E-B2B3-8C021A37ED89}']
|
|
function Add(const AValue: Single): Boolean;
|
|
function AddAll(const ACollection: IJclSingleCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(const AValue: Single): Boolean;
|
|
function ContainsAll(const ACollection: IJclSingleCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclSingleCollection): Boolean;
|
|
function Extract(const AValue: Single): Boolean;
|
|
function ExtractAll(const ACollection: IJclSingleCollection): Boolean;
|
|
function First: IJclSingleIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclSingleIterator;
|
|
function Remove(const AValue: Single): Boolean;
|
|
function RemoveAll(const ACollection: IJclSingleCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclSingleCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclSingleIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclDoubleCollection = interface(IJclDoubleContainer)
|
|
['{E54C7717-C33A-4F1B-860C-4F60F303EAD3}']
|
|
function Add(const AValue: Double): Boolean;
|
|
function AddAll(const ACollection: IJclDoubleCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(const AValue: Double): Boolean;
|
|
function ContainsAll(const ACollection: IJclDoubleCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclDoubleCollection): Boolean;
|
|
function Extract(const AValue: Double): Boolean;
|
|
function ExtractAll(const ACollection: IJclDoubleCollection): Boolean;
|
|
function First: IJclDoubleIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclDoubleIterator;
|
|
function Remove(const AValue: Double): Boolean;
|
|
function RemoveAll(const ACollection: IJclDoubleCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclDoubleCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclDoubleIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclExtendedCollection = interface(IJclExtendedContainer)
|
|
['{2A1341CB-B997-4E3B-B1CA-6D60AE853C55}']
|
|
function Add(const AValue: Extended): Boolean;
|
|
function AddAll(const ACollection: IJclExtendedCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(const AValue: Extended): Boolean;
|
|
function ContainsAll(const ACollection: IJclExtendedCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclExtendedCollection): Boolean;
|
|
function Extract(const AValue: Extended): Boolean;
|
|
function ExtractAll(const ACollection: IJclExtendedCollection): Boolean;
|
|
function First: IJclExtendedIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclExtendedIterator;
|
|
function Remove(const AValue: Extended): Boolean;
|
|
function RemoveAll(const ACollection: IJclExtendedCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclExtendedCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclExtendedIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatCollection = IJclExtendedCollection;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatCollection = IJclDoubleCollection;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatCollection = IJclSingleCollection;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerCollection = interface(IJclContainer)
|
|
['{AF69890D-22D1-4D89-8FFD-5FAD7E0638BA}']
|
|
function Add(AValue: Integer): Boolean;
|
|
function AddAll(const ACollection: IJclIntegerCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(AValue: Integer): Boolean;
|
|
function ContainsAll(const ACollection: IJclIntegerCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclIntegerCollection): Boolean;
|
|
function Extract(AValue: Integer): Boolean;
|
|
function ExtractAll(const ACollection: IJclIntegerCollection): Boolean;
|
|
function First: IJclIntegerIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclIntegerIterator;
|
|
function Remove(AValue: Integer): Boolean;
|
|
function RemoveAll(const ACollection: IJclIntegerCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclIntegerCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclIntegerIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclCardinalCollection = interface(IJclContainer)
|
|
['{CFBD0344-58C8-4FA2-B4D7-D21D77DFBF80}']
|
|
function Add(AValue: Cardinal): Boolean;
|
|
function AddAll(const ACollection: IJclCardinalCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(AValue: Cardinal): Boolean;
|
|
function ContainsAll(const ACollection: IJclCardinalCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclCardinalCollection): Boolean;
|
|
function Extract(AValue: Cardinal): Boolean;
|
|
function ExtractAll(const ACollection: IJclCardinalCollection): Boolean;
|
|
function First: IJclCardinalIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclCardinalIterator;
|
|
function Remove(AValue: Cardinal): Boolean;
|
|
function RemoveAll(const ACollection: IJclCardinalCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclCardinalCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclCardinalIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclInt64Collection = interface(IJclContainer)
|
|
['{93A45BDE-3C4C-48D6-9874-5322914DFDDA}']
|
|
function Add(const AValue: Int64): Boolean;
|
|
function AddAll(const ACollection: IJclInt64Collection): Boolean;
|
|
procedure Clear;
|
|
function Contains(const AValue: Int64): Boolean;
|
|
function ContainsAll(const ACollection: IJclInt64Collection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclInt64Collection): Boolean;
|
|
function Extract(const AValue: Int64): Boolean;
|
|
function ExtractAll(const ACollection: IJclInt64Collection): Boolean;
|
|
function First: IJclInt64Iterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclInt64Iterator;
|
|
function Remove(const AValue: Int64): Boolean;
|
|
function RemoveAll(const ACollection: IJclInt64Collection): Boolean;
|
|
function RetainAll(const ACollection: IJclInt64Collection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclInt64Iterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclPtrCollection = interface(IJclContainer)
|
|
['{02E909A7-5B1D-40D4-82EA-A0CD97D5C811}']
|
|
function Add(APtr: Pointer): Boolean;
|
|
function AddAll(const ACollection: IJclPtrCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(APtr: Pointer): Boolean;
|
|
function ContainsAll(const ACollection: IJclPtrCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclPtrCollection): Boolean;
|
|
function Extract(APtr: Pointer): Boolean;
|
|
function ExtractAll(const ACollection: IJclPtrCollection): Boolean;
|
|
function First: IJclPtrIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclPtrIterator;
|
|
function Remove(APtr: Pointer): Boolean;
|
|
function RemoveAll(const ACollection: IJclPtrCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclPtrCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclPtrIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
IJclCollection = interface(IJclContainer)
|
|
['{58947EF1-CD21-4DD1-AE3D-225C3AAD7EE5}']
|
|
function Add(AObject: TObject): Boolean;
|
|
function AddAll(const ACollection: IJclCollection): Boolean;
|
|
procedure Clear;
|
|
function Contains(AObject: TObject): Boolean;
|
|
function ContainsAll(const ACollection: IJclCollection): Boolean;
|
|
function CollectionEquals(const ACollection: IJclCollection): Boolean;
|
|
function Extract(AObject: TObject): Boolean;
|
|
function ExtractAll(const ACollection: IJclCollection): Boolean;
|
|
function First: IJclIterator;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclIterator;
|
|
function Remove(AObject: TObject): Boolean;
|
|
function RemoveAll(const ACollection: IJclCollection): Boolean;
|
|
function RetainAll(const ACollection: IJclCollection): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclIterator;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
//DOM-IGNORE-BEGIN
|
|
IJclCollection<T> = interface(IJclContainer)
|
|
['{67EE8AF3-19B0-4DCA-A730-3C9B261B8EC5}']
|
|
function Add(const AItem: T): Boolean;
|
|
function AddAll(const ACollection: IJclCollection<T>): Boolean;
|
|
procedure Clear;
|
|
function Contains(const AItem: T): Boolean;
|
|
function ContainsAll(const ACollection: IJclCollection<T>): Boolean;
|
|
function CollectionEquals(const ACollection: IJclCollection<T>): Boolean;
|
|
function Extract(const AItem: T): Boolean;
|
|
function ExtractAll(const ACollection: IJclCollection<T>): Boolean;
|
|
function First: IJclIterator<T>;
|
|
function IsEmpty: Boolean;
|
|
function Last: IJclIterator<T>;
|
|
function Remove(const AItem: T): Boolean;
|
|
function RemoveAll(const ACollection: IJclCollection<T>): Boolean;
|
|
function RetainAll(const ACollection: IJclCollection<T>): Boolean;
|
|
function Size: Integer;
|
|
{$IFDEF SUPPORTS_FOR_IN}
|
|
function GetEnumerator: IJclIterator<T>;
|
|
{$ENDIF SUPPORTS_FOR_IN}
|
|
end;
|
|
//DOM-IGNORE-END
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfList = interface(IJclIntfCollection)
|
|
['{E14EDA4B-1DAA-4013-9E6C-CDCB365C7CF9}']
|
|
function Delete(Index: Integer): IInterface;
|
|
function ExtractIndex(Index: Integer): IInterface;
|
|
function GetObject(Index: Integer): IInterface;
|
|
function IndexOf(const AInterface: IInterface): Integer;
|
|
function Insert(Index: Integer; const AInterface: IInterface): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclIntfCollection): Boolean;
|
|
function LastIndexOf(const AInterface: IInterface): Integer;
|
|
procedure SetObject(Index: Integer; const AInterface: IInterface);
|
|
function SubList(First, Count: Integer): IJclIntfList;
|
|
property Objects[Key: Integer]: IInterface read GetObject write SetObject; default;
|
|
end;
|
|
|
|
IJclAnsiStrList = interface(IJclAnsiStrCollection)
|
|
['{07DD7644-EAC6-4059-99FC-BEB7FBB73186}']
|
|
function Delete(Index: Integer): AnsiString;
|
|
function ExtractIndex(Index: Integer): AnsiString;
|
|
function GetString(Index: Integer): AnsiString;
|
|
function IndexOf(const AString: AnsiString): Integer;
|
|
function Insert(Index: Integer; const AString: AnsiString): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclAnsiStrCollection): Boolean;
|
|
function LastIndexOf(const AString: AnsiString): Integer;
|
|
procedure SetString(Index: Integer; const AString: AnsiString);
|
|
function SubList(First, Count: Integer): IJclAnsiStrList;
|
|
property Strings[Key: Integer]: AnsiString read GetString write SetString; default;
|
|
end;
|
|
|
|
IJclWideStrList = interface(IJclWideStrCollection)
|
|
['{C9955874-6AC0-4CE0-8CC0-606A3F1702C6}']
|
|
function Delete(Index: Integer): WideString;
|
|
function ExtractIndex(Index: Integer): WideString;
|
|
function GetString(Index: Integer): WideString;
|
|
function IndexOf(const AString: WideString): Integer;
|
|
function Insert(Index: Integer; const AString: WideString): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclWideStrCollection): Boolean;
|
|
function LastIndexOf(const AString: WideString): Integer;
|
|
procedure SetString(Index: Integer; const AString: WideString);
|
|
function SubList(First, Count: Integer): IJclWideStrList;
|
|
property Strings[Key: Integer]: WideString read GetString write SetString; default;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrList = interface(IJclUnicodeStrCollection)
|
|
['{F4307EB4-D66E-4656-AC56-50883D0F2C83}']
|
|
function Delete(Index: Integer): UnicodeString;
|
|
function ExtractIndex(Index: Integer): UnicodeString;
|
|
function GetString(Index: Integer): UnicodeString;
|
|
function IndexOf(const AString: UnicodeString): Integer;
|
|
function Insert(Index: Integer; const AString: UnicodeString): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclUnicodeStrCollection): Boolean;
|
|
function LastIndexOf(const AString: UnicodeString): Integer;
|
|
procedure SetString(Index: Integer; const AString: UnicodeString);
|
|
function SubList(First, Count: Integer): IJclUnicodeStrList;
|
|
property Strings[Key: Integer]: UnicodeString read GetString write SetString; default;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrList = IJclAnsiStrList;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrList = IJclWideStrList;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrList = IJclUnicodeStrList;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleList = interface(IJclSingleCollection)
|
|
['{D081324C-70A4-4AAC-BA42-7557F0262826}']
|
|
function Delete(Index: Integer): Single;
|
|
function ExtractIndex(Index: Integer): Single;
|
|
function GetValue(Index: Integer): Single;
|
|
function IndexOf(const AValue: Single): Integer;
|
|
function Insert(Index: Integer; const AValue: Single): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclSingleCollection): Boolean;
|
|
function LastIndexOf(const AValue: Single): Integer;
|
|
procedure SetValue(Index: Integer; const AValue: Single);
|
|
function SubList(First, Count: Integer): IJclSingleList;
|
|
property Values[Key: Integer]: Single read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclDoubleList = interface(IJclDoubleCollection)
|
|
['{ECA58515-3903-4312-9486-3214E03F35AB}']
|
|
function Delete(Index: Integer): Double;
|
|
function ExtractIndex(Index: Integer): Double;
|
|
function GetValue(Index: Integer): Double;
|
|
function IndexOf(const AValue: Double): Integer;
|
|
function Insert(Index: Integer; const AValue: Double): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclDoubleCollection): Boolean;
|
|
function LastIndexOf(const AValue: Double): Integer;
|
|
procedure SetValue(Index: Integer; const AValue: Double);
|
|
function SubList(First, Count: Integer): IJclDoubleList;
|
|
property Values[Key: Integer]: Double read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclExtendedList = interface(IJclExtendedCollection)
|
|
['{7463F954-F8DF-4B02-A284-FCB98746248E}']
|
|
function Delete(Index: Integer): Extended;
|
|
function ExtractIndex(Index: Integer): Extended;
|
|
function GetValue(Index: Integer): Extended;
|
|
function IndexOf(const AValue: Extended): Integer;
|
|
function Insert(Index: Integer; const AValue: Extended): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclExtendedCollection): Boolean;
|
|
function LastIndexOf(const AValue: Extended): Integer;
|
|
procedure SetValue(Index: Integer; const AValue: Extended);
|
|
function SubList(First, Count: Integer): IJclExtendedList;
|
|
property Values[Key: Integer]: Extended read GetValue write SetValue; default;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatList = IJclExtendedList;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatList = IJclDoubleList;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatList = IJclSingleList;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerList = interface(IJclIntegerCollection)
|
|
['{339BE91B-557D-4CE0-A854-1CBD4FE31725}']
|
|
function Delete(Index: Integer): Integer;
|
|
function ExtractIndex(Index: Integer): Integer;
|
|
function GetValue(Index: Integer): Integer;
|
|
function IndexOf(AValue: Integer): Integer;
|
|
function Insert(Index: Integer; AValue: Integer): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclIntegerCollection): Boolean;
|
|
function LastIndexOf(AValue: Integer): Integer;
|
|
procedure SetValue(Index: Integer; AValue: Integer);
|
|
function SubList(First, Count: Integer): IJclIntegerList;
|
|
property Values[Key: Integer]: Integer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclCardinalList = interface(IJclCardinalCollection)
|
|
['{02B09EA8-DE6F-4A18-AA57-C3533E6AC4E3}']
|
|
function Delete(Index: Integer): Cardinal;
|
|
function ExtractIndex(Index: Integer): Cardinal;
|
|
function GetValue(Index: Integer): Cardinal;
|
|
function IndexOf(AValue: Cardinal): Integer;
|
|
function Insert(Index: Integer; AValue: Cardinal): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclCardinalCollection): Boolean;
|
|
function LastIndexOf(AValue: Cardinal): Integer;
|
|
procedure SetValue(Index: Integer; AValue: Cardinal);
|
|
function SubList(First, Count: Integer): IJclCardinalList;
|
|
property Values[Key: Integer]: Cardinal read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclInt64List = interface(IJclInt64Collection)
|
|
['{E8D49200-91D3-4BD0-A59B-B93EC7E2074B}']
|
|
function Delete(Index: Integer): Int64;
|
|
function ExtractIndex(Index: Integer): Int64;
|
|
function GetValue(Index: Integer): Int64;
|
|
function IndexOf(const AValue: Int64): Integer;
|
|
function Insert(Index: Integer; const AValue: Int64): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclInt64Collection): Boolean;
|
|
function LastIndexOf(const AValue: Int64): Integer;
|
|
procedure SetValue(Index: Integer; const AValue: Int64);
|
|
function SubList(First, Count: Integer): IJclInt64List;
|
|
property Values[Key: Integer]: Int64 read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclPtrList = interface(IJclPtrCollection)
|
|
['{2CF5CF1F-C012-480C-A4CE-38BDAFB15D05}']
|
|
function Delete(Index: Integer): Pointer;
|
|
function ExtractIndex(Index: Integer): Pointer;
|
|
function GetPointer(Index: Integer): Pointer;
|
|
function IndexOf(APtr: Pointer): Integer;
|
|
function Insert(Index: Integer; APtr: Pointer): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclPtrCollection): Boolean;
|
|
function LastIndexOf(APtr: Pointer): Integer;
|
|
procedure SetPointer(Index: Integer; APtr: Pointer);
|
|
function SubList(First, Count: Integer): IJclPtrList;
|
|
property Pointers[Key: Integer]: Pointer read GetPointer write SetPointer; default;
|
|
end;
|
|
|
|
IJclList = interface(IJclCollection)
|
|
['{8ABC70AC-5C06-43EA-AFE0-D066379BCC28}']
|
|
function Delete(Index: Integer): TObject;
|
|
function ExtractIndex(Index: Integer): TObject;
|
|
function GetObject(Index: Integer): TObject;
|
|
function IndexOf(AObject: TObject): Integer;
|
|
function Insert(Index: Integer; AObject: TObject): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclCollection): Boolean;
|
|
function LastIndexOf(AObject: TObject): Integer;
|
|
procedure SetObject(Index: Integer; AObject: TObject);
|
|
function SubList(First, Count: Integer): IJclList;
|
|
property Objects[Key: Integer]: TObject read GetObject write SetObject; default;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclList<T> = interface(IJclCollection<T>)
|
|
['{3B4BE3D7-8FF7-4163-91DF-3F73AE6935E7}']
|
|
function Delete(Index: Integer): T;
|
|
function ExtractIndex(Index: Integer): T;
|
|
function GetItem(Index: Integer): T;
|
|
function IndexOf(const AItem: T): Integer;
|
|
function Insert(Index: Integer; const AItem: T): Boolean;
|
|
function InsertAll(Index: Integer; const ACollection: IJclCollection<T>): Boolean;
|
|
function LastIndexOf(const AItem: T): Integer;
|
|
procedure SetItem(Index: Integer; const AItem: T);
|
|
function SubList(First, Count: Integer): IJclList<T>;
|
|
property Items[Key: Integer]: T read GetItem write SetItem; default;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
// Pointer functions for sort algorithms
|
|
TIntfSortProc = procedure(const AList: IJclIntfList; L, R: Integer; AComparator: TIntfCompare);
|
|
TAnsiStrSortProc = procedure(const AList: IJclAnsiStrList; L, R: Integer; AComparator: TAnsiStrCompare);
|
|
TWideStrSortProc = procedure(const AList: IJclWideStrList; L, R: Integer; AComparator: TWideStrCompare);
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
TUnicodeStrSortProc = procedure(const AList: IJclUnicodeStrList; L, R: Integer; AComparator: TUnicodeStrCompare);
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
TStrSortProc = TAnsiStrSortProc;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
TStrSortProc = TWideStrSortProc;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
TStrSortProc = TUnicodeStrSortProc;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
TSingleSortProc = procedure(const AList: IJclSingleList; L, R: Integer; AComparator: TSingleCompare);
|
|
TDoubleSortProc = procedure(const AList: IJclDoubleList; L, R: Integer; AComparator: TDoubleCompare);
|
|
TExtendedSortProc = procedure(const AList: IJclExtendedList; L, R: Integer; AComparator: TExtendedCompare);
|
|
TIntegerSortProc = procedure(const AList: IJclIntegerList; L, R: Integer; AComparator: TIntegerCompare);
|
|
TCardinalSortProc = procedure(const AList: IJclCardinalList; L, R: Integer; AComparator: TCardinalCompare);
|
|
TInt64SortProc = procedure(const AList: IJclInt64List; L, R: Integer; AComparator: TInt64Compare);
|
|
TPtrSortProc = procedure(const AList: IJclPtrList; L, R: Integer; AComparator: TPtrCompare);
|
|
TSortProc = procedure(const AList: IJclList; L, R: Integer; AComparator: TCompare);
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
TSortProc<T> = procedure(const AList: IJclList<T>; L, R: Integer; AComparator: TCompare<T>);
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfArray = interface(IJclIntfList)
|
|
['{B055B427-7817-43FC-97D4-AD1845643D63}']
|
|
function GetObject(Index: Integer): IInterface;
|
|
procedure SetObject(Index: Integer; const AInterface: IInterface);
|
|
property Objects[Index: Integer]: IInterface read GetObject write SetObject; default;
|
|
end;
|
|
|
|
IJclAnsiStrArray = interface(IJclAnsiStrList)
|
|
['{4953EA83-9288-4537-9D10-544D1C992B62}']
|
|
function GetString(Index: Integer): AnsiString;
|
|
procedure SetString(Index: Integer; const AString: AnsiString);
|
|
property Strings[Index: Integer]: AnsiString read GetString write SetString; default;
|
|
end;
|
|
|
|
IJclWideStrArray = interface(IJclWideStrList)
|
|
['{3CE09F9A-5CB4-4867-80D5-C2313D278D69}']
|
|
function GetString(Index: Integer): WideString;
|
|
procedure SetString(Index: Integer; const AString: WideString);
|
|
property Strings[Index: Integer]: WideString read GetString write SetString; default;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrArray = interface(IJclUnicodeStrList)
|
|
['{24312E5B-B61D-485C-9E57-AC36C93D8159}']
|
|
function GetString(Index: Integer): UnicodeString;
|
|
procedure SetString(Index: Integer; const AString: UnicodeString);
|
|
property Strings[Index: Integer]: UnicodeString read GetString write SetString; default;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrArray = IJclAnsiStrArray;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrArray = IJclWideStrArray;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrArray = IJclUnicodeStrArray;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleArray = interface(IJclSingleList)
|
|
['{B96E2A4D-D750-4B65-B975-C619A05A29F6}']
|
|
function GetValue(Index: Integer): Single;
|
|
procedure SetValue(Index: Integer; const AValue: Single);
|
|
property Values[Index: Integer]: Single read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclDoubleArray = interface(IJclDoubleList)
|
|
['{67E66324-9757-4E85-8ECD-53396910FB39}']
|
|
function GetValue(Index: Integer): Double;
|
|
procedure SetValue(Index: Integer; const AValue: Double);
|
|
property Values[Index: Integer]: Double read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclExtendedArray = interface(IJclExtendedList)
|
|
['{D43E8D18-26B3-41A2-8D52-ED7EA2FE1AB7}']
|
|
function GetValue(Index: Integer): Extended;
|
|
procedure SetValue(Index: Integer; const AValue: Extended);
|
|
property Values[Index: Integer]: Extended read GetValue write SetValue; default;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatArray = IJclExtendedArray;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatArray = IJclDoubleArray;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatArray = IJclSingleArray;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerArray = interface(IJclIntegerList)
|
|
['{2B7C8B33-C0BD-4EC3-9764-63866E174781}']
|
|
function GetValue(Index: Integer): Integer;
|
|
procedure SetValue(Index: Integer; AValue: Integer);
|
|
property Values[Index: Integer]: Integer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclCardinalArray = interface(IJclCardinalList)
|
|
['{C451F2F8-65C6-4C29-99A0-CC9C15356418}']
|
|
function GetValue(Index: Integer): Cardinal;
|
|
procedure SetValue(Index: Integer; AValue: Cardinal);
|
|
property Values[Index: Integer]: Cardinal read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclInt64Array = interface(IJclInt64List)
|
|
['{D947C43D-2D04-442A-A707-39EDE7D96FC9}']
|
|
function GetValue(Index: Integer): Int64;
|
|
procedure SetValue(Index: Integer; const AValue: Int64);
|
|
property Values[Index: Integer]: Int64 read GetValue write SetValue; default;
|
|
end;
|
|
|
|
IJclPtrArray = interface(IJclPtrList)
|
|
['{D43E8D18-26B3-41A2-8D52-ED7EA2FE1AB7}']
|
|
function GetPointer(Index: Integer): Pointer;
|
|
procedure SetPointer(Index: Integer; APtr: Pointer);
|
|
property Pointers[Index: Integer]: Pointer read GetPointer write SetPointer; default;
|
|
end;
|
|
|
|
IJclArray = interface(IJclList)
|
|
['{A69F6D35-54B2-4361-852E-097ED75E648A}']
|
|
function GetObject(Index: Integer): TObject;
|
|
procedure SetObject(Index: Integer; AObject: TObject);
|
|
property Objects[Index: Integer]: TObject read GetObject write SetObject; default;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclArray<T> = interface(IJclList<T>)
|
|
['{38810C13-E35E-428A-B84F-D25FB994BE8E}']
|
|
function GetItem(Index: Integer): T;
|
|
procedure SetItem(Index: Integer; const AItem: T);
|
|
property Items[Index: Integer]: T read GetItem write SetItem; default;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfSet = interface(IJclIntfCollection)
|
|
['{E2D28852-9774-49B7-A739-5DBA2B705924}']
|
|
procedure Intersect(const ACollection: IJclIntfCollection);
|
|
procedure Subtract(const ACollection: IJclIntfCollection);
|
|
procedure Union(const ACollection: IJclIntfCollection);
|
|
end;
|
|
|
|
IJclAnsiStrSet = interface(IJclAnsiStrCollection)
|
|
['{72204D85-2B68-4914-B9F2-09E5180C12E9}']
|
|
procedure Intersect(const ACollection: IJclAnsiStrCollection);
|
|
procedure Subtract(const ACollection: IJclAnsiStrCollection);
|
|
procedure Union(const ACollection: IJclAnsiStrCollection);
|
|
end;
|
|
|
|
IJclWideStrSet = interface(IJclWideStrCollection)
|
|
['{08009E0A-ABDD-46AB-8CEE-407D4723E17C}']
|
|
procedure Intersect(const ACollection: IJclWideStrCollection);
|
|
procedure Subtract(const ACollection: IJclWideStrCollection);
|
|
procedure Union(const ACollection: IJclWideStrCollection);
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrSet = interface(IJclUnicodeStrCollection)
|
|
['{440E9BCB-341F-40B6-8AED-479B2E98C92A}']
|
|
procedure Intersect(const ACollection: IJclUnicodeStrCollection);
|
|
procedure Subtract(const ACollection: IJclUnicodeStrCollection);
|
|
procedure Union(const ACollection: IJclUnicodeStrCollection);
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrSet = IJclAnsiStrSet;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrSet = IJclWideStrSet;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrSet = IJclUnicodeStrSet;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleSet = interface(IJclSingleCollection)
|
|
['{36E34A78-6A29-4503-97D5-4BF53538CEC0}']
|
|
procedure Intersect(const ACollection: IJclSingleCollection);
|
|
procedure Subtract(const ACollection: IJclSingleCollection);
|
|
procedure Union(const ACollection: IJclSingleCollection);
|
|
end;
|
|
|
|
IJclDoubleSet = interface(IJclDoubleCollection)
|
|
['{4E1E4847-E934-4811-A26C-5FC8E772A623}']
|
|
procedure Intersect(const ACollection: IJclDoubleCollection);
|
|
procedure Subtract(const ACollection: IJclDoubleCollection);
|
|
procedure Union(const ACollection: IJclDoubleCollection);
|
|
end;
|
|
|
|
IJclExtendedSet = interface(IJclExtendedCollection)
|
|
['{3B9CF52D-1C49-4388-A7B3-9BEE1821FFD4}']
|
|
procedure Intersect(const ACollection: IJclExtendedCollection);
|
|
procedure Subtract(const ACollection: IJclExtendedCollection);
|
|
procedure Union(const ACollection: IJclExtendedCollection);
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatSet = IJclExtendedSet;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatSet = IJclDoubleSet;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatSet = IJclSingleSet;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerSet = interface(IJclIntegerCollection)
|
|
['{5E4D29AF-F508-465B-9008-D11FF82F25FE}']
|
|
procedure Intersect(const ACollection: IJclIntegerCollection);
|
|
procedure Subtract(const ACollection: IJclIntegerCollection);
|
|
procedure Union(const ACollection: IJclIntegerCollection);
|
|
end;
|
|
|
|
IJclCardinalSet = interface(IJclCardinalCollection)
|
|
['{09858637-CE8F-42E6-97E0-2786CD68387B}']
|
|
procedure Intersect(const ACollection: IJclCardinalCollection);
|
|
procedure Subtract(const ACollection: IJclCardinalCollection);
|
|
procedure Union(const ACollection: IJclCardinalCollection);
|
|
end;
|
|
|
|
IJclInt64Set = interface(IJclInt64Collection)
|
|
['{ACB3127A-48EE-4F9F-B988-6AE9057780E9}']
|
|
procedure Intersect(const ACollection: IJclInt64Collection);
|
|
procedure Subtract(const ACollection: IJclInt64Collection);
|
|
procedure Union(const ACollection: IJclInt64Collection);
|
|
end;
|
|
|
|
IJclPtrSet = interface(IJclPtrCollection)
|
|
['{26717C68-4F83-4CCB-973A-7324FBD09632}']
|
|
procedure Intersect(const ACollection: IJclPtrCollection);
|
|
procedure Subtract(const ACollection: IJclPtrCollection);
|
|
procedure Union(const ACollection: IJclPtrCollection);
|
|
end;
|
|
|
|
IJclSet = interface(IJclCollection)
|
|
['{0B7CDB90-8588-4260-A54C-D87101C669EA}']
|
|
procedure Intersect(const ACollection: IJclCollection);
|
|
procedure Subtract(const ACollection: IJclCollection);
|
|
procedure Union(const ACollection: IJclCollection);
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclSet<T> = interface(IJclCollection<T>)
|
|
['{0B7CDB90-8588-4260-A54C-D87101C669EA}']
|
|
procedure Intersect(const ACollection: IJclCollection<T>);
|
|
procedure Subtract(const ACollection: IJclCollection<T>);
|
|
procedure Union(const ACollection: IJclCollection<T>);
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
TJclTraverseOrder = (toPreOrder, toOrder, toPostOrder);
|
|
|
|
IJclIntfTree = interface(IJclIntfCollection)
|
|
['{5A21688F-113D-41B4-A17C-54BDB0BD6559}']
|
|
function GetRoot: IJclIntfTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclIntfTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
IJclAnsiStrTree = interface(IJclAnsiStrCollection)
|
|
['{1E1896C0-0497-47DF-83AF-A9422084636C}']
|
|
function GetRoot: IJclAnsiStrTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclAnsiStrTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
IJclWideStrTree = interface(IJclWideStrCollection)
|
|
['{E325615A-7A20-4788-87FA-9051002CCD91}']
|
|
function GetRoot: IJclWideStrTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclWideStrTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrTree = interface(IJclUnicodeStrCollection)
|
|
['{A378BC36-1FB1-4330-A335-037DD370E81B}']
|
|
function GetRoot: IJclUnicodeStrTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclUnicodeStrTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrTree = IJclAnsiStrTree;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrTree = IJclWideStrTree;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrTree = IJclUnicodeStrTree;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleTree = interface(IJclSingleCollection)
|
|
['{A90A51BC-EBD7-40D3-B0A0-C9987E7A83D0}']
|
|
function GetRoot: IJclSingleTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclSingleTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
IJclDoubleTree = interface(IJclDoubleCollection)
|
|
['{69DA85B1-A0DD-407B-B5CF-5EB7C6D4B82D}']
|
|
function GetRoot: IJclDoubleTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclDoubleTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
IJclExtendedTree = interface(IJclExtendedCollection)
|
|
['{9ACCCAFD-B617-43DC-AAF9-916BE324A17E}']
|
|
function GetRoot: IJclExtendedTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclExtendedTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatTree = IJclExtendedTree;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatTree = IJclDoubleTree;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatTree = IJclSingleTree;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerTree = interface(IJclIntegerCollection)
|
|
['{40A6F934-E5F3-4C74-AC02-227035C8C3C6}']
|
|
function GetRoot: IJclIntegerTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclIntegerTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
IJclCardinalTree = interface(IJclCardinalCollection)
|
|
['{6C76C668-50C8-42A2-B72B-79BF102E270D}']
|
|
function GetRoot: IJclCardinalTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclCardinalTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
IJclInt64Tree = interface(IJclInt64Collection)
|
|
['{1925B973-8B75-4A79-A993-DF2598FF19BE}']
|
|
function GetRoot: IJclInt64TreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclInt64TreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
IJclPtrTree = interface(IJclPtrCollection)
|
|
['{2C1ACA3E-3F23-4E3C-984D-151CF9776E14}']
|
|
function GetRoot: IJclPtrTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclPtrTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
IJclTree = interface(IJclCollection)
|
|
['{B0C658CC-FEF5-4178-A4C5-442C0DEDE207}']
|
|
function GetRoot: IJclTreeIterator;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclTreeIterator read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclTree<T> = interface(IJclCollection<T>)
|
|
['{3F963AB5-5A75-41F9-A21B-7E7FB541A459}']
|
|
function GetRoot: IJclTreeIterator<T>;
|
|
function GetTraverseOrder: TJclTraverseOrder;
|
|
procedure SetTraverseOrder(Value: TJclTraverseOrder);
|
|
property Root: IJclTreeIterator<T> read GetRoot;
|
|
property TraverseOrder: TJclTraverseOrder read GetTraverseOrder write SetTraverseOrder;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfIntfMap = interface(IJclContainer)
|
|
['{01D05399-4A05-4F3E-92F4-0C236BE77019}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(const Key: IInterface): IInterface;
|
|
function GetValue(const Key: IInterface): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfIntfMap);
|
|
procedure PutValue(const Key, Value: IInterface);
|
|
function Remove(const Key: IInterface): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[const Key: IInterface]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
(*IJclMultiIntfIntfMap = interface(IJclIntfIntfMap)
|
|
['{497775A5-D3F1-49FC-A641-15CC9E77F3D0}']
|
|
function GetValues(const Key: IInterface): IJclIntfIterator;
|
|
function Count(const Key: IInterface): Integer;
|
|
end;*)
|
|
|
|
IJclAnsiStrIntfMap = interface(IJclAnsiStrContainer)
|
|
['{A4788A96-281A-4924-AA24-03776DDAAD8A}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: AnsiString): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(const Key: AnsiString): IInterface;
|
|
function GetValue(const Key: AnsiString): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): AnsiString;
|
|
function KeySet: IJclAnsiStrSet;
|
|
function MapEquals(const AMap: IJclAnsiStrIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclAnsiStrIntfMap);
|
|
procedure PutValue(const Key: AnsiString; const Value: IInterface);
|
|
function Remove(const Key: AnsiString): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[const Key: AnsiString]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclWideStrIntfMap = interface(IJclWideStrContainer)
|
|
['{C959AB76-9CF0-4C2C-A2C6-8A1846563FAF}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: WideString): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(const Key: WideString): IInterface;
|
|
function GetValue(const Key: WideString): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): WideString;
|
|
function KeySet: IJclWideStrSet;
|
|
function MapEquals(const AMap: IJclWideStrIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclWideStrIntfMap);
|
|
procedure PutValue(const Key: WideString; const Value: IInterface);
|
|
function Remove(const Key: WideString): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[const Key: WideString]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrIntfMap = interface(IJclUnicodeStrContainer)
|
|
['{C83D4F5E-8E66-41E9-83F6-338B44F24BE6}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: UnicodeString): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(const Key: UnicodeString): IInterface;
|
|
function GetValue(const Key: UnicodeString): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): UnicodeString;
|
|
function KeySet: IJclUnicodeStrSet;
|
|
function MapEquals(const AMap: IJclUnicodeStrIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclUnicodeStrIntfMap);
|
|
procedure PutValue(const Key: UnicodeString; const Value: IInterface);
|
|
function Remove(const Key: UnicodeString): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[const Key: UnicodeString]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrIntfMap = IJclAnsiStrIntfMap;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrIntfMap = IJclWideStrIntfMap;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrIntfMap = IJclUnicodeStrIntfMap;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclIntfAnsiStrMap = interface(IJclAnsiStrContainer)
|
|
['{B10E324A-1D98-42FF-B9B4-7F99044591B2}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(const Value: AnsiString): Boolean;
|
|
function Extract(const Key: IInterface): AnsiString;
|
|
function GetValue(const Key: IInterface): AnsiString;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: AnsiString): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfAnsiStrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfAnsiStrMap);
|
|
procedure PutValue(const Key: IInterface; const Value: AnsiString);
|
|
function Remove(const Key: IInterface): AnsiString;
|
|
function Size: Integer;
|
|
function Values: IJclAnsiStrCollection;
|
|
property Items[const Key: IInterface]: AnsiString read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntfWideStrMap = interface(IJclWideStrContainer)
|
|
['{D9FD7887-B840-4636-8A8F-E586663E332C}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(const Value: WideString): Boolean;
|
|
function Extract(const Key: IInterface): WideString;
|
|
function GetValue(const Key: IInterface): WideString;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: WideString): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfWideStrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfWideStrMap);
|
|
procedure PutValue(const Key: IInterface; const Value: WideString);
|
|
function Remove(const Key: IInterface): WideString;
|
|
function Size: Integer;
|
|
function Values: IJclWideStrCollection;
|
|
property Items[const Key: IInterface]: WideString read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclIntfUnicodeStrMap = interface(IJclUnicodeStrContainer)
|
|
['{40F8B873-B763-4A3C-8EC4-31DB3404BF73}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(const Value: UnicodeString): Boolean;
|
|
function Extract(const Key: IInterface): UnicodeString;
|
|
function GetValue(const Key: IInterface): UnicodeString;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: UnicodeString): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfUnicodeStrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfUnicodeStrMap);
|
|
procedure PutValue(const Key: IInterface; const Value: UnicodeString);
|
|
function Remove(const Key: IInterface): UnicodeString;
|
|
function Size: Integer;
|
|
function Values: IJclUnicodeStrCollection;
|
|
property Items[const Key: IInterface]: UnicodeString read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclIntfStrMap = IJclIntfAnsiStrMap;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclIntfStrMap = IJclIntfWideStrMap;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclIntfStrMap = IJclIntfUnicodeStrMap;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclAnsiStrAnsiStrMap = interface(IJclAnsiStrContainer)
|
|
['{A4788A96-281A-4924-AA24-03776DDAAD8A}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: AnsiString): Boolean;
|
|
function ContainsValue(const Value: AnsiString): Boolean;
|
|
function Extract(const Key: AnsiString): AnsiString;
|
|
function GetValue(const Key: AnsiString): AnsiString;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: AnsiString): AnsiString;
|
|
function KeySet: IJclAnsiStrSet;
|
|
function MapEquals(const AMap: IJclAnsiStrAnsiStrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclAnsiStrAnsiStrMap);
|
|
procedure PutValue(const Key, Value: AnsiString);
|
|
function Remove(const Key: AnsiString): AnsiString;
|
|
function Size: Integer;
|
|
function Values: IJclAnsiStrCollection;
|
|
property Items[const Key: AnsiString]: AnsiString read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclWideStrWideStrMap = interface(IJclWideStrContainer)
|
|
['{8E8D2735-C4FB-4F00-8802-B2102BCE3644}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: WideString): Boolean;
|
|
function ContainsValue(const Value: WideString): Boolean;
|
|
function Extract(const Key: WideString): WideString;
|
|
function GetValue(const Key: WideString): WideString;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: WideString): WideString;
|
|
function KeySet: IJclWideStrSet;
|
|
function MapEquals(const AMap: IJclWideStrWideStrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclWideStrWideStrMap);
|
|
procedure PutValue(const Key, Value: WideString);
|
|
function Remove(const Key: WideString): WideString;
|
|
function Size: Integer;
|
|
function Values: IJclWideStrCollection;
|
|
property Items[const Key: WideString]: WideString read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrUnicodeStrMap = interface(IJclUnicodeStrContainer)
|
|
['{557E1CBD-06AC-41C2-BAED-253709CBD0AE}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: UnicodeString): Boolean;
|
|
function ContainsValue(const Value: UnicodeString): Boolean;
|
|
function Extract(const Key: UnicodeString): UnicodeString;
|
|
function GetValue(const Key: UnicodeString): UnicodeString;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: UnicodeString): UnicodeString;
|
|
function KeySet: IJclUnicodeStrSet;
|
|
function MapEquals(const AMap: IJclUnicodeStrUnicodeStrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclUnicodeStrUnicodeStrMap);
|
|
procedure PutValue(const Key, Value: UnicodeString);
|
|
function Remove(const Key: UnicodeString): UnicodeString;
|
|
function Size: Integer;
|
|
function Values: IJclUnicodeStrCollection;
|
|
property Items[const Key: UnicodeString]: UnicodeString read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrStrMap = IJclAnsiStrAnsiStrMap;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrStrMap = IJclWideStrWideStrMap;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrStrMap = IJclUnicodeStrUnicodeStrMap;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleIntfMap = interface(IJclSingleContainer)
|
|
['{5F5E9E8B-E648-450B-B6C0-0EC65CC2D0BA}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Single): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(const Key: Single): IInterface;
|
|
function GetValue(const Key: Single): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): Single;
|
|
function KeySet: IJclSingleSet;
|
|
function MapEquals(const AMap: IJclSingleIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclSingleIntfMap);
|
|
procedure PutValue(const Key: Single; const Value: IInterface);
|
|
function Remove(const Key: Single): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[const Key: Single]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntfSingleMap = interface(IJclSingleContainer)
|
|
['{234D1618-FB0E-46F5-A70D-5106163A90F7}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(const Value: Single): Boolean;
|
|
function Extract(const Key: IInterface): Single;
|
|
function GetValue(const Key: IInterface): Single;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: Single): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfSingleMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfSingleMap);
|
|
procedure PutValue(const Key: IInterface; const Value: Single);
|
|
function Remove(const Key: IInterface): Single;
|
|
function Size: Integer;
|
|
function Values: IJclSingleCollection;
|
|
property Items[const Key: IInterface]: Single read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclSingleSingleMap = interface(IJclSingleContainer)
|
|
['{AEB0008F-F3CF-4055-A7F3-A330D312F03F}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Single): Boolean;
|
|
function ContainsValue(const Value: Single): Boolean;
|
|
function Extract(const Key: Single): Single;
|
|
function GetValue(const Key: Single): Single;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: Single): Single;
|
|
function KeySet: IJclSingleSet;
|
|
function MapEquals(const AMap: IJclSingleSingleMap): Boolean;
|
|
procedure PutAll(const AMap: IJclSingleSingleMap);
|
|
procedure PutValue(const Key, Value: Single);
|
|
function Remove(const Key: Single): Single;
|
|
function Size: Integer;
|
|
function Values: IJclSingleCollection;
|
|
property Items[const Key: Single]: Single read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclDoubleIntfMap = interface(IJclDoubleContainer)
|
|
['{08968FFB-36C6-4FBA-BC09-3DCA2B5D7A50}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Double): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(const Key: Double): IInterface;
|
|
function GetValue(const Key: Double): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): Double;
|
|
function KeySet: IJclDoubleSet;
|
|
function MapEquals(const AMap: IJclDoubleIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclDoubleIntfMap);
|
|
procedure PutValue(const Key: Double; const Value: IInterface);
|
|
function Remove(const Key: Double): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[const Key: Double]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntfDoubleMap = interface(IJclDoubleContainer)
|
|
['{B23DAF6A-6DC5-4DDD-835C-CD4633DDA010}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(const Value: Double): Boolean;
|
|
function Extract(const Key: IInterface): Double;
|
|
function GetValue(const Key: IInterface): Double;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: Double): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfDoubleMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfDoubleMap);
|
|
procedure PutValue(const Key: IInterface; const Value: Double);
|
|
function Remove(const Key: IInterface): Double;
|
|
function Size: Integer;
|
|
function Values: IJclDoubleCollection;
|
|
property Items[const Key: IInterface]: Double read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclDoubleDoubleMap = interface(IJclDoubleContainer)
|
|
['{329A03B8-0B6B-4FE3-87C5-4B63447A5FFD}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Double): Boolean;
|
|
function ContainsValue(const Value: Double): Boolean;
|
|
function Extract(const Key: Double): Double;
|
|
function GetValue(const Key: Double): Double;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: Double): Double;
|
|
function KeySet: IJclDoubleSet;
|
|
function MapEquals(const AMap: IJclDoubleDoubleMap): Boolean;
|
|
procedure PutAll(const AMap: IJclDoubleDoubleMap);
|
|
procedure PutValue(const Key, Value: Double);
|
|
function Remove(const Key: Double): Double;
|
|
function Size: Integer;
|
|
function Values: IJclDoubleCollection;
|
|
property Items[const Key: Double]: Double read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclExtendedIntfMap = interface(IJclExtendedContainer)
|
|
['{7C0731E0-C9AB-4378-B1B0-8CE3DD60AD41}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Extended): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(const Key: Extended): IInterface;
|
|
function GetValue(const Key: Extended): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): Extended;
|
|
function KeySet: IJclExtendedSet;
|
|
function MapEquals(const AMap: IJclExtendedIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclExtendedIntfMap);
|
|
procedure PutValue(const Key: Extended; const Value: IInterface);
|
|
function Remove(const Key: Extended): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[const Key: Extended]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntfExtendedMap = interface(IJclExtendedContainer)
|
|
['{479FCE5A-2D8A-44EE-96BC-E8DA3187DBD8}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(const Value: Extended): Boolean;
|
|
function Extract(const Key: IInterface): Extended;
|
|
function GetValue(const Key: IInterface): Extended;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: Extended): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfExtendedMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfExtendedMap);
|
|
procedure PutValue(const Key: IInterface; const Value: Extended);
|
|
function Remove(const Key: IInterface): Extended;
|
|
function Size: Integer;
|
|
function Values: IJclExtendedCollection;
|
|
property Items[const Key: IInterface]: Extended read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclExtendedExtendedMap = interface(IJclExtendedContainer)
|
|
['{962C2B09-8CF5-44E8-A21A-4A7DAFB72A11}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Extended): Boolean;
|
|
function ContainsValue(const Value: Extended): Boolean;
|
|
function Extract(const Key: Extended): Extended;
|
|
function GetValue(const Key: Extended): Extended;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: Extended): Extended;
|
|
function KeySet: IJclExtendedSet;
|
|
function MapEquals(const AMap: IJclExtendedExtendedMap): Boolean;
|
|
procedure PutAll(const AMap: IJclExtendedExtendedMap);
|
|
procedure PutValue(const Key, Value: Extended);
|
|
function Remove(const Key: Extended): Extended;
|
|
function Size: Integer;
|
|
function Values: IJclExtendedCollection;
|
|
property Items[const Key: Extended]: Extended read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatIntfMap = IJclExtendedIntfMap;
|
|
IJclIntfFloatMap = IJclIntfExtendedMap;
|
|
IJclFloatFloatMap = IJclExtendedExtendedMap;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatIntfMap = IJclDoubleIntfMap;
|
|
IJclIntfFloatMap = IJclIntfDoubleMap;
|
|
IJclFloatFloatMap = IJclDoubleDoubleMap;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatIntfMap = IJclSingleIntfMap;
|
|
IJclIntfFloatMap = IJclIntfSingleMap;
|
|
IJclFloatFloatMap = IJclSingleSingleMap;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerIntfMap = interface(IJclContainer)
|
|
['{E535FE65-AC88-49D3-BEF2-FB30D92C2FA6}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: Integer): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(Key: Integer): IInterface;
|
|
function GetValue(Key: Integer): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): Integer;
|
|
function KeySet: IJclIntegerSet;
|
|
function MapEquals(const AMap: IJclIntegerIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntegerIntfMap);
|
|
procedure PutValue(Key: Integer; const Value: IInterface);
|
|
function Remove(Key: Integer): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[Key: Integer]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntfIntegerMap = interface(IJclContainer)
|
|
['{E01DA012-BEE0-4259-8E30-0A7A1A87BED0}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(Value: Integer): Boolean;
|
|
function Extract(const Key: IInterface): Integer;
|
|
function GetValue(const Key: IInterface): Integer;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: Integer): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfIntegerMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfIntegerMap);
|
|
procedure PutValue(const Key: IInterface; Value: Integer);
|
|
function Remove(const Key: IInterface): Integer;
|
|
function Size: Integer;
|
|
function Values: IJclIntegerCollection;
|
|
property Items[const Key: IInterface]: Integer read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntegerIntegerMap = interface(IJclContainer)
|
|
['{23A46BC0-DF8D-4BD2-89D2-4DACF1EC73A1}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: Integer): Boolean;
|
|
function ContainsValue(Value: Integer): Boolean;
|
|
function Extract(Key: Integer): Integer;
|
|
function GetValue(Key: Integer): Integer;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: Integer): Integer;
|
|
function KeySet: IJclIntegerSet;
|
|
function MapEquals(const AMap: IJclIntegerIntegerMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntegerIntegerMap);
|
|
procedure PutValue(Key, Value: Integer);
|
|
function Remove(Key: Integer): Integer;
|
|
function Size: Integer;
|
|
function Values: IJclIntegerCollection;
|
|
property Items[Key: Integer]: Integer read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclCardinalIntfMap = interface(IJclContainer)
|
|
['{80D39FB1-0D10-49CE-8AF3-1CD98A1D4F6C}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: Cardinal): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(Key: Cardinal): IInterface;
|
|
function GetValue(Key: Cardinal): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): Cardinal;
|
|
function KeySet: IJclCardinalSet;
|
|
function MapEquals(const AMap: IJclCardinalIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclCardinalIntfMap);
|
|
procedure PutValue(Key: Cardinal; const Value: IInterface);
|
|
function Remove(Key: Cardinal): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[Key: Cardinal]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntfCardinalMap = interface(IJclContainer)
|
|
['{E1A724AB-6BDA-45F0-AE21-5E7E789A751B}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(Value: Cardinal): Boolean;
|
|
function Extract(const Key: IInterface): Cardinal;
|
|
function GetValue(const Key: IInterface): Cardinal;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: Cardinal): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfCardinalMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfCardinalMap);
|
|
procedure PutValue(const Key: IInterface; Value: Cardinal);
|
|
function Remove(const Key: IInterface): Cardinal;
|
|
function Size: Integer;
|
|
function Values: IJclCardinalCollection;
|
|
property Items[const Key: IInterface]: Cardinal read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclCardinalCardinalMap = interface(IJclContainer)
|
|
['{1CD3F54C-F92F-4AF4-82B2-0829C08AA83B}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: Cardinal): Boolean;
|
|
function ContainsValue(Value: Cardinal): Boolean;
|
|
function Extract(Key: Cardinal): Cardinal;
|
|
function GetValue(Key: Cardinal): Cardinal;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: Cardinal): Cardinal;
|
|
function KeySet: IJclCardinalSet;
|
|
function MapEquals(const AMap: IJclCardinalCardinalMap): Boolean;
|
|
procedure PutAll(const AMap: IJclCardinalCardinalMap);
|
|
procedure PutValue(Key, Value: Cardinal);
|
|
function Remove(Key: Cardinal): Cardinal;
|
|
function Size: Integer;
|
|
function Values: IJclCardinalCollection;
|
|
property Items[Key: Cardinal]: Cardinal read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclInt64IntfMap = interface(IJclContainer)
|
|
['{B64FB2D1-8D45-4367-B950-98D3D05AC6A0}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Int64): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(const Key: Int64): IInterface;
|
|
function GetValue(const Key: Int64): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): Int64;
|
|
function KeySet: IJclInt64Set;
|
|
function MapEquals(const AMap: IJclInt64IntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclInt64IntfMap);
|
|
procedure PutValue(const Key: Int64; const Value: IInterface);
|
|
function Remove(const Key: Int64): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[const Key: Int64]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntfInt64Map = interface(IJclContainer)
|
|
['{9886BEE3-D15B-45D2-A3FB-4D3A0ADEC8AC}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(const Value: Int64): Boolean;
|
|
function Extract(const Key: IInterface): Int64;
|
|
function GetValue(const Key: IInterface): Int64;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: Int64): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfInt64Map): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfInt64Map);
|
|
procedure PutValue(const Key: IInterface; const Value: Int64);
|
|
function Remove(const Key: IInterface): Int64;
|
|
function Size: Integer;
|
|
function Values: IJclInt64Collection;
|
|
property Items[const Key: IInterface]: Int64 read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclInt64Int64Map = interface(IJclContainer)
|
|
['{EF2A2726-408A-4984-9971-DDC1B6EFC9F5}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Int64): Boolean;
|
|
function ContainsValue(const Value: Int64): Boolean;
|
|
function Extract(const Key: Int64): Int64;
|
|
function GetValue(const Key: Int64): Int64;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: Int64): Int64;
|
|
function KeySet: IJclInt64Set;
|
|
function MapEquals(const AMap: IJclInt64Int64Map): Boolean;
|
|
procedure PutAll(const AMap: IJclInt64Int64Map);
|
|
procedure PutValue(const Key, Value: Int64);
|
|
function Remove(const Key: Int64): Int64;
|
|
function Size: Integer;
|
|
function Values: IJclInt64Collection;
|
|
property Items[const Key: Int64]: Int64 read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclPtrIntfMap = interface(IJclContainer)
|
|
['{B7C48542-39A0-453F-8F03-8C8CFAB0DCCF}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: Pointer): Boolean;
|
|
function ContainsValue(const Value: IInterface): Boolean;
|
|
function Extract(Key: Pointer): IInterface;
|
|
function GetValue(Key: Pointer): IInterface;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: IInterface): Pointer;
|
|
function KeySet: IJclPtrSet;
|
|
function MapEquals(const AMap: IJclPtrIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclPtrIntfMap);
|
|
procedure PutValue(Key: Pointer; const Value: IInterface);
|
|
function Remove(Key: Pointer): IInterface;
|
|
function Size: Integer;
|
|
function Values: IJclIntfCollection;
|
|
property Items[Key: Pointer]: IInterface read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntfPtrMap = interface(IJclContainer)
|
|
['{DA51D823-58DB-4D7C-9B8E-07E0FD560B57}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(Value: Pointer): Boolean;
|
|
function Extract(const Key: IInterface): Pointer;
|
|
function GetValue(const Key: IInterface): Pointer;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: Pointer): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfPtrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfPtrMap);
|
|
procedure PutValue(const Key: IInterface; Value: Pointer);
|
|
function Remove(const Key: IInterface): Pointer;
|
|
function Size: Integer;
|
|
function Values: IJclPtrCollection;
|
|
property Items[const Key: IInterface]: Pointer read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclPtrPtrMap = interface(IJclContainer)
|
|
['{1200CB0F-A766-443F-9030-5A804C11B798}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: Pointer): Boolean;
|
|
function ContainsValue(Value: Pointer): Boolean;
|
|
function Extract(Key: Pointer): Pointer;
|
|
function GetValue(Key: Pointer): Pointer;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: Pointer): Pointer;
|
|
function KeySet: IJclPtrSet;
|
|
function MapEquals(const AMap: IJclPtrPtrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclPtrPtrMap);
|
|
procedure PutValue(Key, Value: Pointer);
|
|
function Remove(Key: Pointer): Pointer;
|
|
function Size: Integer;
|
|
function Values: IJclPtrCollection;
|
|
property Items[Key: Pointer]: Pointer read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclIntfMap = interface(IJclContainer)
|
|
['{C70570C6-EDDB-47B4-9003-C637B486731D}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: IInterface): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(const Key: IInterface): TObject;
|
|
function GetValue(const Key: IInterface): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): IInterface;
|
|
function KeySet: IJclIntfSet;
|
|
function MapEquals(const AMap: IJclIntfMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntfMap);
|
|
procedure PutValue(const Key: IInterface; Value: TObject);
|
|
function Remove(const Key: IInterface): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[const Key: IInterface]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclAnsiStrMap = interface(IJclAnsiStrContainer)
|
|
['{A7D0A882-6952-496D-A258-23D47DDCCBC4}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: AnsiString): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(const Key: AnsiString): TObject;
|
|
function GetValue(const Key: AnsiString): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): AnsiString;
|
|
function KeySet: IJclAnsiStrSet;
|
|
function MapEquals(const AMap: IJclAnsiStrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclAnsiStrMap);
|
|
procedure PutValue(const Key: AnsiString; Value: TObject);
|
|
function Remove(const Key: AnsiString): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[const Key: AnsiString]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclWideStrMap = interface(IJclWideStrContainer)
|
|
['{ACE8E6B4-5A56-4753-A2C6-BAE195A56B63}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: WideString): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(const Key: WideString): TObject;
|
|
function GetValue(const Key: WideString): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): WideString;
|
|
function KeySet: IJclWideStrSet;
|
|
function MapEquals(const AMap: IJclWideStrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclWideStrMap);
|
|
procedure PutValue(const Key: WideString; Value: TObject);
|
|
function Remove(const Key: WideString): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[const Key: WideString]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrMap = interface(IJclUnicodeStrContainer)
|
|
['{4328E033-9B92-40C6-873D-A6982CFC2B95}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: UnicodeString): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(const Key: UnicodeString): TObject;
|
|
function GetValue(const Key: UnicodeString): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): UnicodeString;
|
|
function KeySet: IJclUnicodeStrSet;
|
|
function MapEquals(const AMap: IJclUnicodeStrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclUnicodeStrMap);
|
|
procedure PutValue(const Key: UnicodeString; Value: TObject);
|
|
function Remove(const Key: UnicodeString): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[const Key: UnicodeString]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrMap = IJclAnsiStrMap;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrMap = IJclWideStrMap;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrMap = IJclUnicodeStrMap;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleMap = interface(IJclSingleContainer)
|
|
['{C501920A-F252-4F94-B142-1F05AE06C3D2}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Single): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(const Key: Single): TObject;
|
|
function GetValue(const Key: Single): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): Single;
|
|
function KeySet: IJclSingleSet;
|
|
function MapEquals(const AMap: IJclSingleMap): Boolean;
|
|
procedure PutAll(const AMap: IJclSingleMap);
|
|
procedure PutValue(const Key: Single; Value: TObject);
|
|
function Remove(const Key: Single): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[const Key: Single]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclDoubleMap = interface(IJclDoubleContainer)
|
|
['{B1B994AC-49C9-418B-814B-43BAD706F355}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Double): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(const Key: Double): TObject;
|
|
function GetValue(const Key: Double): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): Double;
|
|
function KeySet: IJclDoubleSet;
|
|
function MapEquals(const AMap: IJclDoubleMap): Boolean;
|
|
procedure PutAll(const AMap: IJclDoubleMap);
|
|
procedure PutValue(const Key: Double; Value: TObject);
|
|
function Remove(const Key: Double): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[const Key: Double]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclExtendedMap = interface(IJclExtendedContainer)
|
|
['{3BCC8C87-A186-45E8-9B37-0B8E85120434}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Extended): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(const Key: Extended): TObject;
|
|
function GetValue(const Key: Extended): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): Extended;
|
|
function KeySet: IJclExtendedSet;
|
|
function MapEquals(const AMap: IJclExtendedMap): Boolean;
|
|
procedure PutAll(const AMap: IJclExtendedMap);
|
|
procedure PutValue(const Key: Extended; Value: TObject);
|
|
function Remove(const Key: Extended): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[const Key: Extended]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatMap = IJclExtendedMap;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatMap = IJclDoubleMap;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatMap = IJclSingleMap;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerMap = interface(IJclContainer)
|
|
['{D6FA5D64-A4AF-4419-9981-56BA79BF8770}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: Integer): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(Key: Integer): TObject;
|
|
function GetValue(Key: Integer): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): Integer;
|
|
function KeySet: IJclIntegerSet;
|
|
function MapEquals(const AMap: IJclIntegerMap): Boolean;
|
|
procedure PutAll(const AMap: IJclIntegerMap);
|
|
procedure PutValue(Key: Integer; Value: TObject);
|
|
function Remove(Key: Integer): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[Key: Integer]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclCardinalMap = interface(IJclContainer)
|
|
['{A2F92F4F-11CB-4DB2-932F-F10A14237126}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: Cardinal): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(Key: Cardinal): TObject;
|
|
function GetValue(Key: Cardinal): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): Cardinal;
|
|
function KeySet: IJclCardinalSet;
|
|
function MapEquals(const AMap: IJclCardinalMap): Boolean;
|
|
procedure PutAll(const AMap: IJclCardinalMap);
|
|
procedure PutValue(Key: Cardinal; Value: TObject);
|
|
function Remove(Key: Cardinal): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[Key: Cardinal]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclInt64Map = interface(IJclContainer)
|
|
['{4C720CE0-7A7C-41D5-BFC1-8D58A47E648F}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: Int64): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(const Key: Int64): TObject;
|
|
function GetValue(const Key: Int64): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): Int64;
|
|
function KeySet: IJclInt64Set;
|
|
function MapEquals(const AMap: IJclInt64Map): Boolean;
|
|
procedure PutAll(const AMap: IJclInt64Map);
|
|
procedure PutValue(const Key: Int64; Value: TObject);
|
|
function Remove(const Key: Int64): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[const Key: Int64]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclPtrMap = interface(IJclContainer)
|
|
['{2FE029A9-026C-487D-8204-AD3A28BD2FA2}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: Pointer): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(Key: Pointer): TObject;
|
|
function GetValue(Key: Pointer): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): Pointer;
|
|
function KeySet: IJclPtrSet;
|
|
function MapEquals(const AMap: IJclPtrMap): Boolean;
|
|
procedure PutAll(const AMap: IJclPtrMap);
|
|
procedure PutValue(Key: Pointer; Value: TObject);
|
|
function Remove(Key: Pointer): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[Key: Pointer]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
IJclMap = interface(IJclContainer)
|
|
['{A7D0A882-6952-496D-A258-23D47DDCCBC4}']
|
|
procedure Clear;
|
|
function ContainsKey(Key: TObject): Boolean;
|
|
function ContainsValue(Value: TObject): Boolean;
|
|
function Extract(Key: TObject): TObject;
|
|
function GetValue(Key: TObject): TObject;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(Value: TObject): TObject;
|
|
function KeySet: IJclSet;
|
|
function MapEquals(const AMap: IJclMap): Boolean;
|
|
procedure PutAll(const AMap: IJclMap);
|
|
procedure PutValue(Key, Value: TObject);
|
|
function Remove(Key: TObject): TObject;
|
|
function Size: Integer;
|
|
function Values: IJclCollection;
|
|
property Items[Key: TObject]: TObject read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IHashable = interface
|
|
function GetHashCode: Integer;
|
|
end;
|
|
|
|
IJclMap<TKey,TValue> = interface(IJclContainer)
|
|
['{22624C43-4828-4A1E-BDD4-4A7FE59AE135}']
|
|
procedure Clear;
|
|
function ContainsKey(const Key: TKey): Boolean;
|
|
function ContainsValue(const Value: TValue): Boolean;
|
|
function Extract(const Key: TKey): TValue;
|
|
function GetValue(const Key: TKey): TValue;
|
|
function IsEmpty: Boolean;
|
|
function KeyOfValue(const Value: TValue): TKey;
|
|
function KeySet: IJclSet<TKey>;
|
|
function MapEquals(const AMap: IJclMap<TKey,TValue>): Boolean;
|
|
procedure PutAll(const AMap: IJclMap<TKey,TValue>);
|
|
procedure PutValue(const Key: TKey; const Value: TValue);
|
|
function Remove(const Key: TKey): TValue;
|
|
function Size: Integer;
|
|
function Values: IJclCollection<TValue>;
|
|
property Items[const Key: TKey]: TValue read GetValue write PutValue;
|
|
{$IFNDEF BUGGY_DEFAULT_INDEXED_PROP} default; {$ENDIF ~BUGGY_DEFAULT_INDEXED_PROP}
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfQueue = interface(IJclContainer)
|
|
['{B88756FE-5553-4106-957E-3E33120BFA99}']
|
|
procedure Clear;
|
|
function Contains(const AInterface: IInterface): Boolean;
|
|
function Dequeue: IInterface;
|
|
function Empty: Boolean;
|
|
function Enqueue(const AInterface: IInterface): Boolean;
|
|
function Peek: IInterface;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclAnsiStrQueue = interface(IJclAnsiStrContainer)
|
|
['{5BA0ED9A-5AF3-4F79-9D80-34FA7FF15D1F}']
|
|
procedure Clear;
|
|
function Contains(const AString: AnsiString): Boolean;
|
|
function Dequeue: AnsiString;
|
|
function Empty: Boolean;
|
|
function Enqueue(const AString: AnsiString): Boolean;
|
|
function Peek: AnsiString;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclWideStrQueue = interface(IJclWideStrContainer)
|
|
['{058BBFB7-E9B9-44B5-B676-D5B5B9A79BEF}']
|
|
procedure Clear;
|
|
function Contains(const AString: WideString): Boolean;
|
|
function Dequeue: WideString;
|
|
function Empty: Boolean;
|
|
function Enqueue(const AString: WideString): Boolean;
|
|
function Peek: WideString;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrQueue = interface(IJclUnicodeStrContainer)
|
|
['{94A09E52-424A-486E-846B-9C2C52DC3A8F}']
|
|
procedure Clear;
|
|
function Contains(const AString: UnicodeString): Boolean;
|
|
function Dequeue: UnicodeString;
|
|
function Empty: Boolean;
|
|
function Enqueue(const AString: UnicodeString): Boolean;
|
|
function Peek: UnicodeString;
|
|
function Size: Integer;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrQueue = IJclAnsiStrQueue;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrQueue = IJclWideStrQueue;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrQueue = IJclUnicodeStrQueue;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleQueue = interface(IJclSingleContainer)
|
|
['{67D74314-9967-4C99-8A48-6E0ADD73EC29}']
|
|
procedure Clear;
|
|
function Contains(const AValue: Single): Boolean;
|
|
function Dequeue: Single;
|
|
function Empty: Boolean;
|
|
function Enqueue(const AValue: Single): Boolean;
|
|
function Peek: Single;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclDoubleQueue = interface(IJclDoubleContainer)
|
|
['{FA1B6D25-3456-4963-87DC-5A2E53B2963F}']
|
|
procedure Clear;
|
|
function Contains(const AValue: Double): Boolean;
|
|
function Dequeue: Double;
|
|
function Empty: Boolean;
|
|
function Enqueue(const AValue: Double): Boolean;
|
|
function Peek: Double;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclExtendedQueue = interface(IJclExtendedContainer)
|
|
['{76F349C0-7681-4BE8-9E94-280C962780D8}']
|
|
procedure Clear;
|
|
function Contains(const AValue: Extended): Boolean;
|
|
function Dequeue: Extended;
|
|
function Empty: Boolean;
|
|
function Enqueue(const AValue: Extended): Boolean;
|
|
function Peek: Extended;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatQueue = IJclExtendedQueue;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatQueue = IJclDoubleQueue;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatQueue = IJclSingleQueue;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerQueue = interface(IJclContainer)
|
|
['{4C4E174E-5D19-44CE-A248-B5589A9B68DF}']
|
|
procedure Clear;
|
|
function Contains(AValue: Integer): Boolean;
|
|
function Dequeue: Integer;
|
|
function Empty: Boolean;
|
|
function Enqueue(AValue: Integer): Boolean;
|
|
function Peek: Integer;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclCardinalQueue = interface(IJclContainer)
|
|
['{CC1D4358-E259-4FB0-BA83-5180A0F8A6C0}']
|
|
procedure Clear;
|
|
function Contains(AValue: Cardinal): Boolean;
|
|
function Dequeue: Cardinal;
|
|
function Empty: Boolean;
|
|
function Enqueue(AValue: Cardinal): Boolean;
|
|
function Peek: Cardinal;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclInt64Queue = interface(IJclContainer)
|
|
['{96B620BB-9A90-43D5-82A7-2D818A11C8E1}']
|
|
procedure Clear;
|
|
function Contains(const AValue: Int64): Boolean;
|
|
function Dequeue: Int64;
|
|
function Empty: Boolean;
|
|
function Enqueue(const AValue: Int64): Boolean;
|
|
function Peek: Int64;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclPtrQueue = interface(IJclContainer)
|
|
['{1052DD37-3035-4C44-A793-54AC4B9C0B29}']
|
|
procedure Clear;
|
|
function Contains(APtr: Pointer): Boolean;
|
|
function Dequeue: Pointer;
|
|
function Empty: Boolean;
|
|
function Enqueue(APtr: Pointer): Boolean;
|
|
function Peek: Pointer;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclQueue = interface(IJclContainer)
|
|
['{7D0F9DE4-71EA-46EF-B879-88BCFD5D9610}']
|
|
procedure Clear;
|
|
function Contains(AObject: TObject): Boolean;
|
|
function Dequeue: TObject;
|
|
function Empty: Boolean;
|
|
function Enqueue(AObject: TObject): Boolean;
|
|
function Peek: TObject;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclQueue<T> = interface(IJclContainer)
|
|
['{16AB909F-2194-46CF-BD89-B4207AC0CAB8}']
|
|
procedure Clear;
|
|
function Contains(const AItem: T): Boolean;
|
|
function Dequeue: T;
|
|
function Empty: Boolean;
|
|
function Enqueue(const AItem: T): Boolean;
|
|
function Peek: T;
|
|
function Size: Integer;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfIntfSortedMap = interface(IJclIntfIntfMap)
|
|
['{265A6EB2-4BB3-459F-8813-360FD32A4971}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfIntfSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfIntfSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfIntfSortedMap;
|
|
end;
|
|
|
|
IJclAnsiStrIntfSortedMap = interface(IJclAnsiStrIntfMap)
|
|
['{706D1C91-5416-4FDC-B6B1-F4C1E8CFCD38}']
|
|
function FirstKey: AnsiString;
|
|
function HeadMap(const ToKey: AnsiString): IJclAnsiStrIntfSortedMap;
|
|
function LastKey: AnsiString;
|
|
function SubMap(const FromKey, ToKey: AnsiString): IJclAnsiStrIntfSortedMap;
|
|
function TailMap(const FromKey: AnsiString): IJclAnsiStrIntfSortedMap;
|
|
end;
|
|
|
|
IJclWideStrIntfSortedMap = interface(IJclWideStrIntfMap)
|
|
['{299FDCFD-2DB7-4D64-BF18-EE3668316430}']
|
|
function FirstKey: WideString;
|
|
function HeadMap(const ToKey: WideString): IJclWideStrIntfSortedMap;
|
|
function LastKey: WideString;
|
|
function SubMap(const FromKey, ToKey: WideString): IJclWideStrIntfSortedMap;
|
|
function TailMap(const FromKey: WideString): IJclWideStrIntfSortedMap;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrIntfSortedMap = interface(IJclUnicodeStrIntfMap)
|
|
['{25FDE916-730D-449A-BA29-852D8A0470B6}']
|
|
function FirstKey: UnicodeString;
|
|
function HeadMap(const ToKey: UnicodeString): IJclUnicodeStrIntfSortedMap;
|
|
function LastKey: UnicodeString;
|
|
function SubMap(const FromKey, ToKey: UnicodeString): IJclUnicodeStrIntfSortedMap;
|
|
function TailMap(const FromKey: UnicodeString): IJclUnicodeStrIntfSortedMap;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrIntfSortedMap = IJclAnsiStrIntfSortedMap;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrIntfSortedMap = IJclWideStrIntfSortedMap;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrIntfSortedMap = IJclUnicodeStrIntfSortedMap;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclIntfAnsiStrSortedMap = interface(IJclIntfAnsiStrMap)
|
|
['{96E6AC5E-8C40-4795-9C8A-CFD098B58680}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfAnsiStrSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfAnsiStrSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfAnsiStrSortedMap;
|
|
end;
|
|
|
|
IJclIntfWideStrSortedMap = interface(IJclIntfWideStrMap)
|
|
['{FBE3AD2E-2781-4DC0-9E80-027027380E21}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfWideStrSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfWideStrSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfWideStrSortedMap;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclIntfUnicodeStrSortedMap = interface(IJclIntfUnicodeStrMap)
|
|
['{B0B0CB9B-268B-40D2-94A8-0B8B5BE2E1AC}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfUnicodeStrSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfUnicodeStrSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfUnicodeStrSortedMap;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclIntfStrSortedMap = IJclIntfAnsiStrSortedMap;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclIntfStrSortedMap = IJclIntfWideStrSortedMap;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclIntfStrSortedMap = IJclIntfUnicodeStrSortedMap;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclAnsiStrAnsiStrSortedMap = interface(IJclAnsiStrAnsiStrMap)
|
|
['{4F457799-5D03-413D-A46C-067DC4200CC3}']
|
|
function FirstKey: AnsiString;
|
|
function HeadMap(const ToKey: AnsiString): IJclAnsiStrAnsiStrSortedMap;
|
|
function LastKey: AnsiString;
|
|
function SubMap(const FromKey, ToKey: AnsiString): IJclAnsiStrAnsiStrSortedMap;
|
|
function TailMap(const FromKey: AnsiString): IJclAnsiStrAnsiStrSortedMap;
|
|
end;
|
|
|
|
IJclWideStrWideStrSortedMap = interface(IJclWideStrWideStrMap)
|
|
['{3B0757B2-2290-4AFA-880D-F9BA600E501E}']
|
|
function FirstKey: WideString;
|
|
function HeadMap(const ToKey: WideString): IJclWideStrWideStrSortedMap;
|
|
function LastKey: WideString;
|
|
function SubMap(const FromKey, ToKey: WideString): IJclWideStrWideStrSortedMap;
|
|
function TailMap(const FromKey: WideString): IJclWideStrWideStrSortedMap;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrUnicodeStrSortedMap = interface(IJclUnicodeStrUnicodeStrMap)
|
|
['{D8EACC5D-B31E-47A8-9CC9-32B15A79CACA}']
|
|
function FirstKey: UnicodeString;
|
|
function HeadMap(const ToKey: UnicodeString): IJclUnicodeStrUnicodeStrSortedMap;
|
|
function LastKey: UnicodeString;
|
|
function SubMap(const FromKey, ToKey: UnicodeString): IJclUnicodeStrUnicodeStrSortedMap;
|
|
function TailMap(const FromKey: UnicodeString): IJclUnicodeStrUnicodeStrSortedMap;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrStrSortedMap = IJclAnsiStrAnsiStrSortedMap;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrStrSortedMap = IJclWideStrWideStrSortedMap;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrStrSortedMap = IJclUnicodeStrUnicodeStrSortedMap;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleIntfSortedMap = interface(IJclSingleIntfMap)
|
|
['{83D57068-7B8E-453E-B35B-2AB4B594A7A9}']
|
|
function FirstKey: Single;
|
|
function HeadMap(const ToKey: Single): IJclSingleIntfSortedMap;
|
|
function LastKey: Single;
|
|
function SubMap(const FromKey, ToKey: Single): IJclSingleIntfSortedMap;
|
|
function TailMap(const FromKey: Single): IJclSingleIntfSortedMap;
|
|
end;
|
|
|
|
IJclIntfSingleSortedMap = interface(IJclIntfSingleMap)
|
|
['{B07FA192-3466-4F2A-BBF0-2DC0100B08A8}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfSingleSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfSingleSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfSingleSortedMap;
|
|
end;
|
|
|
|
IJclSingleSingleSortedMap = interface(IJclSingleSingleMap)
|
|
['{7C6EA0B4-959D-44D5-915F-99DFC1753B00}']
|
|
function FirstKey: Single;
|
|
function HeadMap(const ToKey: Single): IJclSingleSingleSortedMap;
|
|
function LastKey: Single;
|
|
function SubMap(const FromKey, ToKey: Single): IJclSingleSingleSortedMap;
|
|
function TailMap(const FromKey: Single): IJclSingleSingleSortedMap;
|
|
end;
|
|
|
|
IJclDoubleIntfSortedMap = interface(IJclDoubleIntfMap)
|
|
['{F36C5F4F-4F8C-4943-AA35-41623D3C21E9}']
|
|
function FirstKey: Double;
|
|
function HeadMap(const ToKey: Double): IJclDoubleIntfSortedMap;
|
|
function LastKey: Double;
|
|
function SubMap(const FromKey, ToKey: Double): IJclDoubleIntfSortedMap;
|
|
function TailMap(const FromKey: Double): IJclDoubleIntfSortedMap;
|
|
end;
|
|
|
|
IJclIntfDoubleSortedMap = interface(IJclIntfDoubleMap)
|
|
['{0F16ADAE-F499-4857-B5EA-6F3CC9009DBA}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfDoubleSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfDoubleSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfDoubleSortedMap;
|
|
end;
|
|
|
|
IJclDoubleDoubleSortedMap = interface(IJclDoubleDoubleMap)
|
|
['{855C858B-74CF-4338-872B-AF88A02DB537}']
|
|
function FirstKey: Double;
|
|
function HeadMap(const ToKey: Double): IJclDoubleDoubleSortedMap;
|
|
function LastKey: Double;
|
|
function SubMap(const FromKey, ToKey: Double): IJclDoubleDoubleSortedMap;
|
|
function TailMap(const FromKey: Double): IJclDoubleDoubleSortedMap;
|
|
end;
|
|
|
|
IJclExtendedIntfSortedMap = interface(IJclExtendedIntfMap)
|
|
['{A30B8835-A319-4776-9A11-D1EEF60B9C26}']
|
|
function FirstKey: Extended;
|
|
function HeadMap(const ToKey: Extended): IJclExtendedIntfSortedMap;
|
|
function LastKey: Extended;
|
|
function SubMap(const FromKey, ToKey: Extended): IJclExtendedIntfSortedMap;
|
|
function TailMap(const FromKey: Extended): IJclExtendedIntfSortedMap;
|
|
end;
|
|
|
|
IJclIntfExtendedSortedMap = interface(IJclIntfExtendedMap)
|
|
['{3493D6C4-3075-48B6-8E99-CB0000D3978C}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfExtendedSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfExtendedSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfExtendedSortedMap;
|
|
end;
|
|
|
|
IJclExtendedExtendedSortedMap = interface(IJclExtendedExtendedMap)
|
|
['{8CAA505C-D9BB-47E7-92EC-6043DC4AF42C}']
|
|
function FirstKey: Extended;
|
|
function HeadMap(const ToKey: Extended): IJclExtendedExtendedSortedMap;
|
|
function LastKey: Extended;
|
|
function SubMap(const FromKey, ToKey: Extended): IJclExtendedExtendedSortedMap;
|
|
function TailMap(const FromKey: Extended): IJclExtendedExtendedSortedMap;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatIntfSortedMap = IJclExtendedIntfSortedMap;
|
|
IJclIntfFloatSortedMap = IJclIntfExtendedSortedMap;
|
|
IJclFloatFloatSortedMap = IJclExtendedExtendedSortedMap;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatIntfSortedMap = IJclDoubleIntfSortedMap;
|
|
IJclIntfFloatSortedMap = IJclIntfDoubleSortedMap;
|
|
IJclFloatFloatSortedMap = IJclDoubleDoubleSortedMap;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatIntfSortedMap = IJclSingleIntfSortedMap;
|
|
IJclIntfFloatSortedMap = IJclIntfSingleSortedMap;
|
|
IJclFloatFloatSortedMap = IJclSingleSingleSortedMap;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerIntfSortedMap = interface(IJclIntegerIntfMap)
|
|
['{8B22802C-61F2-4DA5-B1E9-DBB7840E7996}']
|
|
function FirstKey: Integer;
|
|
function HeadMap(ToKey: Integer): IJclIntegerIntfSortedMap;
|
|
function LastKey: Integer;
|
|
function SubMap(FromKey, ToKey: Integer): IJclIntegerIntfSortedMap;
|
|
function TailMap(FromKey: Integer): IJclIntegerIntfSortedMap;
|
|
end;
|
|
|
|
IJclIntfIntegerSortedMap = interface(IJclIntfIntegerMap)
|
|
['{8D3C9B7E-772D-409B-A58C-0CABFAFDEFF0}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfIntegerSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfIntegerSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfIntegerSortedMap;
|
|
end;
|
|
|
|
IJclIntegerIntegerSortedMap = interface(IJclIntegerIntegerMap)
|
|
['{8A8BA17A-F468-469C-AF99-77D64C802F7A}']
|
|
function FirstKey: Integer;
|
|
function HeadMap(ToKey: Integer): IJclIntegerIntegerSortedMap;
|
|
function LastKey: Integer;
|
|
function SubMap(FromKey, ToKey: Integer): IJclIntegerIntegerSortedMap;
|
|
function TailMap(FromKey: Integer): IJclIntegerIntegerSortedMap;
|
|
end;
|
|
|
|
IJclCardinalIntfSortedMap = interface(IJclCardinalIntfMap)
|
|
['{BAE97425-4F2E-461B-88DD-F83D27657AFA}']
|
|
function FirstKey: Cardinal;
|
|
function HeadMap(ToKey: Cardinal): IJclCardinalIntfSortedMap;
|
|
function LastKey: Cardinal;
|
|
function SubMap(FromKey, ToKey: Cardinal): IJclCardinalIntfSortedMap;
|
|
function TailMap(FromKey: Cardinal): IJclCardinalIntfSortedMap;
|
|
end;
|
|
|
|
IJclIntfCardinalSortedMap = interface(IJclIntfCardinalMap)
|
|
['{BC66BACF-23AE-48C4-9573-EDC3B5110BE7}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfCardinalSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfCardinalSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfCardinalSortedMap;
|
|
end;
|
|
|
|
IJclCardinalCardinalSortedMap = interface(IJclCardinalCardinalMap)
|
|
['{182ACDA4-7D74-4D29-BB5C-4C8189DA774E}']
|
|
function FirstKey: Cardinal;
|
|
function HeadMap(ToKey: Cardinal): IJclCardinalCardinalSortedMap;
|
|
function LastKey: Cardinal;
|
|
function SubMap(FromKey, ToKey: Cardinal): IJclCardinalCardinalSortedMap;
|
|
function TailMap(FromKey: Cardinal): IJclCardinalCardinalSortedMap;
|
|
end;
|
|
|
|
IJclInt64IntfSortedMap = interface(IJclInt64IntfMap)
|
|
['{24391756-FB02-4901-81E3-A37738B73DAD}']
|
|
function FirstKey: Int64;
|
|
function HeadMap(const ToKey: Int64): IJclInt64IntfSortedMap;
|
|
function LastKey: Int64;
|
|
function SubMap(const FromKey, ToKey: Int64): IJclInt64IntfSortedMap;
|
|
function TailMap(const FromKey: Int64): IJclInt64IntfSortedMap;
|
|
end;
|
|
|
|
IJclIntfInt64SortedMap = interface(IJclIntfInt64Map)
|
|
['{6E2AB647-59CC-4609-82E8-6AE75AED80CA}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfInt64SortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfInt64SortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfInt64SortedMap;
|
|
end;
|
|
|
|
IJclInt64Int64SortedMap = interface(IJclInt64Int64Map)
|
|
['{168581D2-9DD3-46D0-934E-EA0CCE5E3C0C}']
|
|
function FirstKey: Int64;
|
|
function HeadMap(const ToKey: Int64): IJclInt64Int64SortedMap;
|
|
function LastKey: Int64;
|
|
function SubMap(const FromKey, ToKey: Int64): IJclInt64Int64SortedMap;
|
|
function TailMap(const FromKey: Int64): IJclInt64Int64SortedMap;
|
|
end;
|
|
|
|
IJclPtrIntfSortedMap = interface(IJclPtrIntfMap)
|
|
['{6D7B8042-3CBC-4C8F-98B5-69AFAA104532}']
|
|
function FirstKey: Pointer;
|
|
function HeadMap(ToKey: Pointer): IJclPtrIntfSortedMap;
|
|
function LastKey: Pointer;
|
|
function SubMap(FromKey, ToKey: Pointer): IJclPtrIntfSortedMap;
|
|
function TailMap(FromKey: Pointer): IJclPtrIntfSortedMap;
|
|
end;
|
|
|
|
IJclIntfPtrSortedMap = interface(IJclIntfPtrMap)
|
|
['{B054BDA2-536F-4C16-B6BB-BB64FA0818B3}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfPtrSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfPtrSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfPtrSortedMap;
|
|
end;
|
|
|
|
IJclPtrPtrSortedMap = interface(IJclPtrPtrMap)
|
|
['{F1FAE922-0212-41D0-BB4E-76A8AB2CAB86}']
|
|
function FirstKey: Pointer;
|
|
function HeadMap(ToKey: Pointer): IJclPtrPtrSortedMap;
|
|
function LastKey: Pointer;
|
|
function SubMap(FromKey, ToKey: Pointer): IJclPtrPtrSortedMap;
|
|
function TailMap(FromKey: Pointer): IJclPtrPtrSortedMap;
|
|
end;
|
|
|
|
IJclIntfSortedMap = interface(IJclIntfMap)
|
|
['{3CED1477-B958-4109-9BDA-7C84B9E063B2}']
|
|
function FirstKey: IInterface;
|
|
function HeadMap(const ToKey: IInterface): IJclIntfSortedMap;
|
|
function LastKey: IInterface;
|
|
function SubMap(const FromKey, ToKey: IInterface): IJclIntfSortedMap;
|
|
function TailMap(const FromKey: IInterface): IJclIntfSortedMap;
|
|
end;
|
|
|
|
IJclAnsiStrSortedMap = interface(IJclAnsiStrMap)
|
|
['{573F98E3-EBCD-4F28-8F35-96A7366CBF47}']
|
|
function FirstKey: AnsiString;
|
|
function HeadMap(const ToKey: AnsiString): IJclAnsiStrSortedMap;
|
|
function LastKey: AnsiString;
|
|
function SubMap(const FromKey, ToKey: AnsiString): IJclAnsiStrSortedMap;
|
|
function TailMap(const FromKey: AnsiString): IJclAnsiStrSortedMap;
|
|
end;
|
|
|
|
IJclWideStrSortedMap = interface(IJclWideStrMap)
|
|
['{B3021EFC-DE25-4B4B-A896-ACE823CD5C01}']
|
|
function FirstKey: WideString;
|
|
function HeadMap(const ToKey: WideString): IJclWideStrSortedMap;
|
|
function LastKey: WideString;
|
|
function SubMap(const FromKey, ToKey: WideString): IJclWideStrSortedMap;
|
|
function TailMap(const FromKey: WideString): IJclWideStrSortedMap;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrSortedMap = interface(IJclUnicodeStrMap)
|
|
['{5510B8FC-3439-4211-8D1F-5EDD9A56D3E3}']
|
|
function FirstKey: UnicodeString;
|
|
function HeadMap(const ToKey: UnicodeString): IJclUnicodeStrSortedMap;
|
|
function LastKey: UnicodeString;
|
|
function SubMap(const FromKey, ToKey: UnicodeString): IJclUnicodeStrSortedMap;
|
|
function TailMap(const FromKey: UnicodeString): IJclUnicodeStrSortedMap;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrSortedMap = IJclAnsiStrSortedMap;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrSortedMap = IJclWideStrSortedMap;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrSortedMap = IJclUnicodeStrSortedMap;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleSortedMap = interface(IJclSingleMap)
|
|
['{8C1A12BE-A7F2-4351-90B7-25DB0AAF5F94}']
|
|
function FirstKey: Single;
|
|
function HeadMap(const ToKey: Single): IJclSingleSortedMap;
|
|
function LastKey: Single;
|
|
function SubMap(const FromKey, ToKey: Single): IJclSingleSortedMap;
|
|
function TailMap(const FromKey: Single): IJclSingleSortedMap;
|
|
end;
|
|
|
|
IJclDoubleSortedMap = interface(IJclDoubleMap)
|
|
['{8018D66B-AA54-4016-84FC-3E780FFCC38B}']
|
|
function FirstKey: Double;
|
|
function HeadMap(const ToKey: Double): IJclDoubleSortedMap;
|
|
function LastKey: Double;
|
|
function SubMap(const FromKey, ToKey: Double): IJclDoubleSortedMap;
|
|
function TailMap(const FromKey: Double): IJclDoubleSortedMap;
|
|
end;
|
|
|
|
IJclExtendedSortedMap = interface(IJclExtendedMap)
|
|
['{2B82C65A-B3EF-477D-BEC0-3D8620A226B1}']
|
|
function FirstKey: Extended;
|
|
function HeadMap(const ToKey: Extended): IJclExtendedSortedMap;
|
|
function LastKey: Extended;
|
|
function SubMap(const FromKey, ToKey: Extended): IJclExtendedSortedMap;
|
|
function TailMap(const FromKey: Extended): IJclExtendedSortedMap;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatSortedMap = IJclExtendedSortedMap;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatSortedMap = IJclDoubleSortedMap;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatSortedMap = IJclSingleSortedMap;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerSortedMap = interface(IJclIntegerMap)
|
|
['{DD7B4C5E-6D51-44CC-9328-B38396A7E1C9}']
|
|
function FirstKey: Integer;
|
|
function HeadMap(ToKey: Integer): IJclIntegerSortedMap;
|
|
function LastKey: Integer;
|
|
function SubMap(FromKey, ToKey: Integer): IJclIntegerSortedMap;
|
|
function TailMap(FromKey: Integer): IJclIntegerSortedMap;
|
|
end;
|
|
|
|
IJclCardinalSortedMap = interface(IJclCardinalMap)
|
|
['{4AEAF81F-D72E-4499-B10E-3D017F39915E}']
|
|
function FirstKey: Cardinal;
|
|
function HeadMap(ToKey: Cardinal): IJclCardinalSortedMap;
|
|
function LastKey: Cardinal;
|
|
function SubMap(FromKey, ToKey: Cardinal): IJclCardinalSortedMap;
|
|
function TailMap(FromKey: Cardinal): IJclCardinalSortedMap;
|
|
end;
|
|
|
|
IJclInt64SortedMap = interface(IJclInt64Map)
|
|
['{06C03F90-7DE9-4043-AA56-AAE071D8BD50}']
|
|
function FirstKey: Int64;
|
|
function HeadMap(const ToKey: Int64): IJclInt64SortedMap;
|
|
function LastKey: Int64;
|
|
function SubMap(const FromKey, ToKey: Int64): IJclInt64SortedMap;
|
|
function TailMap(const FromKey: Int64): IJclInt64SortedMap;
|
|
end;
|
|
|
|
IJclPtrSortedMap = interface(IJclPtrMap)
|
|
['{578918DB-6A4A-4A9D-B44E-AE3E8FF70818}']
|
|
function FirstKey: Pointer;
|
|
function HeadMap(ToKey: Pointer): IJclPtrSortedMap;
|
|
function LastKey: Pointer;
|
|
function SubMap(FromKey, ToKey: Pointer): IJclPtrSortedMap;
|
|
function TailMap(FromKey: Pointer): IJclPtrSortedMap;
|
|
end;
|
|
|
|
IJclSortedMap = interface(IJclMap)
|
|
['{F317A70F-7851-49C2-9DCF-092D8F4D4F98}']
|
|
function FirstKey: TObject;
|
|
function HeadMap(ToKey: TObject): IJclSortedMap;
|
|
function LastKey: TObject;
|
|
function SubMap(FromKey, ToKey: TObject): IJclSortedMap;
|
|
function TailMap(FromKey: TObject): IJclSortedMap;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclSortedMap<TKey,TValue> = interface(IJclMap<TKey,TValue>)
|
|
['{C62B75C4-891B-442E-A5D6-9954E75A5C0C}']
|
|
function FirstKey: TKey;
|
|
function HeadMap(const ToKey: TKey): IJclSortedMap<TKey,TValue>;
|
|
function LastKey: TKey;
|
|
function SubMap(const FromKey, ToKey: TKey): IJclSortedMap<TKey,TValue>;
|
|
function TailMap(const FromKey: TKey): IJclSortedMap<TKey,TValue>;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfSortedSet = interface(IJclIntfSet)
|
|
['{159BE5A7-7349-42FF-BE55-9CA1B9DBA991}']
|
|
function HeadSet(const Finish: IInterface): IJclIntfSortedSet;
|
|
function SubSet(const Start, Finish: IInterface): IJclIntfSortedSet;
|
|
function TailSet(const Start: IInterface): IJclIntfSortedSet;
|
|
end;
|
|
|
|
IJclAnsiStrSortedSet = interface(IJclAnsiStrSet)
|
|
['{03198146-F967-4310-868B-7AD3D52D5CBE}']
|
|
function HeadSet(const Finish: AnsiString): IJclAnsiStrSortedSet;
|
|
function SubSet(const Start, Finish: AnsiString): IJclAnsiStrSortedSet;
|
|
function TailSet(const Start: AnsiString): IJclAnsiStrSortedSet;
|
|
end;
|
|
|
|
IJclWideStrSortedSet = interface(IJclWideStrSet)
|
|
['{ED9567E2-C1D3-4C00-A1D4-90D5C7E27C2D}']
|
|
function HeadSet(const Finish: WideString): IJclWideStrSortedSet;
|
|
function SubSet(const Start, Finish: WideString): IJclWideStrSortedSet;
|
|
function TailSet(const Start: WideString): IJclWideStrSortedSet;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrSortedSet = interface(IJclUnicodeStrSet)
|
|
['{172BCD6F-D23C-4014-9C8C-A77A27D6E881}']
|
|
function HeadSet(const Finish: UnicodeString): IJclUnicodeStrSortedSet;
|
|
function SubSet(const Start, Finish: UnicodeString): IJclUnicodeStrSortedSet;
|
|
function TailSet(const Start: UnicodeString): IJclUnicodeStrSortedSet;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrSortedSet = IJclAnsiStrSortedSet;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrSortedSet = IJclWideStrSortedSet;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrSortedSet = IJclUnicodeStrSortedSet;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleSortedSet = interface(IJclSingleSet)
|
|
['{65EDA801-9E04-4119-BF9E-D7DD4AF82144}']
|
|
function HeadSet(const Finish: Single): IJclSingleSortedSet;
|
|
function SubSet(const Start, Finish: Single): IJclSingleSortedSet;
|
|
function TailSet(const Start: Single): IJclSingleSortedSet;
|
|
end;
|
|
|
|
IJclDoubleSortedSet = interface(IJclDoubleSet)
|
|
['{DA0E689F-BAFE-4BCE-85E4-C38E780BC84C}']
|
|
function HeadSet(const Finish: Double): IJclDoubleSortedSet;
|
|
function SubSet(const Start, Finish: Double): IJclDoubleSortedSet;
|
|
function TailSet(const Start: Double): IJclDoubleSortedSet;
|
|
end;
|
|
|
|
IJclExtendedSortedSet = interface(IJclExtendedSet)
|
|
['{A9875ED3-81A4-43A3-86BB-3429F51B278B}']
|
|
function HeadSet(const Finish: Extended): IJclExtendedSortedSet;
|
|
function SubSet(const Start, Finish: Extended): IJclExtendedSortedSet;
|
|
function TailSet(const Start: Extended): IJclExtendedSortedSet;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatSortedSet = IJclExtendedSortedSet;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatSortedSet = IJclDoubleSortedSet;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatSortedSet = IJclSingleSortedSet;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerSortedSet = interface(IJclIntegerSet)
|
|
['{E086C54B-4FA3-426D-AC4E-FF8E8CA3D663}']
|
|
function HeadSet(Finish: Integer): IJclIntegerSortedSet;
|
|
function SubSet(Start, Finish: Integer): IJclIntegerSortedSet;
|
|
function TailSet(Start: Integer): IJclIntegerSortedSet;
|
|
end;
|
|
|
|
IJclCardinalSortedSet = interface(IJclCardinalSet)
|
|
['{2D7995C6-A784-48B6-87E9-55D394A72362}']
|
|
function HeadSet(Finish: Cardinal): IJclCardinalSortedSet;
|
|
function SubSet(Start, Finish: Cardinal): IJclCardinalSortedSet;
|
|
function TailSet(Start: Cardinal): IJclCardinalSortedSet;
|
|
end;
|
|
|
|
IJclInt64SortedSet = interface(IJclInt64Set)
|
|
['{4C1C3FCA-6169-4A2F-B044-91AC2AA2E954}']
|
|
function HeadSet(const Finish: Int64): IJclInt64SortedSet;
|
|
function SubSet(const Start, Finish: Int64): IJclInt64SortedSet;
|
|
function TailSet(const Start: Int64): IJclInt64SortedSet;
|
|
end;
|
|
|
|
IJclPtrSortedSet = interface(IJclPtrSet)
|
|
['{F3A3183C-0820-425C-9446-E0838F0ADAD8}']
|
|
function HeadSet(Finish: Pointer): IJclPtrSortedSet;
|
|
function SubSet(Start, Finish: Pointer): IJclPtrSortedSet;
|
|
function TailSet(Start: Pointer): IJclPtrSortedSet;
|
|
end;
|
|
|
|
IJclSortedSet = interface(IJclSet)
|
|
['{A3D23E76-ADE9-446C-9B97-F49FCE895D9F}']
|
|
function HeadSet(Finish: TObject): IJclSortedSet;
|
|
function SubSet(Start, Finish: TObject): IJclSortedSet;
|
|
function TailSet(Start: TObject): IJclSortedSet;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclSortedSet<T> = interface(IJclSet<T>)
|
|
['{30F836E3-2FB1-427E-A499-DFAE201633C8}']
|
|
function HeadSet(const Finish: T): IJclSortedSet<T>;
|
|
function SubSet(const Start, Finish: T): IJclSortedSet<T>;
|
|
function TailSet(const Start: T): IJclSortedSet<T>;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
IJclIntfStack = interface(IJclContainer)
|
|
['{CA1DC7A1-8D8F-4A5D-81D1-0FE32E9A4E84}']
|
|
procedure Clear;
|
|
function Contains(const AInterface: IInterface): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: IInterface;
|
|
function Pop: IInterface;
|
|
function Push(const AInterface: IInterface): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclAnsiStrStack = interface(IJclAnsiStrContainer)
|
|
['{649BB74C-D7BE-40D9-9F4E-32DDC3F13F3B}']
|
|
procedure Clear;
|
|
function Contains(const AString: AnsiString): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: AnsiString;
|
|
function Pop: AnsiString;
|
|
function Push(const AString: AnsiString): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclWideStrStack = interface(IJclWideStrContainer)
|
|
['{B2C3B165-33F1-4B7D-A2EC-0B19D12CE33C}']
|
|
procedure Clear;
|
|
function Contains(const AString: WideString): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: WideString;
|
|
function Pop: WideString;
|
|
function Push(const AString: WideString): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_UNICODE_STRING}
|
|
IJclUnicodeStrStack = interface(IJclUnicodeStrContainer)
|
|
['{BC046C3D-E3D2-42BA-A96D-054834A70404}']
|
|
procedure Clear;
|
|
function Contains(const AString: UnicodeString): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: UnicodeString;
|
|
function Pop: UnicodeString;
|
|
function Push(const AString: UnicodeString): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
{$ENDIF SUPPORTS_UNICODE_STRING}
|
|
|
|
{$IFDEF CONTAINER_ANSISTR}
|
|
IJclStrStack = IJclAnsiStrStack;
|
|
{$ENDIF CONTAINER_ANSISTR}
|
|
{$IFDEF CONTAINER_WIDESTR}
|
|
IJclStrStack = IJclWideStrStack;
|
|
{$ENDIF CONTAINER_WIDESTR}
|
|
{$IFDEF CONTAINER_UNICODESTR}
|
|
IJclStrStack = IJclUnicodeStrStack;
|
|
{$ENDIF CONTAINER_UNICODESTR}
|
|
|
|
IJclSingleStack = interface(IJclSingleContainer)
|
|
['{8DCE45C8-B5B3-43AB-BA08-DAD531CEB9CF}']
|
|
procedure Clear;
|
|
function Contains(const AValue: Single): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: Single;
|
|
function Pop: Single;
|
|
function Push(const AValue: Single): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclDoubleStack = interface(IJclDoubleContainer)
|
|
['{46DF2701-16F0-453C-B938-F04E9C1CEBF8}']
|
|
procedure Clear;
|
|
function Contains(const AValue: Double): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: Double;
|
|
function Pop: Double;
|
|
function Push(const AValue: Double): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclExtendedStack = interface(IJclExtendedContainer)
|
|
['{A2A30585-F561-4757-ABE1-CA511AE72CC5}']
|
|
procedure Clear;
|
|
function Contains(const AValue: Extended): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: Extended;
|
|
function Pop: Extended;
|
|
function Push(const AValue: Extended): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
{$IFDEF MATH_EXTENDED_PRECISION}
|
|
IJclFloatStack = IJclExtendedStack;
|
|
{$ENDIF MATH_EXTENDED_PRECISION}
|
|
{$IFDEF MATH_DOUBLE_PRECISION}
|
|
IJclFloatStack = IJclDoubleStack;
|
|
{$ENDIF MATH_DOUBLE_PRECISION}
|
|
{$IFDEF MATH_SINGLE_PRECISION}
|
|
IJclFloatStack = IJclSingleStack;
|
|
{$ENDIF MATH_SINGLE_PRECISION}
|
|
|
|
IJclIntegerStack = interface(IJclContainer)
|
|
['{9190BF0E-5B0C-4D6C-A107-20A933C9B56A}']
|
|
procedure Clear;
|
|
function Contains(AValue: Integer): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: Integer;
|
|
function Pop: Integer;
|
|
function Push(AValue: Integer): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclCardinalStack = interface(IJclContainer)
|
|
['{94F9EDB3-602B-49CE-9990-0AFDAC556F83}']
|
|
procedure Clear;
|
|
function Contains(AValue: Cardinal): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: Cardinal;
|
|
function Pop: Cardinal;
|
|
function Push(AValue: Cardinal): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclInt64Stack = interface(IJclContainer)
|
|
['{D689EB8F-2746-40E9-AD1B-7E656475FC64}']
|
|
procedure Clear;
|
|
function Contains(const AValue: Int64): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: Int64;
|
|
function Pop: Int64;
|
|
function Push(const AValue: Int64): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclPtrStack = interface(IJclContainer)
|
|
['{AD11D06C-E0E1-4EDE-AA2F-BC8BDD972B73}']
|
|
procedure Clear;
|
|
function Contains(APtr: Pointer): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: Pointer;
|
|
function Pop: Pointer;
|
|
function Push(APtr: Pointer): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
IJclStack = interface(IJclContainer)
|
|
['{E07E0BD8-A831-41B9-B9A0-7199BD4873B9}']
|
|
procedure Clear;
|
|
function Contains(AObject: TObject): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: TObject;
|
|
function Pop: TObject;
|
|
function Push(AObject: TObject): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
|
|
{$IFDEF SUPPORTS_GENERICS}
|
|
IJclStack<T> = interface(IJclContainer)
|
|
['{2F08EAC9-270D-496E-BE10-5E975918A5F2}']
|
|
procedure Clear;
|
|
function Contains(const AItem: T): Boolean;
|
|
function Empty: Boolean;
|
|
function Peek: T;
|
|
function Pop: T;
|
|
function Push(const AItem: T): Boolean;
|
|
function Size: Integer;
|
|
end;
|
|
{$ENDIF SUPPORTS_GENERICS}
|
|
|
|
// Exceptions
|
|
EJclContainerError = class(EJclError);
|
|
|
|
EJclOutOfBoundsError = class(EJclContainerError)
|
|
public
|
|
// RsEOutOfBounds
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclNoSuchElementError = class(EJclContainerError)
|
|
public
|
|
// RsEValueNotFound
|
|
constructor Create(const Value: string);
|
|
end;
|
|
|
|
EJclDuplicateElementError = class(EJclContainerError)
|
|
public
|
|
// RsEDuplicateElement
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclIllegalArgumentError = class(EJclContainerError)
|
|
end;
|
|
|
|
EJclNoCollectionError = class(EJclIllegalArgumentError)
|
|
public
|
|
// RsENoCollection
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclIllegalQueueCapacityError = class(EJclIllegalArgumentError)
|
|
public
|
|
// RsEIllegalQueueCapacity
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclOperationNotSupportedError = class(EJclContainerError)
|
|
public
|
|
// RsEOperationNotSupported
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclNoEqualityComparerError = class(EJclContainerError)
|
|
public
|
|
// RsENoEqualityComparer
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclNoComparerError = class(EJclContainerError)
|
|
public
|
|
// RsENoComparer
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclNoHashConverterError = class(EJclContainerError)
|
|
public
|
|
// RsENoHashConverter
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclIllegalStateOperationError = class(EJclContainerError)
|
|
public
|
|
// RsEIllegalStateOperation
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclAssignError = class(EJclContainerError)
|
|
public
|
|
// RsEAssignError
|
|
constructor Create;
|
|
end;
|
|
|
|
EJclReadOnlyError = class(EJclContainerError)
|
|
public
|
|
// RsEReadOnlyError
|
|
constructor Create;
|
|
end;
|
|
|
|
{$IFDEF UNITVERSIONING}
|
|
const
|
|
UnitVersioning: TUnitVersionInfo = (
|
|
RCSfile: '$URL: https://jcl.svn.sourceforge.net/svnroot/jcl/tags/JCL-2.1-Build3536/jcl/source/common/JclContainerIntf.pas $';
|
|
Revision: '$Revision: 2940 $';
|
|
Date: '$Date: 2009-08-10 19:54:31 +0200 (lun., 10 août 2009) $';
|
|
LogPath: 'JCL\source\common';
|
|
Extra: '';
|
|
Data: nil
|
|
);
|
|
{$ENDIF UNITVERSIONING}
|
|
|
|
implementation
|
|
|
|
uses
|
|
SysUtils,
|
|
JclResources;
|
|
|
|
//=== { EJclOutOfBoundsError } ===============================================
|
|
|
|
constructor EJclOutOfBoundsError.Create;
|
|
begin
|
|
inherited CreateRes(@RsEOutOfBounds);
|
|
end;
|
|
|
|
//=== { EJclNoSuchElementError } =============================================
|
|
|
|
constructor EJclNoSuchElementError.Create(const Value: string);
|
|
begin
|
|
inherited CreateResFmt(@RsEValueNotFound, [Value]);
|
|
end;
|
|
|
|
//=== { EJclDuplicateElementError } ==========================================
|
|
|
|
constructor EJclDuplicateElementError.Create;
|
|
begin
|
|
inherited CreateRes(@RsEDuplicateElement);
|
|
end;
|
|
|
|
//=== { EJclIllegalQueueCapacityError } ======================================
|
|
|
|
constructor EJclIllegalQueueCapacityError.Create;
|
|
begin
|
|
inherited CreateRes(@RsEIllegalQueueCapacity);
|
|
end;
|
|
|
|
//=== { EJclNoCollectionError } ==============================================
|
|
|
|
constructor EJclNoCollectionError.Create;
|
|
begin
|
|
inherited CreateRes(@RsENoCollection);
|
|
end;
|
|
|
|
//=== { EJclOperationNotSupportedError } =====================================
|
|
|
|
constructor EJclOperationNotSupportedError.Create;
|
|
begin
|
|
inherited CreateRes(@RsEOperationNotSupported);
|
|
end;
|
|
|
|
//=== { EJclIllegalStateOperationError } =====================================
|
|
|
|
constructor EJclIllegalStateOperationError.Create;
|
|
begin
|
|
inherited CreateRes(@RsEIllegalStateOperation);
|
|
end;
|
|
|
|
//=== { EJclNoComparerError } ================================================
|
|
|
|
constructor EJclNoComparerError.Create;
|
|
begin
|
|
inherited CreateRes(@RsENoComparer);
|
|
end;
|
|
|
|
//=== { EJclNoEqualityComparerError } ========================================
|
|
|
|
constructor EJclNoEqualityComparerError.Create;
|
|
begin
|
|
inherited CreateRes(@RsENoEqualityComparer);
|
|
end;
|
|
|
|
//=== { EJclNoHashConverterError } ===========================================
|
|
|
|
constructor EJclNoHashConverterError.Create;
|
|
begin
|
|
inherited CreateRes(@RsENoHashConverter);
|
|
end;
|
|
|
|
//=== { EJclAssignError } ====================================================
|
|
|
|
constructor EJclAssignError.Create;
|
|
begin
|
|
inherited CreateRes(@RsEAssignError);
|
|
end;
|
|
|
|
//=== { EJclReadOnlyError } ==================================================
|
|
|
|
constructor EJclReadOnlyError.Create;
|
|
begin
|
|
inherited CreateRes(@RsEReadOnlyError);
|
|
end;
|
|
|
|
{$IFDEF UNITVERSIONING}
|
|
initialization
|
|
RegisterUnitVersion(HInstance, UnitVersioning);
|
|
|
|
finalization
|
|
UnregisterUnitVersion(HInstance);
|
|
{$ENDIF UNITVERSIONING}
|
|
|
|
end.
|
|
|