diff --git a/jcl/source/common/JclContainerIntf.pas b/jcl/source/common/JclContainerIntf.pas index b9f1e98ed0..075de3f914 100644 --- a/jcl/source/common/JclContainerIntf.pas +++ b/jcl/source/common/JclContainerIntf.pas @@ -273,6 +273,408 @@ interface //DOM-IGNORE-END {$ENDIF SUPPORTS_GENERICS} + // map entry types + TJclIntfIntfMapEntry = record + Key: IInterface; + Value: IInterface; + end; + + TJclIntfIntfMapEntryArray = array of TJclIntfIntfMapEntry; + + TJclAnsiStrIntfMapEntry = record + Key: AnsiString; + Value: IInterface; + end; + + TJclAnsiStrIntfMapEntryArray = array of TJclAnsiStrIntfMapEntry; + + TJclIntfAnsiStrMapEntry = record + Key: IInterface; + Value: AnsiString; + end; + + TJclIntfAnsiStrMapEntryArray = array of TJclIntfAnsiStrMapEntry; + + TJclAnsiStrAnsiStrMapEntry = record + Key: AnsiString; + Value: AnsiString; + end; + + TJclAnsiStrAnsiStrMapEntryArray = array of TJclAnsiStrAnsiStrMapEntry; + + TJclWideStrIntfMapEntry = record + Key: WideString; + Value: IInterface; + end; + + TJclWideStrIntfMapEntryArray = array of TJclWideStrIntfMapEntry; + + TJclIntfWideStrMapEntry = record + Key: IInterface; + Value: WideString; + end; + + TJclIntfWideStrMapEntryArray = array of TJclIntfWideStrMapEntry; + + TJclWideStrWideStrMapEntry = record + Key: WideString; + Value: WideString; + end; + + TJclWideStrWideStrMapEntryArray = array of TJclWideStrWideStrMapEntry; + + {$IFDEF SUPPORTS_UNICODE_STRING} + TJclUnicodeStrIntfMapEntry = record + Key: UnicodeString; + Value: IInterface; + end; + + TJclUnicodeStrIntfMapEntryArray = array of TJclUnicodeStrIntfMapEntry; + {$ENDIF SUPPORTS_UNICODE_STRING} + + {$IFDEF SUPPORTS_UNICODE_STRING} + TJclIntfUnicodeStrMapEntry = record + Key: IInterface; + Value: UnicodeString; + end; + + TJclIntfUnicodeStrMapEntryArray = array of TJclIntfUnicodeStrMapEntry; + {$ENDIF SUPPORTS_UNICODE_STRING} + + {$IFDEF SUPPORTS_UNICODE_STRING} + TJclUnicodeStrUnicodeStrMapEntry = record + Key: UnicodeString; + Value: UnicodeString; + end; + + TJclUnicodeStrUnicodeStrMapEntryArray = array of TJclUnicodeStrUnicodeStrMapEntry; + {$ENDIF SUPPORTS_UNICODE_STRING} + + {$IFDEF CONTAINER_ANSISTR} + TJclStrIntfMapEntry = TJclAnsiStrIntfMapEntry; + {$ENDIF CONTAINER_ANSISTR} + {$IFDEF CONTAINER_WIDESTR} + TJclStrIntfMapEntry = TJclWideStrIntfMapEntry; + {$ENDIF CONTAINER_WIDESTR} + {$IFDEF CONTAINER_UNICODESTR} + TJclStrIntfMapEntry = TJclUnicodeStrIntfMapEntry; + {$ENDIF CONTAINER_UNICODESTR} + + {$IFDEF CONTAINER_ANSISTR} + TJclIntfStrMapEntry = TJclIntfAnsiStrMapEntry; + {$ENDIF CONTAINER_ANSISTR} + {$IFDEF CONTAINER_WIDESTR} + TJclIntfStrMapEntry = TJclIntfWideStrMapEntry; + {$ENDIF CONTAINER_WIDESTR} + {$IFDEF CONTAINER_UNICODESTR} + TJclIntfStrMapEntry = TJclIntfUnicodeStrMapEntry; + {$ENDIF CONTAINER_UNICODESTR} + + {$IFDEF CONTAINER_ANSISTR} + TJclStrStrMapEntry = TJclAnsiStrAnsiStrMapEntry; + {$ENDIF CONTAINER_ANSISTR} + {$IFDEF CONTAINER_WIDESTR} + TJclStrStrMapEntry = TJclWideStrWideStrMapEntry; + {$ENDIF CONTAINER_WIDESTR} + {$IFDEF CONTAINER_UNICODESTR} + TJclStrStrMapEntry = TJclUnicodeStrUnicodeStrMapEntry; + {$ENDIF CONTAINER_UNICODESTR} + + TJclSingleIntfMapEntry = record + Key: Single; + Value: IInterface; + end; + + TJclSingleIntfMapEntryArray = array of TJclSingleIntfMapEntry; + + TJclIntfSingleMapEntry = record + Key: IInterface; + Value: Single; + end; + + TJclIntfSingleMapEntryArray = array of TJclIntfSingleMapEntry; + + TJclSingleSingleMapEntry = record + Key: Single; + Value: Single; + end; + + TJclSingleSingleMapEntryArray = array of TJclSingleSingleMapEntry; + + TJclDoubleIntfMapEntry = record + Key: Double; + Value: IInterface; + end; + + TJclDoubleIntfMapEntryArray = array of TJclDoubleIntfMapEntry; + + TJclIntfDoubleMapEntry = record + Key: IInterface; + Value: Double; + end; + + TJclIntfDoubleMapEntryArray = array of TJclIntfDoubleMapEntry; + + TJclDoubleDoubleMapEntry = record + Key: Double; + Value: Double; + end; + + TJclDoubleDoubleMapEntryArray = array of TJclDoubleDoubleMapEntry; + + TJclExtendedIntfMapEntry = record + Key: Extended; + Value: IInterface; + end; + + TJclExtendedIntfMapEntryArray = array of TJclExtendedIntfMapEntry; + + TJclIntfExtendedMapEntry = record + Key: IInterface; + Value: Extended; + end; + + TJclIntfExtendedMapEntryArray = array of TJclIntfExtendedMapEntry; + + TJclExtendedExtendedMapEntry = record + Key: Extended; + Value: Extended; + end; + + TJclExtendedExtendedMapEntryArray = array of TJclExtendedExtendedMapEntry; + + {$IFDEF MATH_SINGLE_PRECISION} + TJclFloatIntfMapEntry = TJclSingleIntfMapEntry; + {$ENDIF MATH_SINGLE_PRECISION} + {$IFDEF MATH_DOUBLE_PRECISION} + TJclFloatIntfMapEntry = TJclDoubleIntfMapEntry; + {$ENDIF MATH_DOUBLE_PRECISION} + {$IFDEF MATH_EXTENDED_PRECISION} + TJclFloatIntfMapEntry = TJclExtendedIntfMapEntry; + {$ENDIF MATH_EXTENDED_PRECISION} + + {$IFDEF MATH_SINGLE_PRECISION} + TJclIntfFloatMapEntry = TJclIntfSingleMapEntry; + {$ENDIF MATH_SINGLE_PRECISION} + {$IFDEF MATH_DOUBLE_PRECISION} + TJclIntfFloatMapEntry = TJclIntfDoubleMapEntry; + {$ENDIF MATH_DOUBLE_PRECISION} + {$IFDEF MATH_EXTENDED_PRECISION} + TJclIntfFloatMapEntry = TJclIntfExtendedMapEntry; + {$ENDIF MATH_EXTENDED_PRECISION} + + {$IFDEF MATH_SINGLE_PRECISION} + TJclFloatFloatMapEntry = TJclSingleSingleMapEntry; + {$ENDIF MATH_SINGLE_PRECISION} + {$IFDEF MATH_DOUBLE_PRECISION} + TJclFloatFloatMapEntry = TJclDoubleDoubleMapEntry; + {$ENDIF MATH_DOUBLE_PRECISION} + {$IFDEF MATH_EXTENDED_PRECISION} + TJclFloatFloatMapEntry = TJclExtendedExtendedMapEntry; + {$ENDIF MATH_EXTENDED_PRECISION} + + TJclIntegerIntfMapEntry = record + Key: Integer; + Value: IInterface; + end; + + TJclIntegerIntfMapEntryArray = array of TJclIntegerIntfMapEntry; + + TJclIntfIntegerMapEntry = record + Key: IInterface; + Value: Integer; + end; + + TJclIntfIntegerMapEntryArray = array of TJclIntfIntegerMapEntry; + + TJclIntegerIntegerMapEntry = record + Key: Integer; + Value: Integer; + end; + + TJclIntegerIntegerMapEntryArray = array of TJclIntegerIntegerMapEntry; + + TJclCardinalIntfMapEntry = record + Key: Cardinal; + Value: IInterface; + end; + + TJclCardinalIntfMapEntryArray = array of TJclCardinalIntfMapEntry; + + TJclIntfCardinalMapEntry = record + Key: IInterface; + Value: Cardinal; + end; + + TJclIntfCardinalMapEntryArray = array of TJclIntfCardinalMapEntry; + + TJclCardinalCardinalMapEntry = record + Key: Cardinal; + Value: Cardinal; + end; + + TJclCardinalCardinalMapEntryArray = array of TJclCardinalCardinalMapEntry; + + TJclInt64IntfMapEntry = record + Key: Int64; + Value: IInterface; + end; + + TJclInt64IntfMapEntryArray = array of TJclInt64IntfMapEntry; + + TJclIntfInt64MapEntry = record + Key: IInterface; + Value: Int64; + end; + + TJclIntfInt64MapEntryArray = array of TJclIntfInt64MapEntry; + + TJclInt64Int64MapEntry = record + Key: Int64; + Value: Int64; + end; + + TJclInt64Int64MapEntryArray = array of TJclInt64Int64MapEntry; + + TJclPtrIntfMapEntry = record + Key: Pointer; + Value: IInterface; + end; + + TJclPtrIntfMapEntryArray = array of TJclPtrIntfMapEntry; + + TJclIntfPtrMapEntry = record + Key: IInterface; + Value: Pointer; + end; + + TJclIntfPtrMapEntryArray = array of TJclIntfPtrMapEntry; + + TJclPtrPtrMapEntry = record + Key: Pointer; + Value: Pointer; + end; + + TJclPtrPtrMapEntryArray = array of TJclPtrPtrMapEntry; + + TJclIntfObjMapEntry = record + Key: IInterface; + Value: TObject; + end; + + TJclIntfObjMapEntryArray = array of TJclIntfObjMapEntry; + + TJclAnsiStrObjMapEntry = record + Key: AnsiString; + Value: TObject; + end; + + TJclAnsiStrObjMapEntryArray = array of TJclAnsiStrObjMapEntry; + + TJclWideStrObjMapEntry = record + Key: WideString; + Value: TObject; + end; + + TJclWideStrObjMapEntryArray = array of TJclWideStrObjMapEntry; + + {$IFDEF SUPPORTS_UNICODE_STRING} + TJclUnicodeStrObjMapEntry = record + Key: UnicodeString; + Value: TObject; + end; + + TJclUnicodeStrObjMapEntryArray = array of TJclUnicodeStrObjMapEntry; + {$ENDIF SUPPORTS_UNICODE_STRING} + + {$IFDEF CONTAINER_ANSISTR} + TJclStrObjMapEntry = TJclAnsiStrObjMapEntry; + {$ENDIF CONTAINER_ANSISTR} + {$IFDEF CONTAINER_WIDESTR} + TJclStrObjMapEntry = TJclWideStrObjMapEntry; + {$ENDIF CONTAINER_WIDESTR} + {$IFDEF CONTAINER_UNICODESTR} + TJclStrObjMapEntry = TJclUnicodeStrObjMapEntry; + {$ENDIF CONTAINER_UNICODESTR} + + TJclSingleObjMapEntry = record + Key: Single; + Value: TObject; + end; + + TJclSingleObjMapEntryArray = array of TJclSingleObjMapEntry; + + TJclDoubleObjMapEntry = record + Key: Double; + Value: TObject; + end; + + TJclDoubleObjMapEntryArray = array of TJclDoubleObjMapEntry; + + TJclExtendedObjMapEntry = record + Key: Extended; + Value: TObject; + end; + + TJclExtendedObjMapEntryArray = array of TJclExtendedObjMapEntry; + + {$IFDEF MATH_SINGLE_PRECISION} + TJclFloatObjMapEntry = TJclSingleObjMapEntry; + {$ENDIF MATH_SINGLE_PRECISION} + {$IFDEF MATH_DOUBLE_PRECISION} + TJclFloatObjMapEntry = TJclDoubleObjMapEntry; + {$ENDIF MATH_DOUBLE_PRECISION} + {$IFDEF MATH_EXTENDED_PRECISION} + TJclFloatObjMapEntry = TJclExtendedObjMapEntry; + {$ENDIF MATH_EXTENDED_PRECISION} + + TJclIntegerObjMapEntry = record + Key: Integer; + Value: TObject; + end; + + TJclIntegerObjMapEntryArray = array of TJclIntegerObjMapEntry; + + TJclCardinalObjMapEntry = record + Key: Cardinal; + Value: TObject; + end; + + TJclCardinalObjMapEntryArray = array of TJclCardinalObjMapEntry; + + TJclInt64ObjMapEntry = record + Key: Int64; + Value: TObject; + end; + + TJclInt64ObjMapEntryArray = array of TJclInt64ObjMapEntry; + + TJclPtrObjMapEntry = record + Key: Pointer; + Value: TObject; + end; + + TJclPtrObjMapEntryArray = array of TJclPtrObjMapEntry; + + TJclObjObjMapEntry = record + Key: TObject; + Value: TObject; + end; + + TJclObjObjMapEntryArray = array of TJclObjObjMapEntry; + + + {$IFDEF SUPPORTS_GENERICS} + //DOM-IGNORE-BEGIN + TJclMapEntry = record + Key: TKey; + Value: TValue; + end; + + TJclMapEntryArray = array of TJclMapEntry; + //DOM-IGNORE-END + {$ENDIF SUPPORTS_GENERICS} + IJclLockable = interface ['{524AD65E-AE1B-4BC6-91C8-8181F0198BA9}'] procedure ReadLock; @@ -1868,6 +2270,1067 @@ interface //DOM-IGNORE-END {$ENDIF SUPPORTS_GENERICS} + IJclIntfIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{CAF455F9-851E-408F-97C8-2781CDE63DCE}'] + function Add(const AEntry: TJclIntfIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfIntfSortedMapIterator): Boolean; + function Next: TJclIntfIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclAnsiStrIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{BF0809BE-007A-4FAD-BFEA-29AB5E5948C6}'] + function Add(const AEntry: TJclAnsiStrIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclAnsiStrIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclAnsiStrIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclAnsiStrIntfSortedMapIterator): Boolean; + function Next: TJclAnsiStrIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclAnsiStrIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclAnsiStrIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclAnsiStrIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfAnsiStrSortedMapIterator = interface(IJclAbstractIterator) + ['{229C5FEB-86D5-48DA-A6AC-FF6D12FFC005}'] + function Add(const AEntry: TJclIntfAnsiStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfAnsiStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfAnsiStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfAnsiStrSortedMapIterator): Boolean; + function Next: TJclIntfAnsiStrMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfAnsiStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfAnsiStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfAnsiStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclAnsiStrAnsiStrSortedMapIterator = interface(IJclAbstractIterator) + ['{41D86675-BA6E-47A2-A47D-3ED95856A010}'] + function Add(const AEntry: TJclAnsiStrAnsiStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclAnsiStrAnsiStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclAnsiStrAnsiStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclAnsiStrAnsiStrSortedMapIterator): Boolean; + function Next: TJclAnsiStrAnsiStrMapEntry; + function NextIndex: Integer; + function Previous: TJclAnsiStrAnsiStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclAnsiStrAnsiStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclAnsiStrAnsiStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclWideStrIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{AF65E496-F3AD-45C4-B4C9-A153B4CBB05A}'] + function Add(const AEntry: TJclWideStrIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclWideStrIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclWideStrIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclWideStrIntfSortedMapIterator): Boolean; + function Next: TJclWideStrIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclWideStrIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclWideStrIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclWideStrIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfWideStrSortedMapIterator = interface(IJclAbstractIterator) + ['{369DFE2E-BA79-4625-A476-B47D004AA612}'] + function Add(const AEntry: TJclIntfWideStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfWideStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfWideStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfWideStrSortedMapIterator): Boolean; + function Next: TJclIntfWideStrMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfWideStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfWideStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfWideStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclWideStrWideStrSortedMapIterator = interface(IJclAbstractIterator) + ['{475964CE-5DCD-4FC7-BCF0-A9FCB1F620C9}'] + function Add(const AEntry: TJclWideStrWideStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclWideStrWideStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclWideStrWideStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclWideStrWideStrSortedMapIterator): Boolean; + function Next: TJclWideStrWideStrMapEntry; + function NextIndex: Integer; + function Previous: TJclWideStrWideStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclWideStrWideStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclWideStrWideStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + {$IFDEF SUPPORTS_UNICODE_STRING} + IJclUnicodeStrIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{C7781D0B-6370-436F-8FA0-4BFDAA472E35}'] + function Add(const AEntry: TJclUnicodeStrIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclUnicodeStrIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclUnicodeStrIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclUnicodeStrIntfSortedMapIterator): Boolean; + function Next: TJclUnicodeStrIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclUnicodeStrIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclUnicodeStrIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclUnicodeStrIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + {$ENDIF SUPPORTS_UNICODE_STRING} + + {$IFDEF SUPPORTS_UNICODE_STRING} + IJclIntfUnicodeStrSortedMapIterator = interface(IJclAbstractIterator) + ['{607194B2-B30E-4756-BE24-1CEB91699D9D}'] + function Add(const AEntry: TJclIntfUnicodeStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfUnicodeStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfUnicodeStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfUnicodeStrSortedMapIterator): Boolean; + function Next: TJclIntfUnicodeStrMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfUnicodeStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfUnicodeStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfUnicodeStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + {$ENDIF SUPPORTS_UNICODE_STRING} + + {$IFDEF SUPPORTS_UNICODE_STRING} + IJclUnicodeStrUnicodeStrSortedMapIterator = interface(IJclAbstractIterator) + ['{81808F34-10FF-4A1F-894F-D39BBF8470AB}'] + function Add(const AEntry: TJclUnicodeStrUnicodeStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclUnicodeStrUnicodeStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclUnicodeStrUnicodeStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclUnicodeStrUnicodeStrSortedMapIterator): Boolean; + function Next: TJclUnicodeStrUnicodeStrMapEntry; + function NextIndex: Integer; + function Previous: TJclUnicodeStrUnicodeStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclUnicodeStrUnicodeStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclUnicodeStrUnicodeStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + {$ENDIF SUPPORTS_UNICODE_STRING} + + {$IFDEF CONTAINER_ANSISTR} + IJclStrIntfSortedMapIterator = IJclAnsiStrIntfSortedMapIterator; + {$ENDIF CONTAINER_ANSISTR} + {$IFDEF CONTAINER_WIDESTR} + IJclStrIntfSortedMapIterator = IJclWideStrIntfSortedMapIterator; + {$ENDIF CONTAINER_WIDESTR} + {$IFDEF CONTAINER_UNICODESTR} + IJclStrIntfSortedMapIterator = IJclUnicodeStrIntfSortedMapIterator; + {$ENDIF CONTAINER_UNICODESTR} + + {$IFDEF CONTAINER_ANSISTR} + IJclIntfStrSortedMapIterator = IJclIntfAnsiStrSortedMapIterator; + {$ENDIF CONTAINER_ANSISTR} + {$IFDEF CONTAINER_WIDESTR} + IJclIntfStrSortedMapIterator = IJclIntfWideStrSortedMapIterator; + {$ENDIF CONTAINER_WIDESTR} + {$IFDEF CONTAINER_UNICODESTR} + IJclIntfStrSortedMapIterator = IJclIntfUnicodeStrSortedMapIterator; + {$ENDIF CONTAINER_UNICODESTR} + + {$IFDEF CONTAINER_ANSISTR} + IJclStrStrSortedMapIterator = IJclAnsiStrAnsiStrSortedMapIterator; + {$ENDIF CONTAINER_ANSISTR} + {$IFDEF CONTAINER_WIDESTR} + IJclStrStrSortedMapIterator = IJclWideStrWideStrSortedMapIterator; + {$ENDIF CONTAINER_WIDESTR} + {$IFDEF CONTAINER_UNICODESTR} + IJclStrStrSortedMapIterator = IJclUnicodeStrUnicodeStrSortedMapIterator; + {$ENDIF CONTAINER_UNICODESTR} + + IJclSingleIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{47E60630-92D9-4191-A979-120B8AE1FC1D}'] + function Add(const AEntry: TJclSingleIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclSingleIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclSingleIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclSingleIntfSortedMapIterator): Boolean; + function Next: TJclSingleIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclSingleIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclSingleIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclSingleIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfSingleSortedMapIterator = interface(IJclAbstractIterator) + ['{B7BF321B-2652-47DE-89D5-813CD92C2B3E}'] + function Add(const AEntry: TJclIntfSingleMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfSingleMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfSingleMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfSingleSortedMapIterator): Boolean; + function Next: TJclIntfSingleMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfSingleMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfSingleMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfSingleMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclSingleSingleSortedMapIterator = interface(IJclAbstractIterator) + ['{F136C49B-A120-4DC3-9014-3BC6C3EB7B0F}'] + function Add(const AEntry: TJclSingleSingleMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclSingleSingleMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclSingleSingleMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclSingleSingleSortedMapIterator): Boolean; + function Next: TJclSingleSingleMapEntry; + function NextIndex: Integer; + function Previous: TJclSingleSingleMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclSingleSingleMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclSingleSingleMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclDoubleIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{DC9C4736-782E-47CA-87A3-7AEDB3C6F777}'] + function Add(const AEntry: TJclDoubleIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclDoubleIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclDoubleIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclDoubleIntfSortedMapIterator): Boolean; + function Next: TJclDoubleIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclDoubleIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclDoubleIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclDoubleIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfDoubleSortedMapIterator = interface(IJclAbstractIterator) + ['{E71488AB-C5CF-4B7E-B38A-DFBB01FBF8D8}'] + function Add(const AEntry: TJclIntfDoubleMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfDoubleMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfDoubleMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfDoubleSortedMapIterator): Boolean; + function Next: TJclIntfDoubleMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfDoubleMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfDoubleMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfDoubleMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclDoubleDoubleSortedMapIterator = interface(IJclAbstractIterator) + ['{85B93232-2862-48F9-9EDA-808DE2B2521F}'] + function Add(const AEntry: TJclDoubleDoubleMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclDoubleDoubleMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclDoubleDoubleMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclDoubleDoubleSortedMapIterator): Boolean; + function Next: TJclDoubleDoubleMapEntry; + function NextIndex: Integer; + function Previous: TJclDoubleDoubleMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclDoubleDoubleMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclDoubleDoubleMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclExtendedIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{4CE090BE-C1DD-460E-A214-92C64A1EBE13}'] + function Add(const AEntry: TJclExtendedIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclExtendedIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclExtendedIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclExtendedIntfSortedMapIterator): Boolean; + function Next: TJclExtendedIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclExtendedIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclExtendedIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclExtendedIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfExtendedSortedMapIterator = interface(IJclAbstractIterator) + ['{1FC3B773-DCF6-40FD-BB0B-98EFEF694888}'] + function Add(const AEntry: TJclIntfExtendedMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfExtendedMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfExtendedMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfExtendedSortedMapIterator): Boolean; + function Next: TJclIntfExtendedMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfExtendedMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfExtendedMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfExtendedMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclExtendedExtendedSortedMapIterator = interface(IJclAbstractIterator) + ['{8997CAA4-CE69-4470-8CD6-47BB54643E14}'] + function Add(const AEntry: TJclExtendedExtendedMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclExtendedExtendedMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclExtendedExtendedMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclExtendedExtendedSortedMapIterator): Boolean; + function Next: TJclExtendedExtendedMapEntry; + function NextIndex: Integer; + function Previous: TJclExtendedExtendedMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclExtendedExtendedMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclExtendedExtendedMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + {$IFDEF MATH_SINGLE_PRECISION} + IJclFloatIntfSortedMapIterator = IJclSingleIntfSortedMapIterator; + {$ENDIF MATH_SINGLE_PRECISION} + {$IFDEF MATH_DOUBLE_PRECISION} + IJclFloatIntfSortedMapIterator = IJclDoubleIntfSortedMapIterator; + {$ENDIF MATH_DOUBLE_PRECISION} + {$IFDEF MATH_EXTENDED_PRECISION} + IJclFloatIntfSortedMapIterator = IJclExtendedIntfSortedMapIterator; + {$ENDIF MATH_EXTENDED_PRECISION} + + {$IFDEF MATH_SINGLE_PRECISION} + IJclIntfFloatSortedMapIterator = IJclIntfSingleSortedMapIterator; + {$ENDIF MATH_SINGLE_PRECISION} + {$IFDEF MATH_DOUBLE_PRECISION} + IJclIntfFloatSortedMapIterator = IJclIntfDoubleSortedMapIterator; + {$ENDIF MATH_DOUBLE_PRECISION} + {$IFDEF MATH_EXTENDED_PRECISION} + IJclIntfFloatSortedMapIterator = IJclIntfExtendedSortedMapIterator; + {$ENDIF MATH_EXTENDED_PRECISION} + + {$IFDEF MATH_SINGLE_PRECISION} + IJclFloatFloatSortedMapIterator = IJclSingleSingleSortedMapIterator; + {$ENDIF MATH_SINGLE_PRECISION} + {$IFDEF MATH_DOUBLE_PRECISION} + IJclFloatFloatSortedMapIterator = IJclDoubleDoubleSortedMapIterator; + {$ENDIF MATH_DOUBLE_PRECISION} + {$IFDEF MATH_EXTENDED_PRECISION} + IJclFloatFloatSortedMapIterator = IJclExtendedExtendedSortedMapIterator; + {$ENDIF MATH_EXTENDED_PRECISION} + + IJclIntegerIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{BD3B48D3-EF75-44E7-B49C-A1140C359CEA}'] + function Add(const AEntry: TJclIntegerIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntegerIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntegerIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntegerIntfSortedMapIterator): Boolean; + function Next: TJclIntegerIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclIntegerIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntegerIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntegerIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfIntegerSortedMapIterator = interface(IJclAbstractIterator) + ['{3E577A0B-CB05-4388-B503-0F58ECA298F4}'] + function Add(const AEntry: TJclIntfIntegerMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfIntegerMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfIntegerMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfIntegerSortedMapIterator): Boolean; + function Next: TJclIntfIntegerMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfIntegerMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfIntegerMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfIntegerMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntegerIntegerSortedMapIterator = interface(IJclAbstractIterator) + ['{0C255B8C-A917-4DA9-A4E2-C3DBC11FFA25}'] + function Add(const AEntry: TJclIntegerIntegerMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntegerIntegerMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntegerIntegerMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntegerIntegerSortedMapIterator): Boolean; + function Next: TJclIntegerIntegerMapEntry; + function NextIndex: Integer; + function Previous: TJclIntegerIntegerMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntegerIntegerMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntegerIntegerMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclCardinalIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{51D7A4B5-5B9C-4AE1-AE33-DF56EB57B4FD}'] + function Add(const AEntry: TJclCardinalIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclCardinalIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclCardinalIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclCardinalIntfSortedMapIterator): Boolean; + function Next: TJclCardinalIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclCardinalIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclCardinalIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclCardinalIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfCardinalSortedMapIterator = interface(IJclAbstractIterator) + ['{F3888CE0-C967-40B2-B725-296553AA1020}'] + function Add(const AEntry: TJclIntfCardinalMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfCardinalMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfCardinalMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfCardinalSortedMapIterator): Boolean; + function Next: TJclIntfCardinalMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfCardinalMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfCardinalMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfCardinalMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclCardinalCardinalSortedMapIterator = interface(IJclAbstractIterator) + ['{38968885-9D36-4E6F-88AD-E79783236915}'] + function Add(const AEntry: TJclCardinalCardinalMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclCardinalCardinalMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclCardinalCardinalMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclCardinalCardinalSortedMapIterator): Boolean; + function Next: TJclCardinalCardinalMapEntry; + function NextIndex: Integer; + function Previous: TJclCardinalCardinalMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclCardinalCardinalMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclCardinalCardinalMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclInt64IntfSortedMapIterator = interface(IJclAbstractIterator) + ['{7A5C332F-6826-42E3-8410-A6F54D9FF1EC}'] + function Add(const AEntry: TJclInt64IntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclInt64IntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclInt64IntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclInt64IntfSortedMapIterator): Boolean; + function Next: TJclInt64IntfMapEntry; + function NextIndex: Integer; + function Previous: TJclInt64IntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclInt64IntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclInt64IntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfInt64SortedMapIterator = interface(IJclAbstractIterator) + ['{8140AF97-0C29-42A9-A56E-E13DF348FADD}'] + function Add(const AEntry: TJclIntfInt64MapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfInt64MapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfInt64MapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfInt64SortedMapIterator): Boolean; + function Next: TJclIntfInt64MapEntry; + function NextIndex: Integer; + function Previous: TJclIntfInt64MapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfInt64MapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfInt64MapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclInt64Int64SortedMapIterator = interface(IJclAbstractIterator) + ['{C9283EE0-6297-43AE-A960-B002313E9F70}'] + function Add(const AEntry: TJclInt64Int64MapEntry): Boolean; + procedure Extract; + function GetEntry: TJclInt64Int64MapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclInt64Int64MapEntry): Boolean; + function IteratorEquals(const AIterator: IJclInt64Int64SortedMapIterator): Boolean; + function Next: TJclInt64Int64MapEntry; + function NextIndex: Integer; + function Previous: TJclInt64Int64MapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclInt64Int64MapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclInt64Int64MapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclPtrIntfSortedMapIterator = interface(IJclAbstractIterator) + ['{137A2DBD-8B20-434D-8518-F130745F3BAC}'] + function Add(const AEntry: TJclPtrIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclPtrIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclPtrIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclPtrIntfSortedMapIterator): Boolean; + function Next: TJclPtrIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclPtrIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclPtrIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclPtrIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfPtrSortedMapIterator = interface(IJclAbstractIterator) + ['{EA1E23CF-4EA4-43AF-8566-ABF26C6B04FF}'] + function Add(const AEntry: TJclIntfPtrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfPtrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfPtrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfPtrSortedMapIterator): Boolean; + function Next: TJclIntfPtrMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfPtrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfPtrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfPtrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclPtrPtrSortedMapIterator = interface(IJclAbstractIterator) + ['{09927643-BC3A-4021-A5A3-C1483A810509}'] + function Add(const AEntry: TJclPtrPtrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclPtrPtrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclPtrPtrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclPtrPtrSortedMapIterator): Boolean; + function Next: TJclPtrPtrMapEntry; + function NextIndex: Integer; + function Previous: TJclPtrPtrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclPtrPtrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclPtrPtrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclIntfObjSortedMapIterator = interface(IJclAbstractIterator) + ['{C6E6DF35-6FAF-4C0A-89C6-4BDF56D4299E}'] + function Add(const AEntry: TJclIntfObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfObjSortedMapIterator): Boolean; + function Next: TJclIntfObjMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclAnsiStrObjSortedMapIterator = interface(IJclAbstractIterator) + ['{EDBAE7CF-4E9A-49B4-A906-599CFC21B484}'] + function Add(const AEntry: TJclAnsiStrObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclAnsiStrObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclAnsiStrObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclAnsiStrObjSortedMapIterator): Boolean; + function Next: TJclAnsiStrObjMapEntry; + function NextIndex: Integer; + function Previous: TJclAnsiStrObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclAnsiStrObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclAnsiStrObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclWideStrObjSortedMapIterator = interface(IJclAbstractIterator) + ['{19FB43BD-42E0-4B59-8EF8-D549A56A43FE}'] + function Add(const AEntry: TJclWideStrObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclWideStrObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclWideStrObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclWideStrObjSortedMapIterator): Boolean; + function Next: TJclWideStrObjMapEntry; + function NextIndex: Integer; + function Previous: TJclWideStrObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclWideStrObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclWideStrObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + {$IFDEF SUPPORTS_UNICODE_STRING} + IJclUnicodeStrObjSortedMapIterator = interface(IJclAbstractIterator) + ['{AB709196-07D6-4D2A-8412-486A592D0B5C}'] + function Add(const AEntry: TJclUnicodeStrObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclUnicodeStrObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclUnicodeStrObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclUnicodeStrObjSortedMapIterator): Boolean; + function Next: TJclUnicodeStrObjMapEntry; + function NextIndex: Integer; + function Previous: TJclUnicodeStrObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclUnicodeStrObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclUnicodeStrObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + {$ENDIF SUPPORTS_UNICODE_STRING} + + {$IFDEF CONTAINER_ANSISTR} + IJclStrObjSortedMapIterator = IJclAnsiStrObjSortedMapIterator; + {$ENDIF CONTAINER_ANSISTR} + {$IFDEF CONTAINER_WIDESTR} + IJclStrObjSortedMapIterator = IJclWideStrObjSortedMapIterator; + {$ENDIF CONTAINER_WIDESTR} + {$IFDEF CONTAINER_UNICODESTR} + IJclStrObjSortedMapIterator = IJclUnicodeStrObjSortedMapIterator; + {$ENDIF CONTAINER_UNICODESTR} + + IJclSingleObjSortedMapIterator = interface(IJclAbstractIterator) + ['{AAB54344-B156-4254-93F3-3359BAA45092}'] + function Add(const AEntry: TJclSingleObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclSingleObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclSingleObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclSingleObjSortedMapIterator): Boolean; + function Next: TJclSingleObjMapEntry; + function NextIndex: Integer; + function Previous: TJclSingleObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclSingleObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclSingleObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclDoubleObjSortedMapIterator = interface(IJclAbstractIterator) + ['{5385B002-AB1E-4E8E-8B8A-5C6EEBEAF0AE}'] + function Add(const AEntry: TJclDoubleObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclDoubleObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclDoubleObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclDoubleObjSortedMapIterator): Boolean; + function Next: TJclDoubleObjMapEntry; + function NextIndex: Integer; + function Previous: TJclDoubleObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclDoubleObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclDoubleObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclExtendedObjSortedMapIterator = interface(IJclAbstractIterator) + ['{4E180C4C-2115-4B8B-B160-A46D8001E0C6}'] + function Add(const AEntry: TJclExtendedObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclExtendedObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclExtendedObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclExtendedObjSortedMapIterator): Boolean; + function Next: TJclExtendedObjMapEntry; + function NextIndex: Integer; + function Previous: TJclExtendedObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclExtendedObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclExtendedObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + {$IFDEF MATH_SINGLE_PRECISION} + IJclFloatObjSortedMapIterator = IJclSingleObjSortedMapIterator; + {$ENDIF MATH_SINGLE_PRECISION} + {$IFDEF MATH_DOUBLE_PRECISION} + IJclFloatObjSortedMapIterator = IJclDoubleObjSortedMapIterator; + {$ENDIF MATH_DOUBLE_PRECISION} + {$IFDEF MATH_EXTENDED_PRECISION} + IJclFloatObjSortedMapIterator = IJclExtendedObjSortedMapIterator; + {$ENDIF MATH_EXTENDED_PRECISION} + + IJclIntegerObjSortedMapIterator = interface(IJclAbstractIterator) + ['{969F91D4-F6B7-4EB0-BEEA-AF1F4A692830}'] + function Add(const AEntry: TJclIntegerObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntegerObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntegerObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntegerObjSortedMapIterator): Boolean; + function Next: TJclIntegerObjMapEntry; + function NextIndex: Integer; + function Previous: TJclIntegerObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntegerObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntegerObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclCardinalObjSortedMapIterator = interface(IJclAbstractIterator) + ['{A0D3E96E-516D-4AAB-BA81-2DF320CF425C}'] + function Add(const AEntry: TJclCardinalObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclCardinalObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclCardinalObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclCardinalObjSortedMapIterator): Boolean; + function Next: TJclCardinalObjMapEntry; + function NextIndex: Integer; + function Previous: TJclCardinalObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclCardinalObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclCardinalObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclInt64ObjSortedMapIterator = interface(IJclAbstractIterator) + ['{96509205-0D23-4DE0-BEA8-5042097F34A9}'] + function Add(const AEntry: TJclInt64ObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclInt64ObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclInt64ObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclInt64ObjSortedMapIterator): Boolean; + function Next: TJclInt64ObjMapEntry; + function NextIndex: Integer; + function Previous: TJclInt64ObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclInt64ObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclInt64ObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclPtrObjSortedMapIterator = interface(IJclAbstractIterator) + ['{7E3528E0-A856-4E4F-BBE0-04C3483CF8D2}'] + function Add(const AEntry: TJclPtrObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclPtrObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclPtrObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclPtrObjSortedMapIterator): Boolean; + function Next: TJclPtrObjMapEntry; + function NextIndex: Integer; + function Previous: TJclPtrObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclPtrObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclPtrObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + IJclObjObjSortedMapIterator = interface(IJclAbstractIterator) + ['{600FA220-5520-4651-9003-ABB01913E697}'] + function Add(const AEntry: TJclObjObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclObjObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclObjObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclObjObjSortedMapIterator): Boolean; + function Next: TJclObjObjMapEntry; + function NextIndex: Integer; + function Previous: TJclObjObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclObjObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclObjObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + + + {$IFDEF SUPPORTS_GENERICS} + //DOM-IGNORE-BEGIN + IJclSortedMapIterator = interface(IJclAbstractIterator) + ['{570920D8-05ED-4CA5-8355-6A899555EBC0}'] + function Add(const AEntry: TJclMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclSortedMapIterator): Boolean; + function Next: TJclMapEntry; + function NextIndex: Integer; + function Previous: TJclMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + //DOM-IGNORE-END + {$ENDIF SUPPORTS_GENERICS} + IJclIntfCollection = interface(IJclIntfFlatContainer) ['{8E178463-4575-487A-B4D5-DC2AED3C7ACA}'] function Add(const AInterface: IInterface): Boolean; diff --git a/jcl/source/common/JclPreProcessorContainerIntfTemplates.pas b/jcl/source/common/JclPreProcessorContainerIntfTemplates.pas index 0b4af97927..69b20a735c 100644 --- a/jcl/source/common/JclPreProcessorContainerIntfTemplates.pas +++ b/jcl/source/common/JclPreProcessorContainerIntfTemplates.pas @@ -61,6 +61,15 @@ TJclContainerIntfAncestorParams = class(TJclContainerIntf1DParams) property AncestorName: string read GetAncestorName write FAncestorName stored IsAncestorNameStored; end; + TJclContainerIntfAncestor2DParams = class(TJclContainerIntf2DParams) + protected + FAncestorName: string; + function GetAncestorName: string; virtual; + function IsAncestorNameStored: Boolean; + public + property AncestorName: string read GetAncestorName write FAncestorName stored IsAncestorNameStored; + end; + TJclContainerIntfFlatAncestorParams = class(TJclContainerIntfAncestorParams) protected function GetAncestorName: string; override; @@ -237,6 +246,19 @@ TJclBinaryTreeIteratorParams = class(TJclContainerIntf1DParams) property TypeName: string index taTypeName read GetTypeAttribute write SetTypeAttribute stored False; end; + (* SORTEDMAPENTRYITERATOR(INTERFACENAME, ANCESTORNAME, GUID, TYPENAME) *) + TJclSortedMapEntryIteratorParams = class(TJclContainerIntfAncestor2DParams) + protected + function GetAncestorName: string; override; + public + function AliasAttributeIDs: TAllTypeAttributeIDs; override; + published + property InterfaceName: string index maSortedMapEntryIteratorInterfaceName read GetMapAttribute write SetMapAttribute stored IsMapAttributeStored; + property AncestorName; + property GUID: string index maSortedMapEntryIteratorInterfaceGUID read GetMapAttribute write SetMapAttribute stored IsMapAttributeStored; + property TypeName: string index maSortedMapEntryTypeName read GetMapAttribute write SetMapAttribute stored False; + end; + (* COLLECTION(INTERFACENAME, ANCESTORNAME, GUID, CONSTKEYWORD, PARAMETERNAME, TYPENAME, ITRNAME) *) TJclCollectionParams = class(TJclContainerIntfFlatAncestorParams) public @@ -412,6 +434,7 @@ procedure RegisterJclContainers; RegisterContainerParams('ITERATOR', TJclIteratorParams); RegisterContainerParams('TREEITERATOR', TJclTreeIteratorParams); RegisterContainerParams('BINTREEITERATOR', TJclBinaryTreeIteratorParams); + RegisterContainerParams('SORTEDMAPENTRYITERATOR', TJclSortedMapEntryIteratorParams); RegisterContainerParams('COLLECTION', TJclCollectionParams); RegisterContainerParams('LIST', TJclListParams); RegisterContainerParams('ARRAY', TJclArrayParams); @@ -440,6 +463,22 @@ function TJclContainerIntfAncestorParams.IsAncestorNameStored: Boolean; Result := FAncestorName <> ''; end; +//=== { TJclContainerIntfAncestor2DParams } ================================== + +function TJclContainerIntfAncestor2DParams.GetAncestorName: string; +begin + Result := FAncestorName; + if Result = '' then + Result := MapInfo.MapAttributes[maMapInterfaceAncestorName]; + if Result = '' then + Result := 'IJclBaseContainer'; +end; + +function TJclContainerIntfAncestor2DParams.IsAncestorNameStored: Boolean; +begin + Result := FAncestorName <> ''; +end; + //=== { TJclIteratorParams } ================================================= function TJclIteratorParams.AliasAttributeIDs: TAllTypeAttributeIDs; @@ -574,6 +613,20 @@ function TJclBinaryTreeIteratorParams.AliasAttributeIDs: TAllTypeAttributeIDs; Result := [taBinaryTreeIteratorInterfaceName]; end; +//=== { TJclSortedMapEntryIteratorParams } =================================== + +function TJclSortedMapEntryIteratorParams.AliasAttributeIDs: TAllTypeAttributeIDs; +begin + Result := [maSortedMapEntryIteratorInterfaceName]; +end; + +function TJclSortedMapEntryIteratorParams.GetAncestorName: string; +begin + Result := FAncestorName; + if Result = '' then + Result := 'IJclAbstractIterator'; +end; + //=== { TJclCollectionParams } =============================================== function TJclCollectionParams.AliasAttributeIDs: TAllTypeAttributeIDs; diff --git a/jcl/source/common/JclPreProcessorContainerKnownMaps.pas b/jcl/source/common/JclPreProcessorContainerKnownMaps.pas index 3b6b926276..ee570b14f0 100644 --- a/jcl/source/common/JclPreProcessorContainerKnownMaps.pas +++ b/jcl/source/common/JclPreProcessorContainerKnownMaps.pas @@ -52,8 +52,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfIntfHashMapBucket', {maHashMapClassName} 'TJclIntfIntfHashMap', - {maSortedMapEntryTypeName} 'TJclIntfIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{CAF455F9-851E-408F-97C8-2781CDE63DCE}', + {maSortedMapEntryIteratorClassName} 'TJclIntfIntfSortedMapIterator' , {maSortedMapClassName} 'TJclIntfIntfSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @IInterfaceKnownType); @@ -70,8 +73,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclAnsiStrIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclAnsiStrIntfHashMapBucket', {maHashMapClassName} 'TJclAnsiStrIntfHashMap', - {maSortedMapEntryTypeName} 'TJclAnsiStrIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclAnsiStrIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclAnsiStrIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclAnsiStrIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclAnsiStrIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{BF0809BE-007A-4FAD-BFEA-29AB5E5948C6}', + {maSortedMapEntryIteratorClassName} 'TJclAnsiStrIntfSortedMapIterator', {maSortedMapClassName} 'TJclAnsiStrIntfSortedMap' ); KeyAttributes: @AnsiStringKnownType; ValueAttributes: @IInterfaceKnownType); @@ -88,8 +94,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclWideStrIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclWideStrIntfHashMapBucket', {maHashMapClassName} 'TJclWideStrIntfHashMap', - {maSortedMapEntryTypeName} 'TJclWideStrIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclWideStrIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclWideStrIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclWideStrIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclWideStrIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{AF65E496-F3AD-45C4-B4C9-A153B4CBB05A}', + {maSortedMapEntryIteratorClassName} 'TJclWideStrIntfSortedMapIterator', {maSortedMapClassName} 'TJclWideStrIntfSortedMap' ); KeyAttributes: @WideStringKnownType; ValueAttributes: @IInterfaceKnownType); @@ -106,8 +115,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclUnicodeStrIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclUnicodeStrIntfHashMapBucket', {maHashMapClassName} 'TJclUnicodeStrIntfHashMap', - {maSortedMapEntryTypeName} 'TJclUnicodeStrIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclUnicodeStrIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclUnicodeStrIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclUnicodeStrIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclUnicodeStrIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{C7781D0B-6370-436F-8FA0-4BFDAA472E35}', + {maSortedMapEntryIteratorClassName} 'TJclUnicodeStrIntfSortedMapIterator', {maSortedMapClassName} 'TJclUnicodeStrIntfSortedMap' ); KeyAttributes: @UnicodeStringKnownType; ValueAttributes: @IInterfaceKnownType); @@ -124,8 +136,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclStrIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclStrIntfHashMapBucket', {maHashMapClassName} 'TJclStrIntfHashMap', - {maSortedMapEntryTypeName} 'TJclStrIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclStrIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclStrIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclStrIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclStrIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '', + {maSortedMapEntryIteratorClassName} 'TJclStrIntfSortedMapIterator', {maSortedMapClassName} 'TJclStrIntfSortedMap' ); KeyAttributes: @StringKnownType; ValueAttributes: @IInterfaceKnownType); @@ -142,8 +157,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfAnsiStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfAnsiStrHashMapBucket', {maHashMapClassName} 'TJclIntfAnsiStrHashMap', - {maSortedMapEntryTypeName} 'TJclIntfAnsiStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfAnsiStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfAnsiStrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfAnsiStrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfAnsiStrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{229C5FEB-86D5-48DA-A6AC-FF6D12FFC005}', + {maSortedMapEntryIteratorClassName} 'TJclIntfAnsiStrSortedMapIterator', {maSortedMapClassName} 'TJclIntfAnsiStrSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @AnsiStringKnownType); @@ -160,8 +178,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfWideStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfWideStrHashMapBucket', {maHashMapClassName} 'TJclIntfWideStrHashMap', - {maSortedMapEntryTypeName} 'TJclIntfWideStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfWideStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfWideStrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfWideStrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfWideStrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{369DFE2E-BA79-4625-A476-B47D004AA612}', + {maSortedMapEntryIteratorClassName} 'TJclIntfWideStrSortedMapIterator', {maSortedMapClassName} 'TJclIntfWideStrSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @WideStringKnownType); @@ -178,8 +199,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfUnicodeStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfUnicodeStrHashMapBucket', {maHashMapClassName} 'TJclIntfUnicodeStrHashMap', - {maSortedMapEntryTypeName} 'TJclIntfUnicodeStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfUnicodeStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfUnicodeStrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfUnicodeStrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfUnicodeStrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{607194B2-B30E-4756-BE24-1CEB91699D9D}', + {maSortedMapEntryIteratorClassName} 'TJclIntfUnicodeStrSortedMapIterator', {maSortedMapClassName} 'TJclIntfUnicodeStrSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @UnicodeStringKnownType); @@ -196,8 +220,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfStrHashMapBucket', {maHashMapClassName} 'TJclIntfStrHashMap', - {maSortedMapEntryTypeName} 'TJclIntfStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfStrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfStrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfStrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '', + {maSortedMapEntryIteratorClassName} 'TJclIntfStrSortedMapIterator', {maSortedMapClassName} 'TJclIntfStrSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @StringKnownType); @@ -214,8 +241,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclAnsiStrAnsiStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclAnsiStrAnsiStrHashMapBucket', {maHashMapClassName} 'TJclAnsiStrAnsiStrHashMap', - {maSortedMapEntryTypeName} 'TJclAnsiStrAnsiStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclAnsiStrAnsiStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclAnsiStrAnsiStrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclAnsiStrAnsiStrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclAnsiStrAnsiStrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{41D86675-BA6E-47A2-A47D-3ED95856A010}', + {maSortedMapEntryIteratorClassName} 'TJclAnsiStrAnsiStrSortedMapIterator', {maSortedMapClassName} 'TJclAnsiStrAnsiStrSortedMap' ); KeyAttributes: @AnsiStringKnownType; ValueAttributes: @AnsiStringKnownType); @@ -232,8 +262,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclWideStrWideStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclWideStrWideStrHashMapBucket', {maHashMapClassName} 'TJclWideStrWideStrHashMap', - {maSortedMapEntryTypeName} 'TJclWideStrWideStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclWideStrWideStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclWideStrWideStrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclWideStrWideStrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclWideStrWideStrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{475964CE-5DCD-4FC7-BCF0-A9FCB1F620C9}', + {maSortedMapEntryIteratorClassName} 'TJclWideStrWideStrSortedMapIterator', {maSortedMapClassName} 'TJclWideStrWideStrSortedMap' ); KeyAttributes: @WideStringKnownType; ValueAttributes: @WideStringKnownType); @@ -250,8 +283,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclUnicodeStrUnicodeStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclUnicodeStrUnicodeStrHashMapBucket', {maHashMapClassName} 'TJclUnicodeStrUnicodeStrHashMap', - {maSortedMapEntryTypeName} 'TJclUnicodeStrUnicodeStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclUnicodeStrUnicodeStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclUnicodeStrUnicodeStrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclUnicodeStrUnicodeStrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclUnicodeStrUnicodeStrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{81808F34-10FF-4A1F-894F-D39BBF8470AB}', + {maSortedMapEntryIteratorClassName} 'TJclUnicodeStrUnicodeStrSortedMapIterator', {maSortedMapClassName} 'TJclUnicodeStrUnicodeStrSortedMap' ); KeyAttributes: @UnicodeStringKnownType; ValueAttributes: @UnicodeStringKnownType); @@ -268,8 +304,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclStrStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclStrStrHashMapBucket', {maHashMapClassName} 'TJclStrStrHashMap', - {maSortedMapEntryTypeName} 'TJclStrStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclStrStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclStrStrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclStrStrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclStrStrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '', + {maSortedMapEntryIteratorClassName} 'TJclStrStrSortedMapIterator', {maSortedMapClassName} 'TJclStrStrSortedMap' ); KeyAttributes: @StringKnownType; ValueAttributes: @StringKnownType); @@ -286,8 +325,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclSingleIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclSingleIntfHashMapBucket', {maHashMapClassName} 'TJclSingleIntfHashMap', - {maSortedMapEntryTypeName} 'TJclSingleIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclSingleIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclSingleIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclSingleIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclSingleIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{47E60630-92D9-4191-A979-120B8AE1FC1D}', + {maSortedMapEntryIteratorClassName} 'TJclSingleIntfSortedMapIterator', {maSortedMapClassName} 'TJclSingleIntfSortedMap' ); KeyAttributes: @SingleKnownType; ValueAttributes: @IInterfaceKnownType); @@ -304,8 +346,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfSingleHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfSingleHashMapBucket', {maHashMapClassName} 'TJclIntfSingleHashMap', - {maSortedMapEntryTypeName} 'TJclIntfSingleSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfSingleSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfSingleMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfSingleMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfSingleSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{B7BF321B-2652-47DE-89D5-813CD92C2B3E}', + {maSortedMapEntryIteratorClassName} 'TJclIntfSingleSortedMapIterator', {maSortedMapClassName} 'TJclIntfSingleSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @SingleKnownType); @@ -322,8 +367,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclSingleSingleHashMapEntryArray', {maHashMapBucketTypeName} 'TJclSingleSingleHashMapBucket', {maHashMapClassName} 'TJclSingleSingleHashMap', - {maSortedMapEntryTypeName} 'TJclSingleSingleSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclSingleSingleSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclSingleSingleMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclSingleSingleMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclSingleSingleSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{F136C49B-A120-4DC3-9014-3BC6C3EB7B0F}', + {maSortedMapEntryIteratorClassName} 'TJclSingleSingleSortedMapIterator', {maSortedMapClassName} 'TJclSingleSingleSortedMap' ); KeyAttributes: @SingleKnownType; ValueAttributes: @SingleKnownType); @@ -340,8 +388,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclDoubleIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclDoubleIntfHashMapBucket', {maHashMapClassName} 'TJclDoubleIntfHashMap', - {maSortedMapEntryTypeName} 'TJclDoubleIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclDoubleIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclDoubleIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclDoubleIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclDoubleIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{DC9C4736-782E-47CA-87A3-7AEDB3C6F777}', + {maSortedMapEntryIteratorClassName} 'TJclDoubleIntfSortedMapIterator', {maSortedMapClassName} 'TJclDoubleIntfSortedMap' ); KeyAttributes: @DoubleKnownType; ValueAttributes: @IInterfaceKnownType); @@ -358,8 +409,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfDoubleHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfDoubleHashMapBucket', {maHashMapClassName} 'TJclIntfDoubleHashMap', - {maSortedMapEntryTypeName} 'TJclIntfDoubleSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfDoubleSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfDoubleMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfDoubleMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfDoubleSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{E71488AB-C5CF-4B7E-B38A-DFBB01FBF8D8}', + {maSortedMapEntryIteratorClassName} 'TJclIntfDoubleSortedMapIterator', {maSortedMapClassName} 'TJclIntfDoubleSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @DoubleKnownType); @@ -376,8 +430,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclDoubleDoubleHashMapEntryArray', {maHashMapBucketTypeName} 'TJclDoubleDoubleHashMapBucket', {maHashMapClassName} 'TJclDoubleDoubleHashMap', - {maSortedMapEntryTypeName} 'TJclDoubleDoubleSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclDoubleDoubleSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclDoubleDoubleMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclDoubleDoubleMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclDoubleDoubleSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{85B93232-2862-48F9-9EDA-808DE2B2521F}', + {maSortedMapEntryIteratorClassName} 'TJclDoubleDoubleSortedMapIterator', {maSortedMapClassName} 'TJclDoubleDoubleSortedMap' ); KeyAttributes: @DoubleKnownType; ValueAttributes: @DoubleKnownType); @@ -394,8 +451,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclExtendedIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclExtendedIntfHashMapBucket', {maHashMapClassName} 'TJclExtendedIntfHashMap', - {maSortedMapEntryTypeName} 'TJclExtendedIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclExtendedIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclExtendedIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclExtendedIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclExtendedIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{4CE090BE-C1DD-460E-A214-92C64A1EBE13}', + {maSortedMapEntryIteratorClassName} 'TJclExtendedIntfSortedMapIterator', {maSortedMapClassName} 'TJclExtendedIntfSortedMap' ); KeyAttributes: @ExtendedKnownType; ValueAttributes: @IInterfaceKnownType); @@ -412,8 +472,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfExtendedHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfExtendedHashMapBucket', {maHashMapClassName} 'TJclIntfExtendedHashMap', - {maSortedMapEntryTypeName} 'TJclIntfExtendedSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfExtendedSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfExtendedMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfExtendedMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfExtendedSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{1FC3B773-DCF6-40FD-BB0B-98EFEF694888}', + {maSortedMapEntryIteratorClassName} 'TJclIntfExtendedSortedMapIterator', {maSortedMapClassName} 'TJclIntfExtendedSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @ExtendedKnownType); @@ -430,8 +493,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclExtendedExtendedHashMapEntryArray', {maHashMapBucketTypeName} 'TJclExtendedExtendedHashMapBucket', {maHashMapClassName} 'TJclExtendedExtendedHashMap', - {maSortedMapEntryTypeName} 'TJclExtendedExtendedSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclExtendedExtendedSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclExtendedExtendedMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclExtendedExtendedMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclExtendedExtendedSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{8997CAA4-CE69-4470-8CD6-47BB54643E14}', + {maSortedMapEntryIteratorClassName} 'TJclExtendedExtendedSortedMapIterator', {maSortedMapClassName} 'TJclExtendedExtendedSortedMap' ); KeyAttributes: @ExtendedKnownType; ValueAttributes: @ExtendedKnownType); @@ -448,8 +514,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclFloatIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclFloatIntfHashMapBucket', {maHashMapClassName} 'TJclFloatIntfHashMap', - {maSortedMapEntryTypeName} 'TJclFloatIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclFloatIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclFloatIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclFloatIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclFloatIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '', + {maSortedMapEntryIteratorClassName} 'TJclFloatIntfSortedMapIterator', {maSortedMapClassName} 'TJclFloatIntfSortedMap' ); KeyAttributes: @FloatKnownType; ValueAttributes: @IInterfaceKnownType); @@ -466,8 +535,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfFloatHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfFloatHashMapBucket', {maHashMapClassName} 'TJclIntfFloatHashMap', - {maSortedMapEntryTypeName} 'TJclIntfFloatSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfFloatSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfFloatMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfFloatMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfFloatSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '', + {maSortedMapEntryIteratorClassName} 'TJclIntfFloatSortedMapIterator', {maSortedMapClassName} 'TJclIntfFloatSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @FloatKnownType); @@ -484,8 +556,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclFloatFloatHashMapEntryArray', {maHashMapBucketTypeName} 'TJclFloatFloatHashMapBucket', {maHashMapClassName} 'TJclFloatFloatHashMap', - {maSortedMapEntryTypeName} 'TJclFloatFloatSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclFloatFloatSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclFloatFloatMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclFloatFloatMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclFloatFloatSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '', + {maSortedMapEntryIteratorClassName} 'TJclFloatFloatSortedMapIterator', {maSortedMapClassName} 'TJclFloatFloatSortedMap' ); KeyAttributes: @FloatKnownType; ValueAttributes: @FloatKnownType); @@ -502,8 +577,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntegerIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntegerIntfHashMapBucket', {maHashMapClassName} 'TJclIntegerIntfHashMap', - {maSortedMapEntryTypeName} 'TJclIntegerIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntegerIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntegerIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntegerIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntegerIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{BD3B48D3-EF75-44E7-B49C-A1140C359CEA}', + {maSortedMapEntryIteratorClassName} 'TJclIntegerIntfSortedMapIterator', {maSortedMapClassName} 'TJclIntegerIntfSortedMap' ); KeyAttributes: @IntegerKnownType; ValueAttributes: @IInterfaceKnownType); @@ -520,8 +598,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfIntegerHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfIntegerHashMapBucket', {maHashMapClassName} 'TJclIntfIntegerHashMap', - {maSortedMapEntryTypeName} 'TJclIntfIntegerSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfIntegerSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfIntegerMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfIntegerMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfIntegerSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{3E577A0B-CB05-4388-B503-0F58ECA298F4}', + {maSortedMapEntryIteratorClassName} 'TJclIntfIntegerSortedMapIterator', {maSortedMapClassName} 'TJclIntfIntegerSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @IntegerKnownType); @@ -538,8 +619,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntegerIntegerHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntegerIntegerHashMapBucket', {maHashMapClassName} 'TJclIntegerIntegerHashMap', - {maSortedMapEntryTypeName} 'TJclIntegerIntegerSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntegerIntegerSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntegerIntegerMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntegerIntegerMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntegerIntegerSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{0C255B8C-A917-4DA9-A4E2-C3DBC11FFA25}', + {maSortedMapEntryIteratorClassName} 'TJclIntegerIntegerSortedMapIterator', {maSortedMapClassName} 'TJclIntegerIntegerSortedMap' ); KeyAttributes: @IntegerKnownType; ValueAttributes: @IntegerKnownType); @@ -556,8 +640,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclCardinalIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclCardinalIntfHashMapBucket', {maHashMapClassName} 'TJclCardinalIntfHashMap', - {maSortedMapEntryTypeName} 'TJclCardinalIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclCardinalIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclCardinalIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclCardinalIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclCardinalIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{51D7A4B5-5B9C-4AE1-AE33-DF56EB57B4FD}', + {maSortedMapEntryIteratorClassName} 'TJclCardinalIntfSortedMapIterator', {maSortedMapClassName} 'TJclCardinalIntfSortedMap' ); KeyAttributes: @CardinalKnownType; ValueAttributes: @IInterfaceKnownType); @@ -574,8 +661,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfCardinalHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfCardinalHashMapBucket', {maHashMapClassName} 'TJclIntfCardinalHashMap', - {maSortedMapEntryTypeName} 'TJclIntfCardinalSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfCardinalSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfCardinalMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfCardinalMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfCardinalSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{F3888CE0-C967-40B2-B725-296553AA1020}', + {maSortedMapEntryIteratorClassName} 'TJclIntfCardinalSortedMapIterator', {maSortedMapClassName} 'TJclIntfCardinalSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @CardinalKnownType); @@ -592,8 +682,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclCardinalCardinalHashMapEntryArray', {maHashMapBucketTypeName} 'TJclCardinalCardinalHashMapBucket', {maHashMapClassName} 'TJclCardinalCardinalHashMap', - {maSortedMapEntryTypeName} 'TJclCardinalCardinalSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclCardinalCardinalSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclCardinalCardinalMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclCardinalCardinalMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclCardinalCardinalSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{38968885-9D36-4E6F-88AD-E79783236915}', + {maSortedMapEntryIteratorClassName} 'TJclCardinalCardinalSortedMapIterator', {maSortedMapClassName} 'TJclCardinalCardinalSortedMap' ); KeyAttributes: @CardinalKnownType; ValueAttributes: @CardinalKnownType); @@ -610,8 +703,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclInt64IntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclInt64IntfHashMapBucket', {maHashMapClassName} 'TJclInt64IntfHashMap', - {maSortedMapEntryTypeName} 'TJclInt64IntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclInt64IntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclInt64IntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclInt64IntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclInt64IntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{7A5C332F-6826-42E3-8410-A6F54D9FF1EC}', + {maSortedMapEntryIteratorClassName} 'TJclInt64IntfSortedMapIterator', {maSortedMapClassName} 'TJclInt64IntfSortedMap' ); KeyAttributes: @Int64KnownType; ValueAttributes: @IInterfaceKnownType); @@ -628,8 +724,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfInt64HashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfInt64HashMapBucket', {maHashMapClassName} 'TJclIntfInt64HashMap', - {maSortedMapEntryTypeName} 'TJclIntfInt64SortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfInt64SortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfInt64MapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfInt64MapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfInt64SortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{8140AF97-0C29-42A9-A56E-E13DF348FADD}', + {maSortedMapEntryIteratorClassName} 'TJclIntfInt64SortedMapIterator', {maSortedMapClassName} 'TJclIntfInt64SortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @Int64KnownType); @@ -646,8 +745,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclInt64Int64HashMapEntryArray', {maHashMapBucketTypeName} 'TJclInt64Int64HashMapBucket', {maHashMapClassName} 'TJclInt64Int64HashMap', - {maSortedMapEntryTypeName} 'TJclInt64Int64SortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclInt64Int64SortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclInt64Int64MapEntry', + {maSortedMapEntryArrayTypeName} 'TJclInt64Int64MapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclInt64Int64SortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{C9283EE0-6297-43AE-A960-B002313E9F70}', + {maSortedMapEntryIteratorClassName} 'TJclInt64Int64SortedMapIterator', {maSortedMapClassName} 'TJclInt64Int64SortedMap' ); KeyAttributes: @Int64KnownType; ValueAttributes: @Int64KnownType); @@ -664,8 +766,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclPtrIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclPtrIntfHashMapBucket', {maHashMapClassName} 'TJclPtrIntfHashMap', - {maSortedMapEntryTypeName} 'TJclPtrIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclPtrIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclPtrIntfMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclPtrIntfMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclPtrIntfSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{137A2DBD-8B20-434D-8518-F130745F3BAC}', + {maSortedMapEntryIteratorClassName} 'TJclPtrIntfSortedMapIterator', {maSortedMapClassName} 'TJclPtrIntfSortedMap' ); KeyAttributes: @PointerKnownType; ValueAttributes: @IInterfaceKnownType); @@ -682,8 +787,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfPtrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfPtrHashMapBucket', {maHashMapClassName} 'TJclIntfPtrHashMap', - {maSortedMapEntryTypeName} 'TJclIntfPtrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfPtrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfPtrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfPtrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfPtrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{EA1E23CF-4EA4-43AF-8566-ABF26C6B04FF}', + {maSortedMapEntryIteratorClassName} 'TJclIntfPtrSortedMapIterator', {maSortedMapClassName} 'TJclIntfPtrSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @PointerKnownType); @@ -700,8 +808,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclPtrPtrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclPtrPtrHashMapBucket', {maHashMapClassName} 'TJclPtrPtrHashMap', - {maSortedMapEntryTypeName} 'TJclPtrPtrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclPtrPtrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclPtrPtrMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclPtrPtrMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclPtrPtrSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{09927643-BC3A-4021-A5A3-C1483A810509}', + {maSortedMapEntryIteratorClassName} 'TJclPtrPtrSortedMapIterator', {maSortedMapClassName} 'TJclPtrPtrSortedMap' ); KeyAttributes: @PointerKnownType; ValueAttributes: @PointerKnownType); @@ -718,8 +829,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntfHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntfHashMapBucket', {maHashMapClassName} 'TJclIntfHashMap', - {maSortedMapEntryTypeName} 'TJclIntfSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntfSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntfObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntfObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntfObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{C6E6DF35-6FAF-4C0A-89C6-4BDF56D4299E}', + {maSortedMapEntryIteratorClassName} 'TJclIntfObjSortedMapIterator', {maSortedMapClassName} 'TJclIntfSortedMap' ); KeyAttributes: @IInterfaceKnownType; ValueAttributes: @TObjectKnownType); @@ -736,8 +850,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclAnsiStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclAnsiStrHashMapBucket', {maHashMapClassName} 'TJclAnsiStrHashMap', - {maSortedMapEntryTypeName} 'TJclAnsiStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclAnsiStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclAnsiStrObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclAnsiStrObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclAnsiStrObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{EDBAE7CF-4E9A-49B4-A906-599CFC21B484}', + {maSortedMapEntryIteratorClassName} 'TJclAnsiStrObjSortedMapIterator', {maSortedMapClassName} 'TJclAnsiStrSortedMap' ); KeyAttributes: @AnsiStringKnownType; ValueAttributes: @TObjectKnownType); @@ -754,8 +871,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclWideStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclWideStrHashMapBucket', {maHashMapClassName} 'TJclWideStrHashMap', - {maSortedMapEntryTypeName} 'TJclWideStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclWideStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclWideStrObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclWideStrObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclWideStrObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{19FB43BD-42E0-4B59-8EF8-D549A56A43FE}', + {maSortedMapEntryIteratorClassName} 'TJclWideStrObjSortedMapIterator', {maSortedMapClassName} 'TJclWideStrSortedMap' ); KeyAttributes: @WideStringKnownType; ValueAttributes: @TObjectKnownType); @@ -772,8 +892,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclUnicodeStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclUnicodeStrHashMapBucket', {maHashMapClassName} 'TJclUnicodeStrHashMap', - {maSortedMapEntryTypeName} 'TJclUnicodeStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclUnicodeStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclUnicodeStrObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclUnicodeStrObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclUnicodeStrObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{AB709196-07D6-4D2A-8412-486A592D0B5C}', + {maSortedMapEntryIteratorClassName} 'TJclUnicodeStrObjSortedMapIterator', {maSortedMapClassName} 'TJclUnicodeStrSortedMap' ); KeyAttributes: @UnicodeStringKnownType; ValueAttributes: @TObjectKnownType); @@ -790,8 +913,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclStrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclStrHashMapBucket', {maHashMapClassName} 'TJclStrHashMap', - {maSortedMapEntryTypeName} 'TJclStrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclStrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclStrObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclStrObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclStrObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '', + {maSortedMapEntryIteratorClassName} 'TJclStrObjSortedMapIterator', {maSortedMapClassName} 'TJclStrSortedMap' ); KeyAttributes: @StringKnownType; ValueAttributes: @TObjectKnownType); @@ -808,8 +934,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclSingleHashMapEntryArray', {maHashMapBucketTypeName} 'TJclSingleHashMapBucket', {maHashMapClassName} 'TJclSingleHashMap', - {maSortedMapEntryTypeName} 'TJclSingleSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclSingleSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclSingleObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclSingleObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclSingleObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{AAB54344-B156-4254-93F3-3359BAA45092}', + {maSortedMapEntryIteratorClassName} 'TJclSingleObjSortedMapIterator', {maSortedMapClassName} 'TJclSingleSortedMap' ); KeyAttributes: @SingleKnownType; ValueAttributes: @TObjectKnownType); @@ -826,8 +955,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclDoubleHashMapEntryArray', {maHashMapBucketTypeName} 'TJclDoubleHashMapBucket', {maHashMapClassName} 'TJclDoubleHashMap', - {maSortedMapEntryTypeName} 'TJclDoubleSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclDoubleSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclDoubleObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclDoubleObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclDoubleObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{5385B002-AB1E-4E8E-8B8A-5C6EEBEAF0AE}', + {maSortedMapEntryIteratorClassName} 'TJclDoubleObjSortedMapIterator', {maSortedMapClassName} 'TJclDoubleSortedMap' ); KeyAttributes: @DoubleKnownType; ValueAttributes: @TObjectKnownType); @@ -844,8 +976,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclExtendedHashMapEntryArray', {maHashMapBucketTypeName} 'TJclExtendedHashMapBucket', {maHashMapClassName} 'TJclExtendedHashMap', - {maSortedMapEntryTypeName} 'TJclExtendedSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclExtendedSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclExtendedObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclExtendedObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclExtendedObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{4E180C4C-2115-4B8B-B160-A46D8001E0C6}', + {maSortedMapEntryIteratorClassName} 'TJclExtendedObjSortedMapIterator', {maSortedMapClassName} 'TJclExtendedSortedMap' ); KeyAttributes: @ExtendedKnownType; ValueAttributes: @TObjectKnownType); @@ -862,8 +997,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclFloatHashMapEntryArray', {maHashMapBucketTypeName} 'TJclFloatHashMapBucket', {maHashMapClassName} 'TJclFloatHashMap', - {maSortedMapEntryTypeName} 'TJclFloatSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclFloatSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclFloatObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclFloatObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclFloatObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '', + {maSortedMapEntryIteratorClassName} 'TJclFloatObjSortedMapIterator', {maSortedMapClassName} 'TJclFloatSortedMap' ); KeyAttributes: @FloatKnownType; ValueAttributes: @TObjectKnownType); @@ -880,8 +1018,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclIntegerHashMapEntryArray', {maHashMapBucketTypeName} 'TJclIntegerHashMapBucket', {maHashMapClassName} 'TJclIntegerHashMap', - {maSortedMapEntryTypeName} 'TJclIntegerSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclIntegerSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclIntegerObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclIntegerObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclIntegerObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{969F91D4-F6B7-4EB0-BEEA-AF1F4A692830}', + {maSortedMapEntryIteratorClassName} 'TJclIntegerObjSortedMapIterator', {maSortedMapClassName} 'TJclIntegerSortedMap' ); KeyAttributes: @IntegerKnownType; ValueAttributes: @TObjectKnownType); @@ -898,8 +1039,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclCardinalHashMapEntryArray', {maHashMapBucketTypeName} 'TJclCardinalHashMapBucket', {maHashMapClassName} 'TJclCardinalHashMap', - {maSortedMapEntryTypeName} 'TJclCardinalSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclCardinalSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclCardinalObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclCardinalObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclCardinalObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{A0D3E96E-516D-4AAB-BA81-2DF320CF425C}', + {maSortedMapEntryIteratorClassName} 'TJclCardinalObjSortedMapIterator', {maSortedMapClassName} 'TJclCardinalSortedMap' ); KeyAttributes: @CardinalKnownType; ValueAttributes: @TObjectKnownType); @@ -916,8 +1060,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclInt64HashMapEntryArray', {maHashMapBucketTypeName} 'TJclInt64HashMapBucket', {maHashMapClassName} 'TJclInt64HashMap', - {maSortedMapEntryTypeName} 'TJclInt64SortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclInt64SortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclInt64ObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclInt64ObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclInt64ObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{96509205-0D23-4DE0-BEA8-5042097F34A9}', + {maSortedMapEntryIteratorClassName} 'TJclInt64ObjSortedMapIterator', {maSortedMapClassName} 'TJclInt64SortedMap' ); KeyAttributes: @Int64KnownType; ValueAttributes: @TObjectKnownType); @@ -934,8 +1081,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclPtrHashMapEntryArray', {maHashMapBucketTypeName} 'TJclPtrHashMapBucket', {maHashMapClassName} 'TJclPtrHashMap', - {maSortedMapEntryTypeName} 'TJclPtrSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclPtrSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclPtrObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclPtrObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclPtrObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{7E3528E0-A856-4E4F-BBE0-04C3483CF8D2}', + {maSortedMapEntryIteratorClassName} 'TJclPtrObjSortedMapIterator', {maSortedMapClassName} 'TJclPtrSortedMap' ); KeyAttributes: @PointerKnownType; ValueAttributes: @TObjectKnownType); @@ -952,8 +1102,11 @@ interface {maHashMapEntryArrayTypeName} 'TJclHashMapEntryArray', {maHashMapBucketTypeName} 'TJclHashMapBucket', {maHashMapClassName} 'TJclHashMap', - {maSortedMapEntryTypeName} 'TJclSortedMapEntry', - {maSortedMapEntryArrayTypeName} 'TJclSortedMapEntryArray', + {maSortedMapEntryTypeName} 'TJclObjObjMapEntry', + {maSortedMapEntryArrayTypeName} 'TJclObjObjMapEntryArray', + {maSortedMapEntryIteratorInterfaceName} 'IJclObjObjSortedMapIterator', + {maSortedMapEntryIteratorInterfaceGUID} '{600FA220-5520-4651-9003-ABB01913E697}', + {maSortedMapEntryIteratorClassName} 'TJclObjObjSortedMapIterator', {maSortedMapClassName} 'TJclSortedMap' ); KeyAttributes: @TObjectKnownType; ValueAttributes: @TObjectKnownType); diff --git a/jcl/source/common/JclPreProcessorContainerTypes.pas b/jcl/source/common/JclPreProcessorContainerTypes.pas index d040fb76bd..c843a7254c 100644 --- a/jcl/source/common/JclPreProcessorContainerTypes.pas +++ b/jcl/source/common/JclPreProcessorContainerTypes.pas @@ -177,6 +177,9 @@ interface maHashMapClassName, maSortedMapEntryTypeName, maSortedMapEntryArrayTypeName, + maSortedMapEntryIteratorInterfaceName, + maSortedMapEntryIteratorInterfaceGUID, + maSortedMapEntryIteratorClassName, maSortedMapClassName); TAllTypeAttributeIDs = set of TAllTypeAttributeID; @@ -353,8 +356,11 @@ TTypeAttributeInfo = record {HashMapEntryArrayTypeName} (IsGUID: False; DefaultValue: 'TJcl%s%sHashEntryArray'), {HashMapBucketTypeName} (IsGUID: False; DefaultValue: 'TJcl%s%sHashBucket'), {HashMapClassName} (IsGUID: False; DefaultValue: 'TJcl%s%sHashMap'), - {SortedMapEntryTypeName} (IsGUID: False; DefaultValue: 'TJcl%s%sSortedEntry'), - {SortedMapEntryArrayTypeName} (IsGUID: False; DefaultValue: 'TJcl%s%sSortedEntryArray'), + {SortedMapEntryTypeName} (IsGUID: False; DefaultValue: 'TJcl%s%sMapEntry'), + {SortedMapEntryArrayTypeName} (IsGUID: False; DefaultValue: 'TJcl%s%sMapEntryArray'), + {SortedMapEntryIteratorInterfaceName} (IsGUID: False; DefaultValue: 'IJcl%s%sSortedMapIterator'), + {SortedMapEntryIteratorInterfaceGUID} (IsGUID: True; DefaultValue: ''), + {SortedMapEntryIteratorClassName} (IsGUID: False; DefaultValue: 'TJcl%s%sSortedMapIterator'), {SortedMapClassName} (IsGUID: False; DefaultValue: 'TJcl%s%sSortedMap') ); type diff --git a/jcl/source/common/JclPreProcessorSortedMapsTemplates.pas b/jcl/source/common/JclPreProcessorSortedMapsTemplates.pas index a3715887a5..dbdb1fc590 100644 --- a/jcl/source/common/JclPreProcessorSortedMapsTemplates.pas +++ b/jcl/source/common/JclPreProcessorSortedMapsTemplates.pas @@ -53,7 +53,7 @@ TJclSortedMapTypeIntParams = class(TJclMapInterfaceParams) end; (* JCLSORTEDMAPINT(ENTRYTYPENAME, ENTRYARRAYTYPENAME, SELFCLASSNAME, ANCESTORNAME, - STDMAPINTERFACENAME, SORTEDMAPINTERFACENAME, + STDMAPINTERFACENAME, SORTEDMAPINTERFACENAME, ITRINTERFACENAME, KEYSETINTERFACENAME, VALUECOLLECTIONINTERFACENAME, INTERFACEADDITIONAL, SECTIONADDITIONAL, KEYOWNERSHIPDECLARATION, VALUEOWNERSHIPDECLARATION, KEYCONSTKEYWORD, KEYTYPENAME, @@ -72,6 +72,7 @@ TJclSortedMapIntParams = class(TJclMapClassInterfaceParams) property AncestorName: string index maMapAncestorClassName read GetMapAttribute write SetMapAttribute stored False; property StdMapInterfaceName: string index maMapInterfaceName read GetMapAttribute write SetMapAttribute stored False; property SortedMapInterfaceName: string index maSortedMapInterfaceName read GetMapAttribute write SetMapAttribute stored False; + property ItrInterfaceName: string index maSortedMapEntryIteratorInterfaceName read GetMapAttribute write SetMapAttribute stored False; property KeySetInterfaceName: string index kaKeySetInterfaceName read GetKeyAttribute write SetKeyAttribute stored False; property ValueCollectionInterfaceName: string index vaValueCollectionInterfaceName read GetValueAttribute write SetValueAttribute stored False; property InterfaceAdditional; @@ -84,8 +85,23 @@ TJclSortedMapIntParams = class(TJclMapClassInterfaceParams) property ValueTypeName; end; + (* JCLSORTEDMAPITRINT(SELFCLASSNAME, ITRINTERFACENAME, MAPCLASSNAME, TYPENAME) *) + TJclSortedMapItrIntParams = class(TJclMapInterfaceParams) + protected + // function CodeUnit: string; override; + public + function AliasAttributeIDs: TAllTypeAttributeIDs; override; + published + property SelfClassName: string index maSortedMapEntryIteratorClassName read GetMapAttribute write SetMapAttribute stored IsMapAttributeStored; + property ItrInterfaceName: string index maSortedMapEntryIteratorInterfaceName read GetMapAttribute write SetMapAttribute stored False; + property GUID: string index maSortedMapEntryIteratorInterfaceGUID read GetMapAttribute write SetMapAttribute stored False; + property MapClassName: string index maSortedMapClassName read GetMapAttribute write SetMapAttribute stored False; + property TypeName: string index maSortedMapEntryTypeName read GetMapAttribute write SetMapAttribute stored False; + end; + (* JCLSORTEDMAPIMP(ENTRYTYPENAME, ENTRYARRAYTYPENAME, SELFCLASSNAME, STDMAPINTERFACENAME, SORTEDMAPINTERFACENAME, + ENTRYITRINTERFACENAME, ENTRYITRCLASSNAME, KEYSETINTERFACENAME, KEYITRINTERFACENAME, VALUECOLLECTIONINTERFACENAME, KEYOWNERSHIPDECLARATION, VALUEOWNERSHIPDECLARATION, @@ -106,6 +122,8 @@ TJclSortedMapImpParams = class(TJclMapClassImplementationParams) property AncestorClassName: string index maMapAncestorClassName read GetMapAttribute write SetMapAttribute stored False; property StdMapInterfaceName: string index maMapInterfaceName read GetMapAttribute write SetMapAttribute stored False; property SortedMapInterfaceName: string index maSortedMapInterfaceName read GetMapAttribute write SetMapAttribute stored False; + property EntryItrInterfaceName: string index maSortedMapEntryIteratorInterfaceName read GetMapAttribute write SetMapAttribute stored False; + property EntryItrClassName: string index maSortedMapEntryIteratorClassName read GetMapAttribute write SetMapAttribute stored False; property KeySetInterfaceName: string index kaKeySetInterfaceName read GetKeyAttribute write SetKeyAttribute stored False; property KeyItrInterfaceName: string index kaKeyIteratorInterfaceName read GetKeyAttribute write SetKeyAttribute stored False; property ValueCollectionInterfaceName: string index vaValueCollectionInterfaceName read GetValueAttribute write SetValueAttribute stored False; @@ -127,6 +145,17 @@ TJclSortedMapImpParams = class(TJclMapClassImplementationParams) property MacroFooter; end; + (* JCLSORTEDMAPITRIMP(SELFCLASSNAME, ITRINTERFACENAME, MAPCLASSNAME, TYPENAME) *) + TJclSortedMapItrImpParams = class(TJclMapImplementationParams) + protected + // function CodeUnit: string; override; + published + property SelfClassName: string index maSortedMapEntryIteratorClassName read GetMapAttribute write SetMapAttribute stored False; + property ItrInterfaceName: string index maSortedMapEntryIteratorInterfaceName read GetMapAttribute write SetMapAttribute stored False; + property MapClassName: string index maSortedMapClassName read GetMapAttribute write SetMapAttribute stored False; + property TypeName: string index maSortedMapEntryTypeName read GetMapAttribute write SetMapAttribute stored False; + end; + {$IFDEF UNITVERSIONING} const UnitVersioning: TUnitVersionInfo = ( @@ -153,7 +182,9 @@ procedure RegisterJclContainers; begin RegisterContainerParams('JCLSORTEDMAPTYPESINT', TJclSortedMapTypeIntParams); RegisterContainerParams('JCLSORTEDMAPINT', TJclSortedMapIntParams); + RegisterContainerParams('JCLSORTEDMAPITRINT', TJclSortedMapItrIntParams); RegisterContainerParams('JCLSORTEDMAPIMP', TJclSortedMapImpParams, TJclSortedMapIntParams); + RegisterContainerParams('JCLSORTEDMAPITRIMP', TJclSortedMapItrImpParams, TJclSortedMapItrIntParams); end; //=== { TJclSortedMapTypeIntParams } ========================================= @@ -177,6 +208,13 @@ function TJclSortedMapIntParams.GetComparisonSectionAdditional: string; [KeyConstKeyword, KeyTypeName, ValueConstKeyword, ValueTypeName]); end; +//=== { TJclSortedMapItrIntParams } ========================================== + +function TJclSortedMapItrIntParams.AliasAttributeIDs: TAllTypeAttributeIDs; +begin + Result := [maSortedMapEntryIteratorClassName]; +end; + //=== { TJclSortedMapImpParams } ============================================= function TJclSortedMapImpParams.GetConstructorParameters: string; diff --git a/jcl/source/common/JclSortedMaps.pas b/jcl/source/common/JclSortedMaps.pas index 2b6f19355e..b47b578e43 100644 --- a/jcl/source/common/JclSortedMaps.pas +++ b/jcl/source/common/JclSortedMaps.pas @@ -54,13 +54,6 @@ interface JclAbstractContainers, JclContainerIntf, JclArrayLists, JclArraySets; type - TJclIntfIntfSortedMapEntry = record - Key: IInterface; - Value: IInterface; - end; - - TJclIntfIntfSortedMapEntryArray = array of TJclIntfIntfSortedMapEntry; - TJclIntfIntfSortedMap = class(TJclIntfAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntfContainer, IJclIntfIntfMap, IJclIntfIntfSortedMap) @@ -71,18 +64,18 @@ TJclIntfIntfSortedMap = class(TJclIntfAbstractContainer, {$IFDEF THREADSAFE} I function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclIntfIntfSortedMapEntryArray; + FEntries: TJclIntfIntfMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -109,15 +102,43 @@ TJclIntfIntfSortedMap = class(TJclIntfAbstractContainer, {$IFDEF THREADSAFE} I function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfIntfSortedMap; function TailMap(const FromKey: IInterface): IJclIntfIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclAnsiStrIntfSortedMapEntry = record - Key: AnsiString; - Value: IInterface; + TJclIntfIntfSortedMapIterator = class(TJclAbstractIterator, IJclIntfIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfIntfSortedMapIterator } + function Add(const AEntry: TJclIntfIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfIntfSortedMapIterator): Boolean; + function Next: TJclIntfIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclAnsiStrIntfSortedMapEntryArray = array of TJclAnsiStrIntfSortedMapEntry; - TJclAnsiStrIntfSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclAnsiStrContainer, IJclIntfContainer, IJclAnsiStrIntfMap, IJclAnsiStrIntfSortedMap) @@ -128,18 +149,18 @@ TJclAnsiStrIntfSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADS function KeysCompare(const A, B: AnsiString): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclAnsiStrIntfSortedMapEntryArray; + FEntries: TJclAnsiStrIntfMapEntryArray; function BinarySearch(const Key: AnsiString): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclAnsiStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclAnsiStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclAnsiStrIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclAnsiStrIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclAnsiStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclAnsiStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclAnsiStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclAnsiStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -166,15 +187,43 @@ TJclAnsiStrIntfSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADS function LastKey: AnsiString; function SubMap(const FromKey, ToKey: AnsiString): IJclAnsiStrIntfSortedMap; function TailMap(const FromKey: AnsiString): IJclAnsiStrIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclAnsiStrIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfAnsiStrSortedMapEntry = record - Key: IInterface; - Value: AnsiString; + TJclAnsiStrIntfSortedMapIterator = class(TJclAbstractIterator, IJclAnsiStrIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclAnsiStrIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclAnsiStrIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclAnsiStrIntfSortedMapIterator } + function Add(const AEntry: TJclAnsiStrIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclAnsiStrIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclAnsiStrIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclAnsiStrIntfSortedMapIterator): Boolean; + function Next: TJclAnsiStrIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclAnsiStrIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclAnsiStrIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclAnsiStrIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfAnsiStrSortedMapEntryArray = array of TJclIntfAnsiStrSortedMapEntry; - TJclIntfAnsiStrSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclIntfContainer, IJclAnsiStrContainer, IJclIntfAnsiStrMap, IJclIntfAnsiStrSortedMap) @@ -185,18 +234,18 @@ TJclIntfAnsiStrSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADS function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(const A, B: AnsiString): Integer; private - FEntries: TJclIntfAnsiStrSortedMapEntryArray; + FEntries: TJclIntfAnsiStrMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfAnsiStrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfAnsiStrMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -223,15 +272,43 @@ TJclIntfAnsiStrSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADS function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfAnsiStrSortedMap; function TailMap(const FromKey: IInterface): IJclIntfAnsiStrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfAnsiStrSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclAnsiStrAnsiStrSortedMapEntry = record - Key: AnsiString; - Value: AnsiString; + TJclIntfAnsiStrSortedMapIterator = class(TJclAbstractIterator, IJclIntfAnsiStrSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfAnsiStrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfAnsiStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfAnsiStrSortedMapIterator } + function Add(const AEntry: TJclIntfAnsiStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfAnsiStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfAnsiStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfAnsiStrSortedMapIterator): Boolean; + function Next: TJclIntfAnsiStrMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfAnsiStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfAnsiStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfAnsiStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclAnsiStrAnsiStrSortedMapEntryArray = array of TJclAnsiStrAnsiStrSortedMapEntry; - TJclAnsiStrAnsiStrSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclAnsiStrContainer, IJclAnsiStrAnsiStrMap, IJclAnsiStrAnsiStrSortedMap) @@ -242,18 +319,18 @@ TJclAnsiStrAnsiStrSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THRE function KeysCompare(const A, B: AnsiString): Integer; function ValuesCompare(const A, B: AnsiString): Integer; private - FEntries: TJclAnsiStrAnsiStrSortedMapEntryArray; + FEntries: TJclAnsiStrAnsiStrMapEntryArray; function BinarySearch(const Key: AnsiString): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclAnsiStrAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclAnsiStrAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclAnsiStrAnsiStrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclAnsiStrAnsiStrMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclAnsiStrAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclAnsiStrAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclAnsiStrAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclAnsiStrAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -280,15 +357,43 @@ TJclAnsiStrAnsiStrSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THRE function LastKey: AnsiString; function SubMap(const FromKey, ToKey: AnsiString): IJclAnsiStrAnsiStrSortedMap; function TailMap(const FromKey: AnsiString): IJclAnsiStrAnsiStrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclAnsiStrAnsiStrSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclWideStrIntfSortedMapEntry = record - Key: WideString; - Value: IInterface; + TJclAnsiStrAnsiStrSortedMapIterator = class(TJclAbstractIterator, IJclAnsiStrAnsiStrSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclAnsiStrAnsiStrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclAnsiStrAnsiStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclAnsiStrAnsiStrSortedMapIterator } + function Add(const AEntry: TJclAnsiStrAnsiStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclAnsiStrAnsiStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclAnsiStrAnsiStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclAnsiStrAnsiStrSortedMapIterator): Boolean; + function Next: TJclAnsiStrAnsiStrMapEntry; + function NextIndex: Integer; + function Previous: TJclAnsiStrAnsiStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclAnsiStrAnsiStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclAnsiStrAnsiStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclWideStrIntfSortedMapEntryArray = array of TJclWideStrIntfSortedMapEntry; - TJclWideStrIntfSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclWideStrContainer, IJclIntfContainer, IJclWideStrIntfMap, IJclWideStrIntfSortedMap) @@ -299,18 +404,18 @@ TJclWideStrIntfSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADS function KeysCompare(const A, B: WideString): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclWideStrIntfSortedMapEntryArray; + FEntries: TJclWideStrIntfMapEntryArray; function BinarySearch(const Key: WideString): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclWideStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclWideStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclWideStrIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclWideStrIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclWideStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclWideStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclWideStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclWideStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -337,15 +442,43 @@ TJclWideStrIntfSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADS function LastKey: WideString; function SubMap(const FromKey, ToKey: WideString): IJclWideStrIntfSortedMap; function TailMap(const FromKey: WideString): IJclWideStrIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclWideStrIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfWideStrSortedMapEntry = record - Key: IInterface; - Value: WideString; + TJclWideStrIntfSortedMapIterator = class(TJclAbstractIterator, IJclWideStrIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclWideStrIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclWideStrIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclWideStrIntfSortedMapIterator } + function Add(const AEntry: TJclWideStrIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclWideStrIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclWideStrIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclWideStrIntfSortedMapIterator): Boolean; + function Next: TJclWideStrIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclWideStrIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclWideStrIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclWideStrIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfWideStrSortedMapEntryArray = array of TJclIntfWideStrSortedMapEntry; - TJclIntfWideStrSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclIntfContainer, IJclWideStrContainer, IJclIntfWideStrMap, IJclIntfWideStrSortedMap) @@ -356,18 +489,18 @@ TJclIntfWideStrSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADS function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(const A, B: WideString): Integer; private - FEntries: TJclIntfWideStrSortedMapEntryArray; + FEntries: TJclIntfWideStrMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfWideStrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfWideStrMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -394,15 +527,43 @@ TJclIntfWideStrSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADS function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfWideStrSortedMap; function TailMap(const FromKey: IInterface): IJclIntfWideStrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfWideStrSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclWideStrWideStrSortedMapEntry = record - Key: WideString; - Value: WideString; + TJclIntfWideStrSortedMapIterator = class(TJclAbstractIterator, IJclIntfWideStrSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfWideStrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfWideStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfWideStrSortedMapIterator } + function Add(const AEntry: TJclIntfWideStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfWideStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfWideStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfWideStrSortedMapIterator): Boolean; + function Next: TJclIntfWideStrMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfWideStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfWideStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfWideStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclWideStrWideStrSortedMapEntryArray = array of TJclWideStrWideStrSortedMapEntry; - TJclWideStrWideStrSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclWideStrContainer, IJclWideStrWideStrMap, IJclWideStrWideStrSortedMap) @@ -413,18 +574,18 @@ TJclWideStrWideStrSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THRE function KeysCompare(const A, B: WideString): Integer; function ValuesCompare(const A, B: WideString): Integer; private - FEntries: TJclWideStrWideStrSortedMapEntryArray; + FEntries: TJclWideStrWideStrMapEntryArray; function BinarySearch(const Key: WideString): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclWideStrWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclWideStrWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclWideStrWideStrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclWideStrWideStrMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclWideStrWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclWideStrWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclWideStrWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclWideStrWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -451,17 +612,43 @@ TJclWideStrWideStrSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THRE function LastKey: WideString; function SubMap(const FromKey, ToKey: WideString): IJclWideStrWideStrSortedMap; function TailMap(const FromKey: WideString): IJclWideStrWideStrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclWideStrWideStrSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - {$IFDEF SUPPORTS_UNICODE_STRING} - TJclUnicodeStrIntfSortedMapEntry = record - Key: UnicodeString; - Value: IInterface; + TJclWideStrWideStrSortedMapIterator = class(TJclAbstractIterator, IJclWideStrWideStrSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclWideStrWideStrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclWideStrWideStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclWideStrWideStrSortedMapIterator } + function Add(const AEntry: TJclWideStrWideStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclWideStrWideStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclWideStrWideStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclWideStrWideStrSortedMapIterator): Boolean; + function Next: TJclWideStrWideStrMapEntry; + function NextIndex: Integer; + function Previous: TJclWideStrWideStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclWideStrWideStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclWideStrWideStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclUnicodeStrIntfSortedMapEntryArray = array of TJclUnicodeStrIntfSortedMapEntry; - {$ENDIF SUPPORTS_UNICODE_STRING} - {$IFDEF SUPPORTS_UNICODE_STRING} TJclUnicodeStrIntfSortedMap = class(TJclUnicodeStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclUnicodeStrContainer, IJclIntfContainer, @@ -473,18 +660,18 @@ TJclUnicodeStrIntfSortedMap = class(TJclUnicodeStrAbstractContainer, {$IFDEF T function KeysCompare(const A, B: UnicodeString): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclUnicodeStrIntfSortedMapEntryArray; + FEntries: TJclUnicodeStrIntfMapEntryArray; function BinarySearch(const Key: UnicodeString): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclUnicodeStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclUnicodeStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclUnicodeStrIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclUnicodeStrIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclUnicodeStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclUnicodeStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclUnicodeStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclUnicodeStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -511,16 +698,44 @@ TJclUnicodeStrIntfSortedMap = class(TJclUnicodeStrAbstractContainer, {$IFDEF T function LastKey: UnicodeString; function SubMap(const FromKey, ToKey: UnicodeString): IJclUnicodeStrIntfSortedMap; function TailMap(const FromKey: UnicodeString): IJclUnicodeStrIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclUnicodeStrIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; {$ENDIF SUPPORTS_UNICODE_STRING} {$IFDEF SUPPORTS_UNICODE_STRING} - TJclIntfUnicodeStrSortedMapEntry = record - Key: IInterface; - Value: UnicodeString; + TJclUnicodeStrIntfSortedMapIterator = class(TJclAbstractIterator, IJclUnicodeStrIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclUnicodeStrIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclUnicodeStrIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclUnicodeStrIntfSortedMapIterator } + function Add(const AEntry: TJclUnicodeStrIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclUnicodeStrIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclUnicodeStrIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclUnicodeStrIntfSortedMapIterator): Boolean; + function Next: TJclUnicodeStrIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclUnicodeStrIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclUnicodeStrIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclUnicodeStrIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - - TJclIntfUnicodeStrSortedMapEntryArray = array of TJclIntfUnicodeStrSortedMapEntry; {$ENDIF SUPPORTS_UNICODE_STRING} {$IFDEF SUPPORTS_UNICODE_STRING} @@ -534,18 +749,18 @@ TJclIntfUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$IFDEF T function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(const A, B: UnicodeString): Integer; private - FEntries: TJclIntfUnicodeStrSortedMapEntryArray; + FEntries: TJclIntfUnicodeStrMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfUnicodeStrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfUnicodeStrMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -572,16 +787,44 @@ TJclIntfUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$IFDEF T function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfUnicodeStrSortedMap; function TailMap(const FromKey: IInterface): IJclIntfUnicodeStrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfUnicodeStrSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; {$ENDIF SUPPORTS_UNICODE_STRING} {$IFDEF SUPPORTS_UNICODE_STRING} - TJclUnicodeStrUnicodeStrSortedMapEntry = record - Key: UnicodeString; - Value: UnicodeString; + TJclIntfUnicodeStrSortedMapIterator = class(TJclAbstractIterator, IJclIntfUnicodeStrSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfUnicodeStrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfUnicodeStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfUnicodeStrSortedMapIterator } + function Add(const AEntry: TJclIntfUnicodeStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfUnicodeStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfUnicodeStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfUnicodeStrSortedMapIterator): Boolean; + function Next: TJclIntfUnicodeStrMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfUnicodeStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfUnicodeStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfUnicodeStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - - TJclUnicodeStrUnicodeStrSortedMapEntryArray = array of TJclUnicodeStrUnicodeStrSortedMapEntry; {$ENDIF SUPPORTS_UNICODE_STRING} {$IFDEF SUPPORTS_UNICODE_STRING} @@ -595,18 +838,18 @@ TJclUnicodeStrUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$I function KeysCompare(const A, B: UnicodeString): Integer; function ValuesCompare(const A, B: UnicodeString): Integer; private - FEntries: TJclUnicodeStrUnicodeStrSortedMapEntryArray; + FEntries: TJclUnicodeStrUnicodeStrMapEntryArray; function BinarySearch(const Key: UnicodeString): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclUnicodeStrUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclUnicodeStrUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclUnicodeStrUnicodeStrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclUnicodeStrUnicodeStrMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclUnicodeStrUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclUnicodeStrUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclUnicodeStrUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclUnicodeStrUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -633,18 +876,45 @@ TJclUnicodeStrUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$I function LastKey: UnicodeString; function SubMap(const FromKey, ToKey: UnicodeString): IJclUnicodeStrUnicodeStrSortedMap; function TailMap(const FromKey: UnicodeString): IJclUnicodeStrUnicodeStrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclUnicodeStrUnicodeStrSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; {$ENDIF SUPPORTS_UNICODE_STRING} - {$IFDEF CONTAINER_ANSISTR} - TJclStrIntfSortedMapEntry = TJclAnsiStrIntfSortedMapEntry; - {$ENDIF CONTAINER_ANSISTR} - {$IFDEF CONTAINER_WIDESTR} - TJclStrIntfSortedMapEntry = TJclWideStrIntfSortedMapEntry; - {$ENDIF CONTAINER_WIDESTR} - {$IFDEF CONTAINER_UNICODESTR} - TJclStrIntfSortedMapEntry = TJclUnicodeStrIntfSortedMapEntry; - {$ENDIF CONTAINER_UNICODESTR} + {$IFDEF SUPPORTS_UNICODE_STRING} + TJclUnicodeStrUnicodeStrSortedMapIterator = class(TJclAbstractIterator, IJclUnicodeStrUnicodeStrSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclUnicodeStrUnicodeStrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclUnicodeStrUnicodeStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclUnicodeStrUnicodeStrSortedMapIterator } + function Add(const AEntry: TJclUnicodeStrUnicodeStrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclUnicodeStrUnicodeStrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclUnicodeStrUnicodeStrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclUnicodeStrUnicodeStrSortedMapIterator): Boolean; + function Next: TJclUnicodeStrUnicodeStrMapEntry; + function NextIndex: Integer; + function Previous: TJclUnicodeStrUnicodeStrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclUnicodeStrUnicodeStrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclUnicodeStrUnicodeStrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; + {$ENDIF SUPPORTS_UNICODE_STRING} {$IFDEF CONTAINER_ANSISTR} TJclStrIntfSortedMap = TJclAnsiStrIntfSortedMap; @@ -657,13 +927,13 @@ TJclUnicodeStrUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$I {$ENDIF CONTAINER_UNICODESTR} {$IFDEF CONTAINER_ANSISTR} - TJclIntfStrSortedMapEntry = TJclIntfAnsiStrSortedMapEntry; + TJclStrIntfSortedMapIterator = TJclAnsiStrIntfSortedMapIterator; {$ENDIF CONTAINER_ANSISTR} {$IFDEF CONTAINER_WIDESTR} - TJclIntfStrSortedMapEntry = TJclIntfWideStrSortedMapEntry; + TJclStrIntfSortedMapIterator = TJclWideStrIntfSortedMapIterator; {$ENDIF CONTAINER_WIDESTR} {$IFDEF CONTAINER_UNICODESTR} - TJclIntfStrSortedMapEntry = TJclIntfUnicodeStrSortedMapEntry; + TJclStrIntfSortedMapIterator = TJclUnicodeStrIntfSortedMapIterator; {$ENDIF CONTAINER_UNICODESTR} {$IFDEF CONTAINER_ANSISTR} @@ -677,13 +947,13 @@ TJclUnicodeStrUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$I {$ENDIF CONTAINER_UNICODESTR} {$IFDEF CONTAINER_ANSISTR} - TJclStrStrSortedMapEntry = TJclAnsiStrAnsiStrSortedMapEntry; + TJclIntfStrSortedMapIterator = TJclIntfAnsiStrSortedMapIterator; {$ENDIF CONTAINER_ANSISTR} {$IFDEF CONTAINER_WIDESTR} - TJclStrStrSortedMapEntry = TJclWideStrWideStrSortedMapEntry; + TJclIntfStrSortedMapIterator = TJclIntfWideStrSortedMapIterator; {$ENDIF CONTAINER_WIDESTR} {$IFDEF CONTAINER_UNICODESTR} - TJclStrStrSortedMapEntry = TJclUnicodeStrUnicodeStrSortedMapEntry; + TJclIntfStrSortedMapIterator = TJclIntfUnicodeStrSortedMapIterator; {$ENDIF CONTAINER_UNICODESTR} {$IFDEF CONTAINER_ANSISTR} @@ -696,12 +966,15 @@ TJclUnicodeStrUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$I TJclStrStrSortedMap = TJclUnicodeStrUnicodeStrSortedMap; {$ENDIF CONTAINER_UNICODESTR} - TJclSingleIntfSortedMapEntry = record - Key: Single; - Value: IInterface; - end; - - TJclSingleIntfSortedMapEntryArray = array of TJclSingleIntfSortedMapEntry; + {$IFDEF CONTAINER_ANSISTR} + TJclStrStrSortedMapIterator = TJclAnsiStrAnsiStrSortedMapIterator; + {$ENDIF CONTAINER_ANSISTR} + {$IFDEF CONTAINER_WIDESTR} + TJclStrStrSortedMapIterator = TJclWideStrWideStrSortedMapIterator; + {$ENDIF CONTAINER_WIDESTR} + {$IFDEF CONTAINER_UNICODESTR} + TJclStrStrSortedMapIterator = TJclUnicodeStrUnicodeStrSortedMapIterator; + {$ENDIF CONTAINER_UNICODESTR} TJclSingleIntfSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclSingleContainer, IJclIntfContainer, @@ -713,18 +986,18 @@ TJclSingleIntfSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAF function KeysCompare(const A, B: Single): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclSingleIntfSortedMapEntryArray; + FEntries: TJclSingleIntfMapEntryArray; function BinarySearch(const Key: Single): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclSingleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclSingleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclSingleIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclSingleIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclSingleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclSingleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclSingleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclSingleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -751,15 +1024,43 @@ TJclSingleIntfSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAF function LastKey: Single; function SubMap(const FromKey, ToKey: Single): IJclSingleIntfSortedMap; function TailMap(const FromKey: Single): IJclSingleIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclSingleIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfSingleSortedMapEntry = record - Key: IInterface; - Value: Single; + TJclSingleIntfSortedMapIterator = class(TJclAbstractIterator, IJclSingleIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclSingleIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclSingleIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclSingleIntfSortedMapIterator } + function Add(const AEntry: TJclSingleIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclSingleIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclSingleIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclSingleIntfSortedMapIterator): Boolean; + function Next: TJclSingleIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclSingleIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclSingleIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclSingleIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfSingleSortedMapEntryArray = array of TJclIntfSingleSortedMapEntry; - TJclIntfSingleSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntfContainer, IJclSingleContainer, IJclIntfSingleMap, IJclIntfSingleSortedMap) @@ -770,18 +1071,18 @@ TJclIntfSingleSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAF function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(const A, B: Single): Integer; private - FEntries: TJclIntfSingleSortedMapEntryArray; + FEntries: TJclIntfSingleMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfSingleSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfSingleMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -808,15 +1109,43 @@ TJclIntfSingleSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAF function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfSingleSortedMap; function TailMap(const FromKey: IInterface): IJclIntfSingleSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfSingleSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclSingleSingleSortedMapEntry = record - Key: Single; - Value: Single; + TJclIntfSingleSortedMapIterator = class(TJclAbstractIterator, IJclIntfSingleSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfSingleSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfSingleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfSingleSortedMapIterator } + function Add(const AEntry: TJclIntfSingleMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfSingleMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfSingleMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfSingleSortedMapIterator): Boolean; + function Next: TJclIntfSingleMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfSingleMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfSingleMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfSingleMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclSingleSingleSortedMapEntryArray = array of TJclSingleSingleSortedMapEntry; - TJclSingleSingleSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclSingleContainer, IJclSingleSingleMap, IJclSingleSingleSortedMap) @@ -827,13 +1156,13 @@ TJclSingleSingleSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADS function KeysCompare(const A, B: Single): Integer; function ValuesCompare(const A, B: Single): Integer; private - FEntries: TJclSingleSingleSortedMapEntryArray; + FEntries: TJclSingleSingleMapEntryArray; function BinarySearch(const Key: Single): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclSingleSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclSingleSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclSingleSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclSingleSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -860,15 +1189,43 @@ TJclSingleSingleSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADS function LastKey: Single; function SubMap(const FromKey, ToKey: Single): IJclSingleSingleSortedMap; function TailMap(const FromKey: Single): IJclSingleSingleSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclSingleSingleSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclDoubleIntfSortedMapEntry = record - Key: Double; - Value: IInterface; + TJclSingleSingleSortedMapIterator = class(TJclAbstractIterator, IJclSingleSingleSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclSingleSingleSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclSingleSingleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclSingleSingleSortedMapIterator } + function Add(const AEntry: TJclSingleSingleMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclSingleSingleMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclSingleSingleMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclSingleSingleSortedMapIterator): Boolean; + function Next: TJclSingleSingleMapEntry; + function NextIndex: Integer; + function Previous: TJclSingleSingleMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclSingleSingleMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclSingleSingleMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclDoubleIntfSortedMapEntryArray = array of TJclDoubleIntfSortedMapEntry; - TJclDoubleIntfSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclDoubleContainer, IJclIntfContainer, IJclDoubleIntfMap, IJclDoubleIntfSortedMap) @@ -879,18 +1236,18 @@ TJclDoubleIntfSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAF function KeysCompare(const A, B: Double): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclDoubleIntfSortedMapEntryArray; + FEntries: TJclDoubleIntfMapEntryArray; function BinarySearch(const Key: Double): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclDoubleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclDoubleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclDoubleIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclDoubleIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclDoubleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclDoubleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclDoubleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclDoubleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -917,15 +1274,43 @@ TJclDoubleIntfSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAF function LastKey: Double; function SubMap(const FromKey, ToKey: Double): IJclDoubleIntfSortedMap; function TailMap(const FromKey: Double): IJclDoubleIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclDoubleIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfDoubleSortedMapEntry = record - Key: IInterface; - Value: Double; + TJclDoubleIntfSortedMapIterator = class(TJclAbstractIterator, IJclDoubleIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclDoubleIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclDoubleIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclDoubleIntfSortedMapIterator } + function Add(const AEntry: TJclDoubleIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclDoubleIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclDoubleIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclDoubleIntfSortedMapIterator): Boolean; + function Next: TJclDoubleIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclDoubleIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclDoubleIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclDoubleIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfDoubleSortedMapEntryArray = array of TJclIntfDoubleSortedMapEntry; - TJclIntfDoubleSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntfContainer, IJclDoubleContainer, IJclIntfDoubleMap, IJclIntfDoubleSortedMap) @@ -936,18 +1321,18 @@ TJclIntfDoubleSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAF function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(const A, B: Double): Integer; private - FEntries: TJclIntfDoubleSortedMapEntryArray; + FEntries: TJclIntfDoubleMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfDoubleSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfDoubleMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -974,15 +1359,43 @@ TJclIntfDoubleSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAF function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfDoubleSortedMap; function TailMap(const FromKey: IInterface): IJclIntfDoubleSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfDoubleSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclDoubleDoubleSortedMapEntry = record - Key: Double; - Value: Double; + TJclIntfDoubleSortedMapIterator = class(TJclAbstractIterator, IJclIntfDoubleSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfDoubleSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfDoubleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfDoubleSortedMapIterator } + function Add(const AEntry: TJclIntfDoubleMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfDoubleMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfDoubleMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfDoubleSortedMapIterator): Boolean; + function Next: TJclIntfDoubleMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfDoubleMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfDoubleMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfDoubleMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclDoubleDoubleSortedMapEntryArray = array of TJclDoubleDoubleSortedMapEntry; - TJclDoubleDoubleSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclDoubleContainer, IJclDoubleDoubleMap, IJclDoubleDoubleSortedMap) @@ -993,13 +1406,13 @@ TJclDoubleDoubleSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADS function KeysCompare(const A, B: Double): Integer; function ValuesCompare(const A, B: Double): Integer; private - FEntries: TJclDoubleDoubleSortedMapEntryArray; + FEntries: TJclDoubleDoubleMapEntryArray; function BinarySearch(const Key: Double): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclDoubleDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclDoubleDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclDoubleDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclDoubleDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1026,15 +1439,43 @@ TJclDoubleDoubleSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADS function LastKey: Double; function SubMap(const FromKey, ToKey: Double): IJclDoubleDoubleSortedMap; function TailMap(const FromKey: Double): IJclDoubleDoubleSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclDoubleDoubleSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclExtendedIntfSortedMapEntry = record - Key: Extended; - Value: IInterface; + TJclDoubleDoubleSortedMapIterator = class(TJclAbstractIterator, IJclDoubleDoubleSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclDoubleDoubleSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclDoubleDoubleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclDoubleDoubleSortedMapIterator } + function Add(const AEntry: TJclDoubleDoubleMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclDoubleDoubleMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclDoubleDoubleMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclDoubleDoubleSortedMapIterator): Boolean; + function Next: TJclDoubleDoubleMapEntry; + function NextIndex: Integer; + function Previous: TJclDoubleDoubleMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclDoubleDoubleMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclDoubleDoubleMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclExtendedIntfSortedMapEntryArray = array of TJclExtendedIntfSortedMapEntry; - TJclExtendedIntfSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclExtendedContainer, IJclIntfContainer, IJclExtendedIntfMap, IJclExtendedIntfSortedMap) @@ -1045,18 +1486,18 @@ TJclExtendedIntfSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREA function KeysCompare(const A, B: Extended): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclExtendedIntfSortedMapEntryArray; + FEntries: TJclExtendedIntfMapEntryArray; function BinarySearch(const Key: Extended): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclExtendedIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclExtendedIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclExtendedIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclExtendedIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclExtendedIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclExtendedIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclExtendedIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclExtendedIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1083,15 +1524,43 @@ TJclExtendedIntfSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREA function LastKey: Extended; function SubMap(const FromKey, ToKey: Extended): IJclExtendedIntfSortedMap; function TailMap(const FromKey: Extended): IJclExtendedIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclExtendedIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfExtendedSortedMapEntry = record - Key: IInterface; - Value: Extended; + TJclExtendedIntfSortedMapIterator = class(TJclAbstractIterator, IJclExtendedIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclExtendedIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclExtendedIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclExtendedIntfSortedMapIterator } + function Add(const AEntry: TJclExtendedIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclExtendedIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclExtendedIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclExtendedIntfSortedMapIterator): Boolean; + function Next: TJclExtendedIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclExtendedIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclExtendedIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclExtendedIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfExtendedSortedMapEntryArray = array of TJclIntfExtendedSortedMapEntry; - TJclIntfExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntfContainer, IJclExtendedContainer, IJclIntfExtendedMap, IJclIntfExtendedSortedMap) @@ -1102,18 +1571,18 @@ TJclIntfExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREA function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(const A, B: Extended): Integer; private - FEntries: TJclIntfExtendedSortedMapEntryArray; + FEntries: TJclIntfExtendedMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfExtendedSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfExtendedMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1140,15 +1609,43 @@ TJclIntfExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREA function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfExtendedSortedMap; function TailMap(const FromKey: IInterface): IJclIntfExtendedSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfExtendedSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclExtendedExtendedSortedMapEntry = record - Key: Extended; - Value: Extended; + TJclIntfExtendedSortedMapIterator = class(TJclAbstractIterator, IJclIntfExtendedSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfExtendedSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfExtendedSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfExtendedSortedMapIterator } + function Add(const AEntry: TJclIntfExtendedMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfExtendedMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfExtendedMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfExtendedSortedMapIterator): Boolean; + function Next: TJclIntfExtendedMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfExtendedMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfExtendedMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfExtendedMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclExtendedExtendedSortedMapEntryArray = array of TJclExtendedExtendedSortedMapEntry; - TJclExtendedExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclExtendedContainer, IJclExtendedExtendedMap, IJclExtendedExtendedSortedMap) @@ -1159,13 +1656,13 @@ TJclExtendedExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF T function KeysCompare(const A, B: Extended): Integer; function ValuesCompare(const A, B: Extended): Integer; private - FEntries: TJclExtendedExtendedSortedMapEntryArray; + FEntries: TJclExtendedExtendedMapEntryArray; function BinarySearch(const Key: Extended): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclExtendedExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclExtendedExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclExtendedExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclExtendedExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1192,17 +1689,42 @@ TJclExtendedExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF T function LastKey: Extended; function SubMap(const FromKey, ToKey: Extended): IJclExtendedExtendedSortedMap; function TailMap(const FromKey: Extended): IJclExtendedExtendedSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclExtendedExtendedSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - {$IFDEF MATH_SINGLE_PRECISION} - TJclFloatIntfSortedMapEntry = TJclSingleIntfSortedMapEntry; - {$ENDIF MATH_SINGLE_PRECISION} - {$IFDEF MATH_DOUBLE_PRECISION} - TJclFloatIntfSortedMapEntry = TJclDoubleIntfSortedMapEntry; - {$ENDIF MATH_DOUBLE_PRECISION} - {$IFDEF MATH_EXTENDED_PRECISION} - TJclFloatIntfSortedMapEntry = TJclExtendedIntfSortedMapEntry; - {$ENDIF MATH_EXTENDED_PRECISION} + TJclExtendedExtendedSortedMapIterator = class(TJclAbstractIterator, IJclExtendedExtendedSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclExtendedExtendedSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclExtendedExtendedSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclExtendedExtendedSortedMapIterator } + function Add(const AEntry: TJclExtendedExtendedMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclExtendedExtendedMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclExtendedExtendedMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclExtendedExtendedSortedMapIterator): Boolean; + function Next: TJclExtendedExtendedMapEntry; + function NextIndex: Integer; + function Previous: TJclExtendedExtendedMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclExtendedExtendedMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclExtendedExtendedMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} + end; {$IFDEF MATH_SINGLE_PRECISION} TJclFloatIntfSortedMap = TJclSingleIntfSortedMap; @@ -1215,13 +1737,13 @@ TJclExtendedExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF T {$ENDIF MATH_EXTENDED_PRECISION} {$IFDEF MATH_SINGLE_PRECISION} - TJclIntfFloatSortedMapEntry = TJclIntfSingleSortedMapEntry; + TJclFloatIntfSortedMapIterator = TJclSingleIntfSortedMapIterator; {$ENDIF MATH_SINGLE_PRECISION} {$IFDEF MATH_DOUBLE_PRECISION} - TJclIntfFloatSortedMapEntry = TJclIntfDoubleSortedMapEntry; + TJclFloatIntfSortedMapIterator = TJclDoubleIntfSortedMapIterator; {$ENDIF MATH_DOUBLE_PRECISION} {$IFDEF MATH_EXTENDED_PRECISION} - TJclIntfFloatSortedMapEntry = TJclIntfExtendedSortedMapEntry; + TJclFloatIntfSortedMapIterator = TJclExtendedIntfSortedMapIterator; {$ENDIF MATH_EXTENDED_PRECISION} {$IFDEF MATH_SINGLE_PRECISION} @@ -1235,13 +1757,13 @@ TJclExtendedExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF T {$ENDIF MATH_EXTENDED_PRECISION} {$IFDEF MATH_SINGLE_PRECISION} - TJclFloatFloatSortedMapEntry = TJclSingleSingleSortedMapEntry; + TJclIntfFloatSortedMapIterator = TJclIntfSingleSortedMapIterator; {$ENDIF MATH_SINGLE_PRECISION} {$IFDEF MATH_DOUBLE_PRECISION} - TJclFloatFloatSortedMapEntry = TJclDoubleDoubleSortedMapEntry; + TJclIntfFloatSortedMapIterator = TJclIntfDoubleSortedMapIterator; {$ENDIF MATH_DOUBLE_PRECISION} {$IFDEF MATH_EXTENDED_PRECISION} - TJclFloatFloatSortedMapEntry = TJclExtendedExtendedSortedMapEntry; + TJclIntfFloatSortedMapIterator = TJclIntfExtendedSortedMapIterator; {$ENDIF MATH_EXTENDED_PRECISION} {$IFDEF MATH_SINGLE_PRECISION} @@ -1254,12 +1776,15 @@ TJclExtendedExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF T TJclFloatFloatSortedMap = TJclExtendedExtendedSortedMap; {$ENDIF MATH_EXTENDED_PRECISION} - TJclIntegerIntfSortedMapEntry = record - Key: Integer; - Value: IInterface; - end; - - TJclIntegerIntfSortedMapEntryArray = array of TJclIntegerIntfSortedMapEntry; + {$IFDEF MATH_SINGLE_PRECISION} + TJclFloatFloatSortedMapIterator = TJclSingleSingleSortedMapIterator; + {$ENDIF MATH_SINGLE_PRECISION} + {$IFDEF MATH_DOUBLE_PRECISION} + TJclFloatFloatSortedMapIterator = TJclDoubleDoubleSortedMapIterator; + {$ENDIF MATH_DOUBLE_PRECISION} + {$IFDEF MATH_EXTENDED_PRECISION} + TJclFloatFloatSortedMapIterator = TJclExtendedExtendedSortedMapIterator; + {$ENDIF MATH_EXTENDED_PRECISION} TJclIntegerIntfSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntegerContainer, IJclIntfContainer, @@ -1271,18 +1796,18 @@ TJclIntegerIntfSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADS function KeysCompare(A, B: Integer): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclIntegerIntfSortedMapEntryArray; + FEntries: TJclIntegerIntfMapEntryArray; function BinarySearch(Key: Integer): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntegerIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntegerIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntegerIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntegerIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntegerIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntegerIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntegerIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntegerIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1309,15 +1834,43 @@ TJclIntegerIntfSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADS function LastKey: Integer; function SubMap(FromKey, ToKey: Integer): IJclIntegerIntfSortedMap; function TailMap(FromKey: Integer): IJclIntegerIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntegerIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfIntegerSortedMapEntry = record - Key: IInterface; - Value: Integer; + TJclIntegerIntfSortedMapIterator = class(TJclAbstractIterator, IJclIntegerIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntegerIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntegerIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntegerIntfSortedMapIterator } + function Add(const AEntry: TJclIntegerIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntegerIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntegerIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntegerIntfSortedMapIterator): Boolean; + function Next: TJclIntegerIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclIntegerIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntegerIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntegerIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfIntegerSortedMapEntryArray = array of TJclIntfIntegerSortedMapEntry; - TJclIntfIntegerSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntfContainer, IJclIntegerContainer, IJclIntfIntegerMap, IJclIntfIntegerSortedMap) @@ -1328,18 +1881,18 @@ TJclIntfIntegerSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADS function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(A, B: Integer): Integer; private - FEntries: TJclIntfIntegerSortedMapEntryArray; + FEntries: TJclIntfIntegerMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfIntegerSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfIntegerMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1366,15 +1919,43 @@ TJclIntfIntegerSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADS function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfIntegerSortedMap; function TailMap(const FromKey: IInterface): IJclIntfIntegerSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfIntegerSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntegerIntegerSortedMapEntry = record - Key: Integer; - Value: Integer; + TJclIntfIntegerSortedMapIterator = class(TJclAbstractIterator, IJclIntfIntegerSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfIntegerSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfIntegerSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfIntegerSortedMapIterator } + function Add(const AEntry: TJclIntfIntegerMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfIntegerMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfIntegerMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfIntegerSortedMapIterator): Boolean; + function Next: TJclIntfIntegerMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfIntegerMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfIntegerMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfIntegerMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntegerIntegerSortedMapEntryArray = array of TJclIntegerIntegerSortedMapEntry; - TJclIntegerIntegerSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntegerContainer, IJclIntegerIntegerMap, IJclIntegerIntegerSortedMap) @@ -1385,13 +1966,13 @@ TJclIntegerIntegerSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THRE function KeysCompare(A, B: Integer): Integer; function ValuesCompare(A, B: Integer): Integer; private - FEntries: TJclIntegerIntegerSortedMapEntryArray; + FEntries: TJclIntegerIntegerMapEntryArray; function BinarySearch(Key: Integer): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclIntegerIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntegerIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntegerIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntegerIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1418,15 +1999,43 @@ TJclIntegerIntegerSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THRE function LastKey: Integer; function SubMap(FromKey, ToKey: Integer): IJclIntegerIntegerSortedMap; function TailMap(FromKey: Integer): IJclIntegerIntegerSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntegerIntegerSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclCardinalIntfSortedMapEntry = record - Key: Cardinal; - Value: IInterface; + TJclIntegerIntegerSortedMapIterator = class(TJclAbstractIterator, IJclIntegerIntegerSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntegerIntegerSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntegerIntegerSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntegerIntegerSortedMapIterator } + function Add(const AEntry: TJclIntegerIntegerMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntegerIntegerMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntegerIntegerMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntegerIntegerSortedMapIterator): Boolean; + function Next: TJclIntegerIntegerMapEntry; + function NextIndex: Integer; + function Previous: TJclIntegerIntegerMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntegerIntegerMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntegerIntegerMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclCardinalIntfSortedMapEntryArray = array of TJclCardinalIntfSortedMapEntry; - TJclCardinalIntfSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclCardinalContainer, IJclIntfContainer, IJclCardinalIntfMap, IJclCardinalIntfSortedMap) @@ -1437,18 +2046,18 @@ TJclCardinalIntfSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREA function KeysCompare(A, B: Cardinal): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclCardinalIntfSortedMapEntryArray; + FEntries: TJclCardinalIntfMapEntryArray; function BinarySearch(Key: Cardinal): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclCardinalIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclCardinalIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclCardinalIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclCardinalIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclCardinalIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclCardinalIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclCardinalIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclCardinalIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1475,15 +2084,43 @@ TJclCardinalIntfSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREA function LastKey: Cardinal; function SubMap(FromKey, ToKey: Cardinal): IJclCardinalIntfSortedMap; function TailMap(FromKey: Cardinal): IJclCardinalIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclCardinalIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfCardinalSortedMapEntry = record - Key: IInterface; - Value: Cardinal; + TJclCardinalIntfSortedMapIterator = class(TJclAbstractIterator, IJclCardinalIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclCardinalIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclCardinalIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclCardinalIntfSortedMapIterator } + function Add(const AEntry: TJclCardinalIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclCardinalIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclCardinalIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclCardinalIntfSortedMapIterator): Boolean; + function Next: TJclCardinalIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclCardinalIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclCardinalIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclCardinalIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfCardinalSortedMapEntryArray = array of TJclIntfCardinalSortedMapEntry; - TJclIntfCardinalSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntfContainer, IJclCardinalContainer, IJclIntfCardinalMap, IJclIntfCardinalSortedMap) @@ -1494,18 +2131,18 @@ TJclIntfCardinalSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREA function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(A, B: Cardinal): Integer; private - FEntries: TJclIntfCardinalSortedMapEntryArray; + FEntries: TJclIntfCardinalMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfCardinalSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfCardinalMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1532,15 +2169,43 @@ TJclIntfCardinalSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREA function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfCardinalSortedMap; function TailMap(const FromKey: IInterface): IJclIntfCardinalSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfCardinalSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclCardinalCardinalSortedMapEntry = record - Key: Cardinal; - Value: Cardinal; + TJclIntfCardinalSortedMapIterator = class(TJclAbstractIterator, IJclIntfCardinalSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfCardinalSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfCardinalSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfCardinalSortedMapIterator } + function Add(const AEntry: TJclIntfCardinalMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfCardinalMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfCardinalMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfCardinalSortedMapIterator): Boolean; + function Next: TJclIntfCardinalMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfCardinalMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfCardinalMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfCardinalMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclCardinalCardinalSortedMapEntryArray = array of TJclCardinalCardinalSortedMapEntry; - TJclCardinalCardinalSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclCardinalContainer, IJclCardinalCardinalMap, IJclCardinalCardinalSortedMap) @@ -1551,13 +2216,13 @@ TJclCardinalCardinalSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF T function KeysCompare(A, B: Cardinal): Integer; function ValuesCompare(A, B: Cardinal): Integer; private - FEntries: TJclCardinalCardinalSortedMapEntryArray; + FEntries: TJclCardinalCardinalMapEntryArray; function BinarySearch(Key: Cardinal): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclCardinalCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclCardinalCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclCardinalCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclCardinalCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1584,15 +2249,43 @@ TJclCardinalCardinalSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF T function LastKey: Cardinal; function SubMap(FromKey, ToKey: Cardinal): IJclCardinalCardinalSortedMap; function TailMap(FromKey: Cardinal): IJclCardinalCardinalSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclCardinalCardinalSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclInt64IntfSortedMapEntry = record - Key: Int64; - Value: IInterface; + TJclCardinalCardinalSortedMapIterator = class(TJclAbstractIterator, IJclCardinalCardinalSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclCardinalCardinalSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclCardinalCardinalSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclCardinalCardinalSortedMapIterator } + function Add(const AEntry: TJclCardinalCardinalMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclCardinalCardinalMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclCardinalCardinalMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclCardinalCardinalSortedMapIterator): Boolean; + function Next: TJclCardinalCardinalMapEntry; + function NextIndex: Integer; + function Previous: TJclCardinalCardinalMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclCardinalCardinalMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclCardinalCardinalMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclInt64IntfSortedMapEntryArray = array of TJclInt64IntfSortedMapEntry; - TJclInt64IntfSortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclInt64Container, IJclIntfContainer, IJclInt64IntfMap, IJclInt64IntfSortedMap) @@ -1603,18 +2296,18 @@ TJclInt64IntfSortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} function KeysCompare(const A, B: Int64): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclInt64IntfSortedMapEntryArray; + FEntries: TJclInt64IntfMapEntryArray; function BinarySearch(const Key: Int64): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclInt64IntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclInt64IntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclInt64IntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclInt64IntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclInt64IntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclInt64IntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclInt64IntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclInt64IntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1641,15 +2334,43 @@ TJclInt64IntfSortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} function LastKey: Int64; function SubMap(const FromKey, ToKey: Int64): IJclInt64IntfSortedMap; function TailMap(const FromKey: Int64): IJclInt64IntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclInt64IntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfInt64SortedMapEntry = record - Key: IInterface; - Value: Int64; + TJclInt64IntfSortedMapIterator = class(TJclAbstractIterator, IJclInt64IntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclInt64IntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclInt64IntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclInt64IntfSortedMapIterator } + function Add(const AEntry: TJclInt64IntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclInt64IntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclInt64IntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclInt64IntfSortedMapIterator): Boolean; + function Next: TJclInt64IntfMapEntry; + function NextIndex: Integer; + function Previous: TJclInt64IntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclInt64IntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclInt64IntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfInt64SortedMapEntryArray = array of TJclIntfInt64SortedMapEntry; - TJclIntfInt64SortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntfContainer, IJclInt64Container, IJclIntfInt64Map, IJclIntfInt64SortedMap) @@ -1660,18 +2381,18 @@ TJclIntfInt64SortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(const A, B: Int64): Integer; private - FEntries: TJclIntfInt64SortedMapEntryArray; + FEntries: TJclIntfInt64MapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfInt64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfInt64SortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfInt64MapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfInt64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfInt64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1698,15 +2419,43 @@ TJclIntfInt64SortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfInt64SortedMap; function TailMap(const FromKey: IInterface): IJclIntfInt64SortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfInt64SortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclInt64Int64SortedMapEntry = record - Key: Int64; - Value: Int64; + TJclIntfInt64SortedMapIterator = class(TJclAbstractIterator, IJclIntfInt64SortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfInt64SortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfInt64SortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfInt64SortedMapIterator } + function Add(const AEntry: TJclIntfInt64MapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfInt64MapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfInt64MapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfInt64SortedMapIterator): Boolean; + function Next: TJclIntfInt64MapEntry; + function NextIndex: Integer; + function Previous: TJclIntfInt64MapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfInt64MapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfInt64MapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclInt64Int64SortedMapEntryArray = array of TJclInt64Int64SortedMapEntry; - TJclInt64Int64SortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclInt64Container, IJclInt64Int64Map, IJclInt64Int64SortedMap) @@ -1717,13 +2466,13 @@ TJclInt64Int64SortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE function KeysCompare(const A, B: Int64): Integer; function ValuesCompare(const A, B: Int64): Integer; private - FEntries: TJclInt64Int64SortedMapEntryArray; + FEntries: TJclInt64Int64MapEntryArray; function BinarySearch(const Key: Int64): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclInt64Int64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclInt64Int64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclInt64Int64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclInt64Int64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1750,15 +2499,43 @@ TJclInt64Int64SortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE function LastKey: Int64; function SubMap(const FromKey, ToKey: Int64): IJclInt64Int64SortedMap; function TailMap(const FromKey: Int64): IJclInt64Int64SortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclInt64Int64SortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclPtrIntfSortedMapEntry = record - Key: Pointer; - Value: IInterface; + TJclInt64Int64SortedMapIterator = class(TJclAbstractIterator, IJclInt64Int64SortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclInt64Int64SortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclInt64Int64SortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclInt64Int64SortedMapIterator } + function Add(const AEntry: TJclInt64Int64MapEntry): Boolean; + procedure Extract; + function GetEntry: TJclInt64Int64MapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclInt64Int64MapEntry): Boolean; + function IteratorEquals(const AIterator: IJclInt64Int64SortedMapIterator): Boolean; + function Next: TJclInt64Int64MapEntry; + function NextIndex: Integer; + function Previous: TJclInt64Int64MapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclInt64Int64MapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclInt64Int64MapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclPtrIntfSortedMapEntryArray = array of TJclPtrIntfSortedMapEntry; - TJclPtrIntfSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclPtrContainer, IJclIntfContainer, IJclPtrIntfMap, IJclPtrIntfSortedMap) @@ -1769,18 +2546,18 @@ TJclPtrIntfSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJc function KeysCompare(A, B: Pointer): Integer; function ValuesCompare(const A, B: IInterface): Integer; private - FEntries: TJclPtrIntfSortedMapEntryArray; + FEntries: TJclPtrIntfMapEntryArray; function BinarySearch(Key: Pointer): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclPtrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclPtrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclPtrIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclPtrIntfMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclPtrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclPtrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclPtrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclPtrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1807,15 +2584,43 @@ TJclPtrIntfSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJc function LastKey: Pointer; function SubMap(FromKey, ToKey: Pointer): IJclPtrIntfSortedMap; function TailMap(FromKey: Pointer): IJclPtrIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclPtrIntfSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfPtrSortedMapEntry = record - Key: IInterface; - Value: Pointer; + TJclPtrIntfSortedMapIterator = class(TJclAbstractIterator, IJclPtrIntfSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclPtrIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclPtrIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclPtrIntfSortedMapIterator } + function Add(const AEntry: TJclPtrIntfMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclPtrIntfMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclPtrIntfMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclPtrIntfSortedMapIterator): Boolean; + function Next: TJclPtrIntfMapEntry; + function NextIndex: Integer; + function Previous: TJclPtrIntfMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclPtrIntfMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclPtrIntfMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfPtrSortedMapEntryArray = array of TJclIntfPtrSortedMapEntry; - TJclIntfPtrSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntfContainer, IJclPtrContainer, IJclIntfPtrMap, IJclIntfPtrSortedMap) @@ -1826,18 +2631,18 @@ TJclIntfPtrSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJc function KeysCompare(const A, B: IInterface): Integer; function ValuesCompare(A, B: Pointer): Integer; private - FEntries: TJclIntfPtrSortedMapEntryArray; + FEntries: TJclIntfPtrMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfPtrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfPtrMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1864,15 +2669,43 @@ TJclIntfPtrSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJc function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfPtrSortedMap; function TailMap(const FromKey: IInterface): IJclIntfPtrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfPtrSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclPtrPtrSortedMapEntry = record - Key: Pointer; - Value: Pointer; + TJclIntfPtrSortedMapIterator = class(TJclAbstractIterator, IJclIntfPtrSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfPtrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfPtrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfPtrSortedMapIterator } + function Add(const AEntry: TJclIntfPtrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfPtrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfPtrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfPtrSortedMapIterator): Boolean; + function Next: TJclIntfPtrMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfPtrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfPtrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfPtrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclPtrPtrSortedMapEntryArray = array of TJclPtrPtrSortedMapEntry; - TJclPtrPtrSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclPtrContainer, IJclPtrPtrMap, IJclPtrPtrSortedMap) @@ -1883,13 +2716,13 @@ TJclPtrPtrSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJcl function KeysCompare(A, B: Pointer): Integer; function ValuesCompare(A, B: Pointer): Integer; private - FEntries: TJclPtrPtrSortedMapEntryArray; + FEntries: TJclPtrPtrMapEntryArray; function BinarySearch(Key: Pointer): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclPtrPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclPtrPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclPtrPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclPtrPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer); destructor Destroy; override; @@ -1916,15 +2749,43 @@ TJclPtrPtrSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJcl function LastKey: Pointer; function SubMap(FromKey, ToKey: Pointer): IJclPtrPtrSortedMap; function TailMap(FromKey: Pointer): IJclPtrPtrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclPtrPtrSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfSortedMapEntry = record - Key: IInterface; - Value: TObject; + TJclPtrPtrSortedMapIterator = class(TJclAbstractIterator, IJclPtrPtrSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclPtrPtrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclPtrPtrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclPtrPtrSortedMapIterator } + function Add(const AEntry: TJclPtrPtrMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclPtrPtrMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclPtrPtrMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclPtrPtrSortedMapIterator): Boolean; + function Next: TJclPtrPtrMapEntry; + function NextIndex: Integer; + function Previous: TJclPtrPtrMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclPtrPtrMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclPtrPtrMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclIntfSortedMapEntryArray = array of TJclIntfSortedMapEntry; - TJclIntfSortedMap = class(TJclIntfAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntfContainer, IJclContainer, IJclValueOwner, IJclIntfMap, IJclIntfSortedMap) @@ -1941,18 +2802,18 @@ TJclIntfSortedMap = class(TJclIntfAbstractContainer, {$IFDEF THREADSAFE} IJclL function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclIntfSortedMapEntryArray; + FEntries: TJclIntfObjMapEntryArray; function BinarySearch(const Key: IInterface): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclIntfObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclIntfSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclIntfObjMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntfObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntfObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -1979,15 +2840,43 @@ TJclIntfSortedMap = class(TJclIntfAbstractContainer, {$IFDEF THREADSAFE} IJclL function LastKey: IInterface; function SubMap(const FromKey, ToKey: IInterface): IJclIntfSortedMap; function TailMap(const FromKey: IInterface): IJclIntfSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntfObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclAnsiStrSortedMapEntry = record - Key: AnsiString; - Value: TObject; + TJclIntfObjSortedMapIterator = class(TJclAbstractIterator, IJclIntfObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntfSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntfObjSortedMapIterator } + function Add(const AEntry: TJclIntfObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntfObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntfObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntfObjSortedMapIterator): Boolean; + function Next: TJclIntfObjMapEntry; + function NextIndex: Integer; + function Previous: TJclIntfObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntfObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntfObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclAnsiStrSortedMapEntryArray = array of TJclAnsiStrSortedMapEntry; - TJclAnsiStrSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclAnsiStrContainer, IJclContainer, IJclValueOwner, IJclAnsiStrMap, IJclAnsiStrSortedMap) @@ -2004,18 +2893,18 @@ TJclAnsiStrSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADSAFE} function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclAnsiStrSortedMapEntryArray; + FEntries: TJclAnsiStrObjMapEntryArray; function BinarySearch(const Key: AnsiString): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclAnsiStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclAnsiStrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclAnsiStrObjMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclAnsiStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclAnsiStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2042,15 +2931,43 @@ TJclAnsiStrSortedMap = class(TJclAnsiStrAbstractContainer, {$IFDEF THREADSAFE} function LastKey: AnsiString; function SubMap(const FromKey, ToKey: AnsiString): IJclAnsiStrSortedMap; function TailMap(const FromKey: AnsiString): IJclAnsiStrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclAnsiStrObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclWideStrSortedMapEntry = record - Key: WideString; - Value: TObject; + TJclAnsiStrObjSortedMapIterator = class(TJclAbstractIterator, IJclAnsiStrObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclAnsiStrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclAnsiStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclAnsiStrObjSortedMapIterator } + function Add(const AEntry: TJclAnsiStrObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclAnsiStrObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclAnsiStrObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclAnsiStrObjSortedMapIterator): Boolean; + function Next: TJclAnsiStrObjMapEntry; + function NextIndex: Integer; + function Previous: TJclAnsiStrObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclAnsiStrObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclAnsiStrObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclWideStrSortedMapEntryArray = array of TJclWideStrSortedMapEntry; - TJclWideStrSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclWideStrContainer, IJclContainer, IJclValueOwner, IJclWideStrMap, IJclWideStrSortedMap) @@ -2067,18 +2984,18 @@ TJclWideStrSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADSAFE} function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclWideStrSortedMapEntryArray; + FEntries: TJclWideStrObjMapEntryArray; function BinarySearch(const Key: WideString): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclWideStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclWideStrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclWideStrObjMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclWideStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclWideStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2105,17 +3022,43 @@ TJclWideStrSortedMap = class(TJclWideStrAbstractContainer, {$IFDEF THREADSAFE} function LastKey: WideString; function SubMap(const FromKey, ToKey: WideString): IJclWideStrSortedMap; function TailMap(const FromKey: WideString): IJclWideStrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclWideStrObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - {$IFDEF SUPPORTS_UNICODE_STRING} - TJclUnicodeStrSortedMapEntry = record - Key: UnicodeString; - Value: TObject; + TJclWideStrObjSortedMapIterator = class(TJclAbstractIterator, IJclWideStrObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclWideStrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclWideStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclWideStrObjSortedMapIterator } + function Add(const AEntry: TJclWideStrObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclWideStrObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclWideStrObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclWideStrObjSortedMapIterator): Boolean; + function Next: TJclWideStrObjMapEntry; + function NextIndex: Integer; + function Previous: TJclWideStrObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclWideStrObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclWideStrObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclUnicodeStrSortedMapEntryArray = array of TJclUnicodeStrSortedMapEntry; - {$ENDIF SUPPORTS_UNICODE_STRING} - {$IFDEF SUPPORTS_UNICODE_STRING} TJclUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclStrBaseContainer, IJclUnicodeStrContainer, IJclContainer, IJclValueOwner, @@ -2133,18 +3076,18 @@ TJclUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$IFDEF THREA function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclUnicodeStrSortedMapEntryArray; + FEntries: TJclUnicodeStrObjMapEntryArray; function BinarySearch(const Key: UnicodeString): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure FinalizeArrayBeforeMove(var List: TJclUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure FinalizeArrayBeforeMove(var List: TJclUnicodeStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArray(var List: TJclUnicodeStrSortedMapEntryArray; FromIndex, Count: SizeInt); + procedure InitializeArray(var List: TJclUnicodeStrObjMapEntryArray; FromIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure InitializeArrayAfterMove(var List: TJclUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclUnicodeStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclUnicodeStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2171,36 +3114,66 @@ TJclUnicodeStrSortedMap = class(TJclUnicodeStrAbstractContainer, {$IFDEF THREA function LastKey: UnicodeString; function SubMap(const FromKey, ToKey: UnicodeString): IJclUnicodeStrSortedMap; function TailMap(const FromKey: UnicodeString): IJclUnicodeStrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclUnicodeStrObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} + end; + {$ENDIF SUPPORTS_UNICODE_STRING} + + {$IFDEF SUPPORTS_UNICODE_STRING} + TJclUnicodeStrObjSortedMapIterator = class(TJclAbstractIterator, IJclUnicodeStrObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclUnicodeStrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclUnicodeStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclUnicodeStrObjSortedMapIterator } + function Add(const AEntry: TJclUnicodeStrObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclUnicodeStrObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclUnicodeStrObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclUnicodeStrObjSortedMapIterator): Boolean; + function Next: TJclUnicodeStrObjMapEntry; + function NextIndex: Integer; + function Previous: TJclUnicodeStrObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclUnicodeStrObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclUnicodeStrObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; {$ENDIF SUPPORTS_UNICODE_STRING} {$IFDEF CONTAINER_ANSISTR} - TJclStrSortedMapEntry = TJclAnsiStrSortedMapEntry; + TJclStrSortedMap = TJclAnsiStrSortedMap; {$ENDIF CONTAINER_ANSISTR} {$IFDEF CONTAINER_WIDESTR} - TJclStrSortedMapEntry = TJclWideStrSortedMapEntry; + TJclStrSortedMap = TJclWideStrSortedMap; {$ENDIF CONTAINER_WIDESTR} {$IFDEF CONTAINER_UNICODESTR} - TJclStrSortedMapEntry = TJclUnicodeStrSortedMapEntry; + TJclStrSortedMap = TJclUnicodeStrSortedMap; {$ENDIF CONTAINER_UNICODESTR} {$IFDEF CONTAINER_ANSISTR} - TJclStrSortedMap = TJclAnsiStrSortedMap; + TJclStrObjSortedMapIterator = TJclAnsiStrObjSortedMapIterator; {$ENDIF CONTAINER_ANSISTR} {$IFDEF CONTAINER_WIDESTR} - TJclStrSortedMap = TJclWideStrSortedMap; + TJclStrObjSortedMapIterator = TJclWideStrObjSortedMapIterator; {$ENDIF CONTAINER_WIDESTR} {$IFDEF CONTAINER_UNICODESTR} - TJclStrSortedMap = TJclUnicodeStrSortedMap; + TJclStrObjSortedMapIterator = TJclUnicodeStrObjSortedMapIterator; {$ENDIF CONTAINER_UNICODESTR} - TJclSingleSortedMapEntry = record - Key: Single; - Value: TObject; - end; - - TJclSingleSortedMapEntryArray = array of TJclSingleSortedMapEntry; - TJclSingleSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclSingleContainer, IJclContainer, IJclValueOwner, IJclSingleMap, IJclSingleSortedMap) @@ -2217,13 +3190,13 @@ TJclSingleSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAFE} I function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclSingleSortedMapEntryArray; + FEntries: TJclSingleObjMapEntryArray; function BinarySearch(const Key: Single): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclSingleObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclSingleObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2250,15 +3223,43 @@ TJclSingleSortedMap = class(TJclSingleAbstractContainer, {$IFDEF THREADSAFE} I function LastKey: Single; function SubMap(const FromKey, ToKey: Single): IJclSingleSortedMap; function TailMap(const FromKey: Single): IJclSingleSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclSingleObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclDoubleSortedMapEntry = record - Key: Double; - Value: TObject; + TJclSingleObjSortedMapIterator = class(TJclAbstractIterator, IJclSingleObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclSingleSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclSingleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclSingleObjSortedMapIterator } + function Add(const AEntry: TJclSingleObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclSingleObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclSingleObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclSingleObjSortedMapIterator): Boolean; + function Next: TJclSingleObjMapEntry; + function NextIndex: Integer; + function Previous: TJclSingleObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclSingleObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclSingleObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclDoubleSortedMapEntryArray = array of TJclDoubleSortedMapEntry; - TJclDoubleSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclDoubleContainer, IJclContainer, IJclValueOwner, IJclDoubleMap, IJclDoubleSortedMap) @@ -2275,13 +3276,13 @@ TJclDoubleSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAFE} I function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclDoubleSortedMapEntryArray; + FEntries: TJclDoubleObjMapEntryArray; function BinarySearch(const Key: Double): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclDoubleObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclDoubleObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2308,15 +3309,43 @@ TJclDoubleSortedMap = class(TJclDoubleAbstractContainer, {$IFDEF THREADSAFE} I function LastKey: Double; function SubMap(const FromKey, ToKey: Double): IJclDoubleSortedMap; function TailMap(const FromKey: Double): IJclDoubleSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclDoubleObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclExtendedSortedMapEntry = record - Key: Extended; - Value: TObject; + TJclDoubleObjSortedMapIterator = class(TJclAbstractIterator, IJclDoubleObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclDoubleSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclDoubleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclDoubleObjSortedMapIterator } + function Add(const AEntry: TJclDoubleObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclDoubleObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclDoubleObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclDoubleObjSortedMapIterator): Boolean; + function Next: TJclDoubleObjMapEntry; + function NextIndex: Integer; + function Previous: TJclDoubleObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclDoubleObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclDoubleObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclExtendedSortedMapEntryArray = array of TJclExtendedSortedMapEntry; - TJclExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclExtendedContainer, IJclContainer, IJclValueOwner, IJclExtendedMap, IJclExtendedSortedMap) @@ -2333,13 +3362,13 @@ TJclExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREADSAF function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclExtendedSortedMapEntryArray; + FEntries: TJclExtendedObjMapEntryArray; function BinarySearch(const Key: Extended): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclExtendedObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclExtendedObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2366,35 +3395,63 @@ TJclExtendedSortedMap = class(TJclExtendedAbstractContainer, {$IFDEF THREADSAF function LastKey: Extended; function SubMap(const FromKey, ToKey: Extended): IJclExtendedSortedMap; function TailMap(const FromKey: Extended): IJclExtendedSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclExtendedObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} + end; + + TJclExtendedObjSortedMapIterator = class(TJclAbstractIterator, IJclExtendedObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclExtendedSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclExtendedSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclExtendedObjSortedMapIterator } + function Add(const AEntry: TJclExtendedObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclExtendedObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclExtendedObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclExtendedObjSortedMapIterator): Boolean; + function Next: TJclExtendedObjMapEntry; + function NextIndex: Integer; + function Previous: TJclExtendedObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclExtendedObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclExtendedObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; {$IFDEF MATH_SINGLE_PRECISION} - TJclFloatSortedMapEntry = TJclSingleSortedMapEntry; + TJclFloatSortedMap = TJclSingleSortedMap; {$ENDIF MATH_SINGLE_PRECISION} {$IFDEF MATH_DOUBLE_PRECISION} - TJclFloatSortedMapEntry = TJclDoubleSortedMapEntry; + TJclFloatSortedMap = TJclDoubleSortedMap; {$ENDIF MATH_DOUBLE_PRECISION} {$IFDEF MATH_EXTENDED_PRECISION} - TJclFloatSortedMapEntry = TJclExtendedSortedMapEntry; + TJclFloatSortedMap = TJclExtendedSortedMap; {$ENDIF MATH_EXTENDED_PRECISION} {$IFDEF MATH_SINGLE_PRECISION} - TJclFloatSortedMap = TJclSingleSortedMap; + TJclFloatObjSortedMapIterator = TJclSingleObjSortedMapIterator; {$ENDIF MATH_SINGLE_PRECISION} {$IFDEF MATH_DOUBLE_PRECISION} - TJclFloatSortedMap = TJclDoubleSortedMap; + TJclFloatObjSortedMapIterator = TJclDoubleObjSortedMapIterator; {$ENDIF MATH_DOUBLE_PRECISION} {$IFDEF MATH_EXTENDED_PRECISION} - TJclFloatSortedMap = TJclExtendedSortedMap; + TJclFloatObjSortedMapIterator = TJclExtendedObjSortedMapIterator; {$ENDIF MATH_EXTENDED_PRECISION} - TJclIntegerSortedMapEntry = record - Key: Integer; - Value: TObject; - end; - - TJclIntegerSortedMapEntryArray = array of TJclIntegerSortedMapEntry; - TJclIntegerSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclIntegerContainer, IJclContainer, IJclValueOwner, IJclIntegerMap, IJclIntegerSortedMap) @@ -2411,13 +3468,13 @@ TJclIntegerSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADSAFE} function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclIntegerSortedMapEntryArray; + FEntries: TJclIntegerObjMapEntryArray; function BinarySearch(Key: Integer): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclIntegerObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclIntegerObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2444,15 +3501,43 @@ TJclIntegerSortedMap = class(TJclIntegerAbstractContainer, {$IFDEF THREADSAFE} function LastKey: Integer; function SubMap(FromKey, ToKey: Integer): IJclIntegerSortedMap; function TailMap(FromKey: Integer): IJclIntegerSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclIntegerObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclCardinalSortedMapEntry = record - Key: Cardinal; - Value: TObject; + TJclIntegerObjSortedMapIterator = class(TJclAbstractIterator, IJclIntegerObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclIntegerSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclIntegerSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclIntegerObjSortedMapIterator } + function Add(const AEntry: TJclIntegerObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclIntegerObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclIntegerObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclIntegerObjSortedMapIterator): Boolean; + function Next: TJclIntegerObjMapEntry; + function NextIndex: Integer; + function Previous: TJclIntegerObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclIntegerObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclIntegerObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclCardinalSortedMapEntryArray = array of TJclCardinalSortedMapEntry; - TJclCardinalSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclCardinalContainer, IJclContainer, IJclValueOwner, IJclCardinalMap, IJclCardinalSortedMap) @@ -2469,13 +3554,13 @@ TJclCardinalSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREADSAF function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclCardinalSortedMapEntryArray; + FEntries: TJclCardinalObjMapEntryArray; function BinarySearch(Key: Cardinal): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclCardinalObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclCardinalObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2502,15 +3587,43 @@ TJclCardinalSortedMap = class(TJclCardinalAbstractContainer, {$IFDEF THREADSAF function LastKey: Cardinal; function SubMap(FromKey, ToKey: Cardinal): IJclCardinalSortedMap; function TailMap(FromKey: Cardinal): IJclCardinalSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclCardinalObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclInt64SortedMapEntry = record - Key: Int64; - Value: TObject; + TJclCardinalObjSortedMapIterator = class(TJclAbstractIterator, IJclCardinalObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclCardinalSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclCardinalSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclCardinalObjSortedMapIterator } + function Add(const AEntry: TJclCardinalObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclCardinalObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclCardinalObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclCardinalObjSortedMapIterator): Boolean; + function Next: TJclCardinalObjMapEntry; + function NextIndex: Integer; + function Previous: TJclCardinalObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclCardinalObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclCardinalObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclInt64SortedMapEntryArray = array of TJclInt64SortedMapEntry; - TJclInt64SortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclInt64Container, IJclContainer, IJclValueOwner, IJclInt64Map, IJclInt64SortedMap) @@ -2527,13 +3640,13 @@ TJclInt64SortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} IJc function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclInt64SortedMapEntryArray; + FEntries: TJclInt64ObjMapEntryArray; function BinarySearch(const Key: Int64): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclInt64ObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclInt64ObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2560,15 +3673,43 @@ TJclInt64SortedMap = class(TJclInt64AbstractContainer, {$IFDEF THREADSAFE} IJc function LastKey: Int64; function SubMap(const FromKey, ToKey: Int64): IJclInt64SortedMap; function TailMap(const FromKey: Int64): IJclInt64SortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclInt64ObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclPtrSortedMapEntry = record - Key: Pointer; - Value: TObject; + TJclInt64ObjSortedMapIterator = class(TJclAbstractIterator, IJclInt64ObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclInt64SortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclInt64SortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclInt64ObjSortedMapIterator } + function Add(const AEntry: TJclInt64ObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclInt64ObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclInt64ObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclInt64ObjSortedMapIterator): Boolean; + function Next: TJclInt64ObjMapEntry; + function NextIndex: Integer; + function Previous: TJclInt64ObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclInt64ObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclInt64ObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclPtrSortedMapEntryArray = array of TJclPtrSortedMapEntry; - TJclPtrSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclPtrContainer, IJclContainer, IJclValueOwner, IJclPtrMap, IJclPtrSortedMap) @@ -2585,13 +3726,13 @@ TJclPtrSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJclLoc function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclPtrSortedMapEntryArray; + FEntries: TJclPtrObjMapEntryArray; function BinarySearch(Key: Pointer): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclPtrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclPtrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean); destructor Destroy; override; @@ -2618,15 +3759,43 @@ TJclPtrSortedMap = class(TJclPtrAbstractContainer, {$IFDEF THREADSAFE} IJclLoc function LastKey: Pointer; function SubMap(FromKey, ToKey: Pointer): IJclPtrSortedMap; function TailMap(FromKey: Pointer): IJclPtrSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclPtrObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclSortedMapEntry = record - Key: TObject; - Value: TObject; + TJclPtrObjSortedMapIterator = class(TJclAbstractIterator, IJclPtrObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclPtrSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclPtrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclPtrObjSortedMapIterator } + function Add(const AEntry: TJclPtrObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclPtrObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclPtrObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclPtrObjSortedMapIterator): Boolean; + function Next: TJclPtrObjMapEntry; + function NextIndex: Integer; + function Previous: TJclPtrObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclPtrObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclPtrObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; - TJclSortedMapEntryArray = array of TJclSortedMapEntry; - TJclSortedMap = class(TJclAbstractContainerBase, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclContainer, IJclKeyOwner, IJclValueOwner, IJclMap, IJclSortedMap) @@ -2647,13 +3816,13 @@ TJclSortedMap = class(TJclAbstractContainerBase, {$IFDEF THREADSAFE} IJclLocka function GetOwnsValues: Boolean; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TJclSortedMapEntryArray; + FEntries: TJclObjObjMapEntryArray; function BinarySearch(Key: TObject): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure InitializeArrayAfterMove(var List: TJclSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure InitializeArrayAfterMove(var List: TJclObjObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); {$IFDEF SUPPORTS_INLINE} inline; {$ENDIF} - procedure MoveArray(var List: TJclSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TJclObjObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean; AOwnsKeys: Boolean); destructor Destroy; override; @@ -2680,25 +3849,55 @@ TJclSortedMap = class(TJclAbstractContainerBase, {$IFDEF THREADSAFE} IJclLocka function LastKey: TObject; function SubMap(FromKey, ToKey: TObject): IJclSortedMap; function TailMap(FromKey: TObject): IJclSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclObjObjSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} + end; + + TJclObjObjSortedMapIterator = class(TJclAbstractIterator, IJclObjObjSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclObjObjSortedMapIterator } + function Add(const AEntry: TJclObjObjMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclObjObjMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclObjObjMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclObjObjSortedMapIterator): Boolean; + function Next: TJclObjObjMapEntry; + function NextIndex: Integer; + function Previous: TJclObjObjMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclObjObjMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclObjObjMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; {$IFDEF SUPPORTS_GENERICS} //DOM-IGNORE-BEGIN - TJclSortedEntry = record - Key: TKey; - Value: TValue; - end; - TJclSortedMap = class(TJclAbstractContainerBase, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclGrowable, IJclPackable, IJclBaseContainer, IJclPairOwner, IJclMap, IJclSortedMap) protected type - TSortedEntry = TJclSortedEntry; - TSortedEntryArray = array of TSortedEntry; + TMapEntry = TJclMapEntry; + TMapEntryArray = array of TMapEntry; private FOwnsKeys: Boolean; FOwnsValues: Boolean; @@ -2716,11 +3915,11 @@ TJclSortedMap = class(TJclAbstractContainerBase, {$IFDEF THREADSA property OwnsKeys: Boolean read FOwnsKeys; property OwnsValues: Boolean read FOwnsValues; private - FEntries: TSortedEntryArray; + FEntries: TMapEntryArray; function BinarySearch(const Key: TKey): Integer; protected procedure AssignDataTo(Dest: TJclAbstractContainerBase); override; - procedure MoveArray(var List: TSortedEntryArray; FromIndex, ToIndex, Count: SizeInt); + procedure MoveArray(var List: TMapEntryArray; FromIndex, ToIndex, Count: SizeInt); public constructor Create(ACapacity: Integer; AOwnsValues: Boolean; AOwnsKeys: Boolean); destructor Destroy; override; @@ -2747,6 +3946,41 @@ TJclSortedMap = class(TJclAbstractContainerBase, {$IFDEF THREADSA function LastKey: TKey; function SubMap(const FromKey, ToKey: TKey): IJclSortedMap; function TailMap(const FromKey: TKey): IJclSortedMap; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: IJclSortedMapIterator; + {$ENDIF SUPPORTS_FOR_IN} + end; + + TJclSortedMapIterator = class(TJclAbstractIterator, IJclSortedMapIterator, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) + private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: TJclSortedMap; + protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; + public + constructor Create(AOwnMap: TJclSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { IJclSortedMapIterator } + function Add(const AEntry: TJclMapEntry): Boolean; + procedure Extract; + function GetEntry: TJclMapEntry; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TJclMapEntry): Boolean; + function IteratorEquals(const AIterator: IJclSortedMapIterator): Boolean; + function Next: TJclMapEntry; + function NextIndex: Integer; + function Previous: TJclMapEntry; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TJclMapEntry); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TJclMapEntry read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end; // E = external helper to compare items @@ -3049,6 +4283,13 @@ function TJclIntfIntfSortedMap.Extract(const Key: IInterface): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfIntfSortedMap.GetEnumerator: IJclIntfIntfSortedMapIterator; +begin + Result := TJclIntfIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfIntfSortedMap.GetValue(const Key: IInterface): IInterface; var Index: Integer; @@ -3223,7 +4464,7 @@ function TJclIntfIntfSortedMap.MapEquals(const AMap: IJclIntfIntfMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclIntfIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -3242,7 +4483,7 @@ procedure TJclIntfIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfIntfSo end; end; -procedure TJclIntfIntfSortedMap.InitializeArray(var List: TJclIntfIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfIntfSortedMap.InitializeArray(var List: TJclIntfIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -3256,7 +4497,7 @@ procedure TJclIntfIntfSortedMap.InitializeArray(var List: TJclIntfIntfSortedMapE {$ENDIF ~FPC} end; -procedure TJclIntfIntfSortedMap.InitializeArrayAfterMove(var List: TJclIntfIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfIntfSortedMap.InitializeArrayAfterMove(var List: TJclIntfIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -3275,7 +4516,7 @@ procedure TJclIntfIntfSortedMap.InitializeArrayAfterMove(var List: TJclIntfIntfS end; end; -procedure TJclIntfIntfSortedMap.MoveArray(var List: TJclIntfIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfIntfSortedMap.MoveArray(var List: TJclIntfIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -3520,28 +4761,182 @@ function TJclIntfIntfSortedMap.ValuesCompare(const A, B: IInterface): Integer; Result := ItemsCompare(A, B); end; -//=== { TJclAnsiStrIntfSortedMap } ============================================== +//=== { TJclIntfIntfSortedMapIterator } =============================================================== -constructor TJclAnsiStrIntfSortedMap.Create(ACapacity: Integer); +constructor TJclIntfIntfSortedMapIterator.Create(AOwnMap: TJclIntfIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclAnsiStrIntfSortedMap.Destroy; +function TJclIntfIntfSortedMapIterator.Add(const AEntry: TJclIntfIntfMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclAnsiStrIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclIntfIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclAnsiStrIntfSortedMap; - Index: Integer; + ADest: TJclIntfIntfSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclAnsiStrIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfIntfSortedMapIterator then + begin + ADest := TJclIntfIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfIntfSortedMapIterator.GetEntry: TJclIntfIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfIntfSortedMapIterator.Insert(const AEntry: TJclIntfIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfIntfSortedMapIterator.IteratorEquals(const AIterator: IJclIntfIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfIntfSortedMapIterator then + begin + ItrObj := TJclIntfIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfIntfSortedMapIterator.Next: TJclIntfIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfIntfSortedMapIterator.Previous: TJclIntfIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfIntfSortedMapIterator.SetEntry(const AEntry: TJclIntfIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclAnsiStrIntfSortedMap } ============================================== + +constructor TJclAnsiStrIntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclAnsiStrIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclAnsiStrIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclAnsiStrIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclAnsiStrIntfSortedMap then begin MyDest := TJclAnsiStrIntfSortedMap(Dest); MyDest.Clear; @@ -3711,6 +5106,13 @@ function TJclAnsiStrIntfSortedMap.Extract(const Key: AnsiString): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclAnsiStrIntfSortedMap.GetEnumerator: IJclAnsiStrIntfSortedMapIterator; +begin + Result := TJclAnsiStrIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclAnsiStrIntfSortedMap.GetValue(const Key: AnsiString): IInterface; var Index: Integer; @@ -3885,7 +5287,7 @@ function TJclAnsiStrIntfSortedMap.MapEquals(const AMap: IJclAnsiStrIntfMap): Boo {$ENDIF THREADSAFE} end; -procedure TJclAnsiStrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclAnsiStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclAnsiStrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclAnsiStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -3904,7 +5306,7 @@ procedure TJclAnsiStrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclAnsiStr end; end; -procedure TJclAnsiStrIntfSortedMap.InitializeArray(var List: TJclAnsiStrIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclAnsiStrIntfSortedMap.InitializeArray(var List: TJclAnsiStrIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -3918,7 +5320,7 @@ procedure TJclAnsiStrIntfSortedMap.InitializeArray(var List: TJclAnsiStrIntfSort {$ENDIF ~FPC} end; -procedure TJclAnsiStrIntfSortedMap.InitializeArrayAfterMove(var List: TJclAnsiStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclAnsiStrIntfSortedMap.InitializeArrayAfterMove(var List: TJclAnsiStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -3937,7 +5339,7 @@ procedure TJclAnsiStrIntfSortedMap.InitializeArrayAfterMove(var List: TJclAnsiSt end; end; -procedure TJclAnsiStrIntfSortedMap.MoveArray(var List: TJclAnsiStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclAnsiStrIntfSortedMap.MoveArray(var List: TJclAnsiStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -4182,6 +5584,160 @@ function TJclAnsiStrIntfSortedMap.ValuesCompare(const A, B: IInterface): Integer Result := IntfSimpleCompare(A, B); end; +//=== { TJclAnsiStrIntfSortedMapIterator } =============================================================== + +constructor TJclAnsiStrIntfSortedMapIterator.Create(AOwnMap: TJclAnsiStrIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclAnsiStrIntfSortedMapIterator.Add(const AEntry: TJclAnsiStrIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclAnsiStrIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclAnsiStrIntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclAnsiStrIntfSortedMapIterator then + begin + ADest := TJclAnsiStrIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclAnsiStrIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclAnsiStrIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclAnsiStrIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclAnsiStrIntfSortedMapIterator.GetEntry: TJclAnsiStrIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclAnsiStrIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclAnsiStrIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclAnsiStrIntfSortedMapIterator.Insert(const AEntry: TJclAnsiStrIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclAnsiStrIntfSortedMapIterator.IteratorEquals(const AIterator: IJclAnsiStrIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclAnsiStrIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclAnsiStrIntfSortedMapIterator then + begin + ItrObj := TJclAnsiStrIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclAnsiStrIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclAnsiStrIntfSortedMapIterator.Next: TJclAnsiStrIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclAnsiStrIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclAnsiStrIntfSortedMapIterator.Previous: TJclAnsiStrIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclAnsiStrIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclAnsiStrIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclAnsiStrIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclAnsiStrIntfSortedMapIterator.SetEntry(const AEntry: TJclAnsiStrIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntfAnsiStrSortedMap } ============================================== constructor TJclIntfAnsiStrSortedMap.Create(ACapacity: Integer); @@ -4373,6 +5929,13 @@ function TJclIntfAnsiStrSortedMap.Extract(const Key: IInterface): AnsiString; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfAnsiStrSortedMap.GetEnumerator: IJclIntfAnsiStrSortedMapIterator; +begin + Result := TJclIntfAnsiStrSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfAnsiStrSortedMap.GetValue(const Key: IInterface): AnsiString; var Index: Integer; @@ -4547,7 +6110,7 @@ function TJclIntfAnsiStrSortedMap.MapEquals(const AMap: IJclIntfAnsiStrMap): Boo {$ENDIF THREADSAFE} end; -procedure TJclIntfAnsiStrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfAnsiStrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -4566,7 +6129,7 @@ procedure TJclIntfAnsiStrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfAns end; end; -procedure TJclIntfAnsiStrSortedMap.InitializeArray(var List: TJclIntfAnsiStrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfAnsiStrSortedMap.InitializeArray(var List: TJclIntfAnsiStrMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -4580,7 +6143,7 @@ procedure TJclIntfAnsiStrSortedMap.InitializeArray(var List: TJclIntfAnsiStrSort {$ENDIF ~FPC} end; -procedure TJclIntfAnsiStrSortedMap.InitializeArrayAfterMove(var List: TJclIntfAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfAnsiStrSortedMap.InitializeArrayAfterMove(var List: TJclIntfAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -4599,7 +6162,7 @@ procedure TJclIntfAnsiStrSortedMap.InitializeArrayAfterMove(var List: TJclIntfAn end; end; -procedure TJclIntfAnsiStrSortedMap.MoveArray(var List: TJclIntfAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfAnsiStrSortedMap.MoveArray(var List: TJclIntfAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -4844,6 +6407,160 @@ function TJclIntfAnsiStrSortedMap.ValuesCompare(const A, B: AnsiString): Integer Result := ItemsCompare(A, B); end; +//=== { TJclIntfAnsiStrSortedMapIterator } =============================================================== + +constructor TJclIntfAnsiStrSortedMapIterator.Create(AOwnMap: TJclIntfAnsiStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfAnsiStrSortedMapIterator.Add(const AEntry: TJclIntfAnsiStrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfAnsiStrSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfAnsiStrSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfAnsiStrSortedMapIterator then + begin + ADest := TJclIntfAnsiStrSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfAnsiStrSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfAnsiStrSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfAnsiStrSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfAnsiStrSortedMapIterator.GetEntry: TJclIntfAnsiStrMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfAnsiStrSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfAnsiStrSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfAnsiStrSortedMapIterator.Insert(const AEntry: TJclIntfAnsiStrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfAnsiStrSortedMapIterator.IteratorEquals(const AIterator: IJclIntfAnsiStrSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfAnsiStrSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfAnsiStrSortedMapIterator then + begin + ItrObj := TJclIntfAnsiStrSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfAnsiStrSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfAnsiStrSortedMapIterator.Next: TJclIntfAnsiStrMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfAnsiStrSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfAnsiStrSortedMapIterator.Previous: TJclIntfAnsiStrMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfAnsiStrSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfAnsiStrSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfAnsiStrSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfAnsiStrSortedMapIterator.SetEntry(const AEntry: TJclIntfAnsiStrMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclAnsiStrAnsiStrSortedMap } ============================================== constructor TJclAnsiStrAnsiStrSortedMap.Create(ACapacity: Integer); @@ -5035,6 +6752,13 @@ function TJclAnsiStrAnsiStrSortedMap.Extract(const Key: AnsiString): AnsiString; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclAnsiStrAnsiStrSortedMap.GetEnumerator: IJclAnsiStrAnsiStrSortedMapIterator; +begin + Result := TJclAnsiStrAnsiStrSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclAnsiStrAnsiStrSortedMap.GetValue(const Key: AnsiString): AnsiString; var Index: Integer; @@ -5209,7 +6933,7 @@ function TJclAnsiStrAnsiStrSortedMap.MapEquals(const AMap: IJclAnsiStrAnsiStrMap {$ENDIF THREADSAFE} end; -procedure TJclAnsiStrAnsiStrSortedMap.FinalizeArrayBeforeMove(var List: TJclAnsiStrAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclAnsiStrAnsiStrSortedMap.FinalizeArrayBeforeMove(var List: TJclAnsiStrAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -5228,7 +6952,7 @@ procedure TJclAnsiStrAnsiStrSortedMap.FinalizeArrayBeforeMove(var List: TJclAnsi end; end; -procedure TJclAnsiStrAnsiStrSortedMap.InitializeArray(var List: TJclAnsiStrAnsiStrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclAnsiStrAnsiStrSortedMap.InitializeArray(var List: TJclAnsiStrAnsiStrMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -5242,7 +6966,7 @@ procedure TJclAnsiStrAnsiStrSortedMap.InitializeArray(var List: TJclAnsiStrAnsiS {$ENDIF ~FPC} end; -procedure TJclAnsiStrAnsiStrSortedMap.InitializeArrayAfterMove(var List: TJclAnsiStrAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclAnsiStrAnsiStrSortedMap.InitializeArrayAfterMove(var List: TJclAnsiStrAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -5261,7 +6985,7 @@ procedure TJclAnsiStrAnsiStrSortedMap.InitializeArrayAfterMove(var List: TJclAns end; end; -procedure TJclAnsiStrAnsiStrSortedMap.MoveArray(var List: TJclAnsiStrAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclAnsiStrAnsiStrSortedMap.MoveArray(var List: TJclAnsiStrAnsiStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -5506,47 +7230,201 @@ function TJclAnsiStrAnsiStrSortedMap.ValuesCompare(const A, B: AnsiString): Inte Result := ItemsCompare(A, B); end; -//=== { TJclWideStrIntfSortedMap } ============================================== +//=== { TJclAnsiStrAnsiStrSortedMapIterator } =============================================================== -constructor TJclWideStrIntfSortedMap.Create(ACapacity: Integer); +constructor TJclAnsiStrAnsiStrSortedMapIterator.Create(AOwnMap: TJclAnsiStrAnsiStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclWideStrIntfSortedMap.Destroy; +function TJclAnsiStrAnsiStrSortedMapIterator.Add(const AEntry: TJclAnsiStrAnsiStrMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclWideStrIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclAnsiStrAnsiStrSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclWideStrIntfSortedMap; - Index: Integer; + ADest: TJclAnsiStrAnsiStrSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclWideStrIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclAnsiStrAnsiStrSortedMapIterator then begin - MyDest := TJclWideStrIntfSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; - MyDest.FSize := FSize; + ADest := TJclAnsiStrAnsiStrSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; end; end; -function TJclWideStrIntfSortedMap.BinarySearch(const Key: WideString): Integer; -var - HiPos, LoPos, CompPos: Integer; - Comp: Integer; +function TJclAnsiStrAnsiStrSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; begin - {$IFDEF THREADSAFE} - if FThreadSafe then - SyncReaderWriter.BeginRead; - try + Result := TJclAnsiStrAnsiStrSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclAnsiStrAnsiStrSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclAnsiStrAnsiStrSortedMapIterator.GetEntry: TJclAnsiStrAnsiStrMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclAnsiStrAnsiStrSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclAnsiStrAnsiStrSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclAnsiStrAnsiStrSortedMapIterator.Insert(const AEntry: TJclAnsiStrAnsiStrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclAnsiStrAnsiStrSortedMapIterator.IteratorEquals(const AIterator: IJclAnsiStrAnsiStrSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclAnsiStrAnsiStrSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclAnsiStrAnsiStrSortedMapIterator then + begin + ItrObj := TJclAnsiStrAnsiStrSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclAnsiStrAnsiStrSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclAnsiStrAnsiStrSortedMapIterator.Next: TJclAnsiStrAnsiStrMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclAnsiStrAnsiStrSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclAnsiStrAnsiStrSortedMapIterator.Previous: TJclAnsiStrAnsiStrMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclAnsiStrAnsiStrSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclAnsiStrAnsiStrSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclAnsiStrAnsiStrSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclAnsiStrAnsiStrSortedMapIterator.SetEntry(const AEntry: TJclAnsiStrAnsiStrMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclWideStrIntfSortedMap } ============================================== + +constructor TJclWideStrIntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclWideStrIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclWideStrIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclWideStrIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclWideStrIntfSortedMap then + begin + MyDest := TJclWideStrIntfSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; + MyDest.FSize := FSize; + end; +end; + +function TJclWideStrIntfSortedMap.BinarySearch(const Key: WideString): Integer; +var + HiPos, LoPos, CompPos: Integer; + Comp: Integer; +begin + {$IFDEF THREADSAFE} + if FThreadSafe then + SyncReaderWriter.BeginRead; + try {$ENDIF THREADSAFE} LoPos := 0; HiPos := FSize - 1; @@ -5697,6 +7575,13 @@ function TJclWideStrIntfSortedMap.Extract(const Key: WideString): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclWideStrIntfSortedMap.GetEnumerator: IJclWideStrIntfSortedMapIterator; +begin + Result := TJclWideStrIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclWideStrIntfSortedMap.GetValue(const Key: WideString): IInterface; var Index: Integer; @@ -5871,7 +7756,7 @@ function TJclWideStrIntfSortedMap.MapEquals(const AMap: IJclWideStrIntfMap): Boo {$ENDIF THREADSAFE} end; -procedure TJclWideStrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclWideStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclWideStrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclWideStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -5890,7 +7775,7 @@ procedure TJclWideStrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclWideStr end; end; -procedure TJclWideStrIntfSortedMap.InitializeArray(var List: TJclWideStrIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclWideStrIntfSortedMap.InitializeArray(var List: TJclWideStrIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -5904,7 +7789,7 @@ procedure TJclWideStrIntfSortedMap.InitializeArray(var List: TJclWideStrIntfSort {$ENDIF ~FPC} end; -procedure TJclWideStrIntfSortedMap.InitializeArrayAfterMove(var List: TJclWideStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclWideStrIntfSortedMap.InitializeArrayAfterMove(var List: TJclWideStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -5923,7 +7808,7 @@ procedure TJclWideStrIntfSortedMap.InitializeArrayAfterMove(var List: TJclWideSt end; end; -procedure TJclWideStrIntfSortedMap.MoveArray(var List: TJclWideStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclWideStrIntfSortedMap.MoveArray(var List: TJclWideStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -6168,6 +8053,160 @@ function TJclWideStrIntfSortedMap.ValuesCompare(const A, B: IInterface): Integer Result := IntfSimpleCompare(A, B); end; +//=== { TJclWideStrIntfSortedMapIterator } =============================================================== + +constructor TJclWideStrIntfSortedMapIterator.Create(AOwnMap: TJclWideStrIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclWideStrIntfSortedMapIterator.Add(const AEntry: TJclWideStrIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclWideStrIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclWideStrIntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclWideStrIntfSortedMapIterator then + begin + ADest := TJclWideStrIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclWideStrIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclWideStrIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclWideStrIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclWideStrIntfSortedMapIterator.GetEntry: TJclWideStrIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclWideStrIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclWideStrIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclWideStrIntfSortedMapIterator.Insert(const AEntry: TJclWideStrIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclWideStrIntfSortedMapIterator.IteratorEquals(const AIterator: IJclWideStrIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclWideStrIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclWideStrIntfSortedMapIterator then + begin + ItrObj := TJclWideStrIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclWideStrIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclWideStrIntfSortedMapIterator.Next: TJclWideStrIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclWideStrIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclWideStrIntfSortedMapIterator.Previous: TJclWideStrIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclWideStrIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclWideStrIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclWideStrIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclWideStrIntfSortedMapIterator.SetEntry(const AEntry: TJclWideStrIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntfWideStrSortedMap } ============================================== constructor TJclIntfWideStrSortedMap.Create(ACapacity: Integer); @@ -6359,6 +8398,13 @@ function TJclIntfWideStrSortedMap.Extract(const Key: IInterface): WideString; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfWideStrSortedMap.GetEnumerator: IJclIntfWideStrSortedMapIterator; +begin + Result := TJclIntfWideStrSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfWideStrSortedMap.GetValue(const Key: IInterface): WideString; var Index: Integer; @@ -6533,7 +8579,7 @@ function TJclIntfWideStrSortedMap.MapEquals(const AMap: IJclIntfWideStrMap): Boo {$ENDIF THREADSAFE} end; -procedure TJclIntfWideStrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfWideStrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -6552,7 +8598,7 @@ procedure TJclIntfWideStrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfWid end; end; -procedure TJclIntfWideStrSortedMap.InitializeArray(var List: TJclIntfWideStrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfWideStrSortedMap.InitializeArray(var List: TJclIntfWideStrMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -6566,7 +8612,7 @@ procedure TJclIntfWideStrSortedMap.InitializeArray(var List: TJclIntfWideStrSort {$ENDIF ~FPC} end; -procedure TJclIntfWideStrSortedMap.InitializeArrayAfterMove(var List: TJclIntfWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfWideStrSortedMap.InitializeArrayAfterMove(var List: TJclIntfWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -6585,7 +8631,7 @@ procedure TJclIntfWideStrSortedMap.InitializeArrayAfterMove(var List: TJclIntfWi end; end; -procedure TJclIntfWideStrSortedMap.MoveArray(var List: TJclIntfWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfWideStrSortedMap.MoveArray(var List: TJclIntfWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -6830,6 +8876,160 @@ function TJclIntfWideStrSortedMap.ValuesCompare(const A, B: WideString): Integer Result := ItemsCompare(A, B); end; +//=== { TJclIntfWideStrSortedMapIterator } =============================================================== + +constructor TJclIntfWideStrSortedMapIterator.Create(AOwnMap: TJclIntfWideStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfWideStrSortedMapIterator.Add(const AEntry: TJclIntfWideStrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfWideStrSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfWideStrSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfWideStrSortedMapIterator then + begin + ADest := TJclIntfWideStrSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfWideStrSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfWideStrSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfWideStrSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfWideStrSortedMapIterator.GetEntry: TJclIntfWideStrMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfWideStrSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfWideStrSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfWideStrSortedMapIterator.Insert(const AEntry: TJclIntfWideStrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfWideStrSortedMapIterator.IteratorEquals(const AIterator: IJclIntfWideStrSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfWideStrSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfWideStrSortedMapIterator then + begin + ItrObj := TJclIntfWideStrSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfWideStrSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfWideStrSortedMapIterator.Next: TJclIntfWideStrMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfWideStrSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfWideStrSortedMapIterator.Previous: TJclIntfWideStrMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfWideStrSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfWideStrSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfWideStrSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfWideStrSortedMapIterator.SetEntry(const AEntry: TJclIntfWideStrMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclWideStrWideStrSortedMap } ============================================== constructor TJclWideStrWideStrSortedMap.Create(ACapacity: Integer); @@ -7021,6 +9221,13 @@ function TJclWideStrWideStrSortedMap.Extract(const Key: WideString): WideString; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclWideStrWideStrSortedMap.GetEnumerator: IJclWideStrWideStrSortedMapIterator; +begin + Result := TJclWideStrWideStrSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclWideStrWideStrSortedMap.GetValue(const Key: WideString): WideString; var Index: Integer; @@ -7195,7 +9402,7 @@ function TJclWideStrWideStrSortedMap.MapEquals(const AMap: IJclWideStrWideStrMap {$ENDIF THREADSAFE} end; -procedure TJclWideStrWideStrSortedMap.FinalizeArrayBeforeMove(var List: TJclWideStrWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclWideStrWideStrSortedMap.FinalizeArrayBeforeMove(var List: TJclWideStrWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -7214,7 +9421,7 @@ procedure TJclWideStrWideStrSortedMap.FinalizeArrayBeforeMove(var List: TJclWide end; end; -procedure TJclWideStrWideStrSortedMap.InitializeArray(var List: TJclWideStrWideStrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclWideStrWideStrSortedMap.InitializeArray(var List: TJclWideStrWideStrMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -7228,7 +9435,7 @@ procedure TJclWideStrWideStrSortedMap.InitializeArray(var List: TJclWideStrWideS {$ENDIF ~FPC} end; -procedure TJclWideStrWideStrSortedMap.InitializeArrayAfterMove(var List: TJclWideStrWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclWideStrWideStrSortedMap.InitializeArrayAfterMove(var List: TJclWideStrWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -7247,7 +9454,7 @@ procedure TJclWideStrWideStrSortedMap.InitializeArrayAfterMove(var List: TJclWid end; end; -procedure TJclWideStrWideStrSortedMap.MoveArray(var List: TJclWideStrWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclWideStrWideStrSortedMap.MoveArray(var List: TJclWideStrWideStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -7492,29 +9699,183 @@ function TJclWideStrWideStrSortedMap.ValuesCompare(const A, B: WideString): Inte Result := ItemsCompare(A, B); end; -{$IFDEF SUPPORTS_UNICODE_STRING} -//=== { TJclUnicodeStrIntfSortedMap } ============================================== +//=== { TJclWideStrWideStrSortedMapIterator } =============================================================== -constructor TJclUnicodeStrIntfSortedMap.Create(ACapacity: Integer); +constructor TJclWideStrWideStrSortedMapIterator.Create(AOwnMap: TJclWideStrWideStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclUnicodeStrIntfSortedMap.Destroy; +function TJclWideStrWideStrSortedMapIterator.Add(const AEntry: TJclWideStrWideStrMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclUnicodeStrIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclWideStrWideStrSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclUnicodeStrIntfSortedMap; - Index: Integer; + ADest: TJclWideStrWideStrSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclUnicodeStrIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclWideStrWideStrSortedMapIterator then + begin + ADest := TJclWideStrWideStrSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclWideStrWideStrSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclWideStrWideStrSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclWideStrWideStrSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclWideStrWideStrSortedMapIterator.GetEntry: TJclWideStrWideStrMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclWideStrWideStrSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclWideStrWideStrSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclWideStrWideStrSortedMapIterator.Insert(const AEntry: TJclWideStrWideStrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclWideStrWideStrSortedMapIterator.IteratorEquals(const AIterator: IJclWideStrWideStrSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclWideStrWideStrSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclWideStrWideStrSortedMapIterator then + begin + ItrObj := TJclWideStrWideStrSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclWideStrWideStrSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclWideStrWideStrSortedMapIterator.Next: TJclWideStrWideStrMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclWideStrWideStrSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclWideStrWideStrSortedMapIterator.Previous: TJclWideStrWideStrMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclWideStrWideStrSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclWideStrWideStrSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclWideStrWideStrSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclWideStrWideStrSortedMapIterator.SetEntry(const AEntry: TJclWideStrWideStrMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +{$IFDEF SUPPORTS_UNICODE_STRING} +//=== { TJclUnicodeStrIntfSortedMap } ============================================== + +constructor TJclUnicodeStrIntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclUnicodeStrIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclUnicodeStrIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclUnicodeStrIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclUnicodeStrIntfSortedMap then begin MyDest := TJclUnicodeStrIntfSortedMap(Dest); MyDest.Clear; @@ -7684,6 +10045,13 @@ function TJclUnicodeStrIntfSortedMap.Extract(const Key: UnicodeString): IInterfa {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclUnicodeStrIntfSortedMap.GetEnumerator: IJclUnicodeStrIntfSortedMapIterator; +begin + Result := TJclUnicodeStrIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclUnicodeStrIntfSortedMap.GetValue(const Key: UnicodeString): IInterface; var Index: Integer; @@ -7858,7 +10226,7 @@ function TJclUnicodeStrIntfSortedMap.MapEquals(const AMap: IJclUnicodeStrIntfMap {$ENDIF THREADSAFE} end; -procedure TJclUnicodeStrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclUnicodeStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclUnicodeStrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclUnicodeStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -7877,7 +10245,7 @@ procedure TJclUnicodeStrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclUnic end; end; -procedure TJclUnicodeStrIntfSortedMap.InitializeArray(var List: TJclUnicodeStrIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclUnicodeStrIntfSortedMap.InitializeArray(var List: TJclUnicodeStrIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -7891,7 +10259,7 @@ procedure TJclUnicodeStrIntfSortedMap.InitializeArray(var List: TJclUnicodeStrIn {$ENDIF ~FPC} end; -procedure TJclUnicodeStrIntfSortedMap.InitializeArrayAfterMove(var List: TJclUnicodeStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclUnicodeStrIntfSortedMap.InitializeArrayAfterMove(var List: TJclUnicodeStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -7910,7 +10278,7 @@ procedure TJclUnicodeStrIntfSortedMap.InitializeArrayAfterMove(var List: TJclUni end; end; -procedure TJclUnicodeStrIntfSortedMap.MoveArray(var List: TJclUnicodeStrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclUnicodeStrIntfSortedMap.MoveArray(var List: TJclUnicodeStrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -8157,6 +10525,162 @@ function TJclUnicodeStrIntfSortedMap.ValuesCompare(const A, B: IInterface): Inte {$ENDIF SUPPORTS_UNICODE_STRING} +{$IFDEF SUPPORTS_UNICODE_STRING} +//=== { TJclUnicodeStrIntfSortedMapIterator } =============================================================== + +constructor TJclUnicodeStrIntfSortedMapIterator.Create(AOwnMap: TJclUnicodeStrIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclUnicodeStrIntfSortedMapIterator.Add(const AEntry: TJclUnicodeStrIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclUnicodeStrIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclUnicodeStrIntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclUnicodeStrIntfSortedMapIterator then + begin + ADest := TJclUnicodeStrIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclUnicodeStrIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclUnicodeStrIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclUnicodeStrIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclUnicodeStrIntfSortedMapIterator.GetEntry: TJclUnicodeStrIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclUnicodeStrIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclUnicodeStrIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclUnicodeStrIntfSortedMapIterator.Insert(const AEntry: TJclUnicodeStrIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclUnicodeStrIntfSortedMapIterator.IteratorEquals(const AIterator: IJclUnicodeStrIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclUnicodeStrIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclUnicodeStrIntfSortedMapIterator then + begin + ItrObj := TJclUnicodeStrIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclUnicodeStrIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclUnicodeStrIntfSortedMapIterator.Next: TJclUnicodeStrIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclUnicodeStrIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclUnicodeStrIntfSortedMapIterator.Previous: TJclUnicodeStrIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclUnicodeStrIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclUnicodeStrIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclUnicodeStrIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclUnicodeStrIntfSortedMapIterator.SetEntry(const AEntry: TJclUnicodeStrIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +{$ENDIF SUPPORTS_UNICODE_STRING} {$IFDEF SUPPORTS_UNICODE_STRING} //=== { TJclIntfUnicodeStrSortedMap } ============================================== @@ -8349,6 +10873,13 @@ function TJclIntfUnicodeStrSortedMap.Extract(const Key: IInterface): UnicodeStri {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfUnicodeStrSortedMap.GetEnumerator: IJclIntfUnicodeStrSortedMapIterator; +begin + Result := TJclIntfUnicodeStrSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfUnicodeStrSortedMap.GetValue(const Key: IInterface): UnicodeString; var Index: Integer; @@ -8523,7 +11054,7 @@ function TJclIntfUnicodeStrSortedMap.MapEquals(const AMap: IJclIntfUnicodeStrMap {$ENDIF THREADSAFE} end; -procedure TJclIntfUnicodeStrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfUnicodeStrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -8542,7 +11073,7 @@ procedure TJclIntfUnicodeStrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntf end; end; -procedure TJclIntfUnicodeStrSortedMap.InitializeArray(var List: TJclIntfUnicodeStrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfUnicodeStrSortedMap.InitializeArray(var List: TJclIntfUnicodeStrMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -8556,7 +11087,7 @@ procedure TJclIntfUnicodeStrSortedMap.InitializeArray(var List: TJclIntfUnicodeS {$ENDIF ~FPC} end; -procedure TJclIntfUnicodeStrSortedMap.InitializeArrayAfterMove(var List: TJclIntfUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfUnicodeStrSortedMap.InitializeArrayAfterMove(var List: TJclIntfUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -8575,7 +11106,7 @@ procedure TJclIntfUnicodeStrSortedMap.InitializeArrayAfterMove(var List: TJclInt end; end; -procedure TJclIntfUnicodeStrSortedMap.MoveArray(var List: TJclIntfUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfUnicodeStrSortedMap.MoveArray(var List: TJclIntfUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -8822,6 +11353,162 @@ function TJclIntfUnicodeStrSortedMap.ValuesCompare(const A, B: UnicodeString): I {$ENDIF SUPPORTS_UNICODE_STRING} +{$IFDEF SUPPORTS_UNICODE_STRING} +//=== { TJclIntfUnicodeStrSortedMapIterator } =============================================================== + +constructor TJclIntfUnicodeStrSortedMapIterator.Create(AOwnMap: TJclIntfUnicodeStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfUnicodeStrSortedMapIterator.Add(const AEntry: TJclIntfUnicodeStrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfUnicodeStrSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfUnicodeStrSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfUnicodeStrSortedMapIterator then + begin + ADest := TJclIntfUnicodeStrSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfUnicodeStrSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfUnicodeStrSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfUnicodeStrSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfUnicodeStrSortedMapIterator.GetEntry: TJclIntfUnicodeStrMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfUnicodeStrSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfUnicodeStrSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfUnicodeStrSortedMapIterator.Insert(const AEntry: TJclIntfUnicodeStrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfUnicodeStrSortedMapIterator.IteratorEquals(const AIterator: IJclIntfUnicodeStrSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfUnicodeStrSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfUnicodeStrSortedMapIterator then + begin + ItrObj := TJclIntfUnicodeStrSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfUnicodeStrSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfUnicodeStrSortedMapIterator.Next: TJclIntfUnicodeStrMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfUnicodeStrSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfUnicodeStrSortedMapIterator.Previous: TJclIntfUnicodeStrMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfUnicodeStrSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfUnicodeStrSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfUnicodeStrSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfUnicodeStrSortedMapIterator.SetEntry(const AEntry: TJclIntfUnicodeStrMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +{$ENDIF SUPPORTS_UNICODE_STRING} {$IFDEF SUPPORTS_UNICODE_STRING} //=== { TJclUnicodeStrUnicodeStrSortedMap } ============================================== @@ -9014,6 +11701,13 @@ function TJclUnicodeStrUnicodeStrSortedMap.Extract(const Key: UnicodeString): Un {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclUnicodeStrUnicodeStrSortedMap.GetEnumerator: IJclUnicodeStrUnicodeStrSortedMapIterator; +begin + Result := TJclUnicodeStrUnicodeStrSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclUnicodeStrUnicodeStrSortedMap.GetValue(const Key: UnicodeString): UnicodeString; var Index: Integer; @@ -9188,7 +11882,7 @@ function TJclUnicodeStrUnicodeStrSortedMap.MapEquals(const AMap: IJclUnicodeStrU {$ENDIF THREADSAFE} end; -procedure TJclUnicodeStrUnicodeStrSortedMap.FinalizeArrayBeforeMove(var List: TJclUnicodeStrUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclUnicodeStrUnicodeStrSortedMap.FinalizeArrayBeforeMove(var List: TJclUnicodeStrUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -9207,7 +11901,7 @@ procedure TJclUnicodeStrUnicodeStrSortedMap.FinalizeArrayBeforeMove(var List: TJ end; end; -procedure TJclUnicodeStrUnicodeStrSortedMap.InitializeArray(var List: TJclUnicodeStrUnicodeStrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclUnicodeStrUnicodeStrSortedMap.InitializeArray(var List: TJclUnicodeStrUnicodeStrMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -9221,7 +11915,7 @@ procedure TJclUnicodeStrUnicodeStrSortedMap.InitializeArray(var List: TJclUnicod {$ENDIF ~FPC} end; -procedure TJclUnicodeStrUnicodeStrSortedMap.InitializeArrayAfterMove(var List: TJclUnicodeStrUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclUnicodeStrUnicodeStrSortedMap.InitializeArrayAfterMove(var List: TJclUnicodeStrUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -9240,7 +11934,7 @@ procedure TJclUnicodeStrUnicodeStrSortedMap.InitializeArrayAfterMove(var List: T end; end; -procedure TJclUnicodeStrUnicodeStrSortedMap.MoveArray(var List: TJclUnicodeStrUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclUnicodeStrUnicodeStrSortedMap.MoveArray(var List: TJclUnicodeStrUnicodeStrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -9487,39 +12181,195 @@ function TJclUnicodeStrUnicodeStrSortedMap.ValuesCompare(const A, B: UnicodeStri {$ENDIF SUPPORTS_UNICODE_STRING} -//=== { TJclSingleIntfSortedMap } ============================================== +{$IFDEF SUPPORTS_UNICODE_STRING} +//=== { TJclUnicodeStrUnicodeStrSortedMapIterator } =============================================================== -constructor TJclSingleIntfSortedMap.Create(ACapacity: Integer); +constructor TJclUnicodeStrUnicodeStrSortedMapIterator.Create(AOwnMap: TJclUnicodeStrUnicodeStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclSingleIntfSortedMap.Destroy; +function TJclUnicodeStrUnicodeStrSortedMapIterator.Add(const AEntry: TJclUnicodeStrUnicodeStrMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclSingleIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclUnicodeStrUnicodeStrSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclSingleIntfSortedMap; - Index: Integer; + ADest: TJclUnicodeStrUnicodeStrSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclSingleIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclUnicodeStrUnicodeStrSortedMapIterator then begin - MyDest := TJclSingleIntfSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; - MyDest.FSize := FSize; + ADest := TJclUnicodeStrUnicodeStrSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; end; end; -function TJclSingleIntfSortedMap.BinarySearch(const Key: Single): Integer; +function TJclUnicodeStrUnicodeStrSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclUnicodeStrUnicodeStrSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclUnicodeStrUnicodeStrSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclUnicodeStrUnicodeStrSortedMapIterator.GetEntry: TJclUnicodeStrUnicodeStrMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclUnicodeStrUnicodeStrSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclUnicodeStrUnicodeStrSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclUnicodeStrUnicodeStrSortedMapIterator.Insert(const AEntry: TJclUnicodeStrUnicodeStrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclUnicodeStrUnicodeStrSortedMapIterator.IteratorEquals(const AIterator: IJclUnicodeStrUnicodeStrSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclUnicodeStrUnicodeStrSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclUnicodeStrUnicodeStrSortedMapIterator then + begin + ItrObj := TJclUnicodeStrUnicodeStrSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclUnicodeStrUnicodeStrSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclUnicodeStrUnicodeStrSortedMapIterator.Next: TJclUnicodeStrUnicodeStrMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclUnicodeStrUnicodeStrSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclUnicodeStrUnicodeStrSortedMapIterator.Previous: TJclUnicodeStrUnicodeStrMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclUnicodeStrUnicodeStrSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclUnicodeStrUnicodeStrSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclUnicodeStrUnicodeStrSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclUnicodeStrUnicodeStrSortedMapIterator.SetEntry(const AEntry: TJclUnicodeStrUnicodeStrMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +{$ENDIF SUPPORTS_UNICODE_STRING} +//=== { TJclSingleIntfSortedMap } ============================================== + +constructor TJclSingleIntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclSingleIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclSingleIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclSingleIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclSingleIntfSortedMap then + begin + MyDest := TJclSingleIntfSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; + MyDest.FSize := FSize; + end; +end; + +function TJclSingleIntfSortedMap.BinarySearch(const Key: Single): Integer; var HiPos, LoPos, CompPos: Integer; Comp: Integer; @@ -9678,6 +12528,13 @@ function TJclSingleIntfSortedMap.Extract(const Key: Single): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclSingleIntfSortedMap.GetEnumerator: IJclSingleIntfSortedMapIterator; +begin + Result := TJclSingleIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclSingleIntfSortedMap.GetValue(const Key: Single): IInterface; var Index: Integer; @@ -9852,7 +12709,7 @@ function TJclSingleIntfSortedMap.MapEquals(const AMap: IJclSingleIntfMap): Boole {$ENDIF THREADSAFE} end; -procedure TJclSingleIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclSingleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSingleIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclSingleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -9871,7 +12728,7 @@ procedure TJclSingleIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclSingleIn end; end; -procedure TJclSingleIntfSortedMap.InitializeArray(var List: TJclSingleIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclSingleIntfSortedMap.InitializeArray(var List: TJclSingleIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -9885,7 +12742,7 @@ procedure TJclSingleIntfSortedMap.InitializeArray(var List: TJclSingleIntfSorted {$ENDIF ~FPC} end; -procedure TJclSingleIntfSortedMap.InitializeArrayAfterMove(var List: TJclSingleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSingleIntfSortedMap.InitializeArrayAfterMove(var List: TJclSingleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -9904,7 +12761,7 @@ procedure TJclSingleIntfSortedMap.InitializeArrayAfterMove(var List: TJclSingleI end; end; -procedure TJclSingleIntfSortedMap.MoveArray(var List: TJclSingleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSingleIntfSortedMap.MoveArray(var List: TJclSingleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -10149,6 +13006,160 @@ function TJclSingleIntfSortedMap.ValuesCompare(const A, B: IInterface): Integer; Result := IntfSimpleCompare(A, B); end; +//=== { TJclSingleIntfSortedMapIterator } =============================================================== + +constructor TJclSingleIntfSortedMapIterator.Create(AOwnMap: TJclSingleIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclSingleIntfSortedMapIterator.Add(const AEntry: TJclSingleIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclSingleIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclSingleIntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclSingleIntfSortedMapIterator then + begin + ADest := TJclSingleIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclSingleIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclSingleIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclSingleIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclSingleIntfSortedMapIterator.GetEntry: TJclSingleIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSingleIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclSingleIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclSingleIntfSortedMapIterator.Insert(const AEntry: TJclSingleIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclSingleIntfSortedMapIterator.IteratorEquals(const AIterator: IJclSingleIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclSingleIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclSingleIntfSortedMapIterator then + begin + ItrObj := TJclSingleIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclSingleIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclSingleIntfSortedMapIterator.Next: TJclSingleIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSingleIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclSingleIntfSortedMapIterator.Previous: TJclSingleIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSingleIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclSingleIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclSingleIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclSingleIntfSortedMapIterator.SetEntry(const AEntry: TJclSingleIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntfSingleSortedMap } ============================================== constructor TJclIntfSingleSortedMap.Create(ACapacity: Integer); @@ -10340,6 +13351,13 @@ function TJclIntfSingleSortedMap.Extract(const Key: IInterface): Single; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfSingleSortedMap.GetEnumerator: IJclIntfSingleSortedMapIterator; +begin + Result := TJclIntfSingleSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfSingleSortedMap.GetValue(const Key: IInterface): Single; var Index: Integer; @@ -10514,7 +13532,7 @@ function TJclIntfSingleSortedMap.MapEquals(const AMap: IJclIntfSingleMap): Boole {$ENDIF THREADSAFE} end; -procedure TJclIntfSingleSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfSingleSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -10533,7 +13551,7 @@ procedure TJclIntfSingleSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfSing end; end; -procedure TJclIntfSingleSortedMap.InitializeArray(var List: TJclIntfSingleSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfSingleSortedMap.InitializeArray(var List: TJclIntfSingleMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -10547,7 +13565,7 @@ procedure TJclIntfSingleSortedMap.InitializeArray(var List: TJclIntfSingleSorted {$ENDIF ~FPC} end; -procedure TJclIntfSingleSortedMap.InitializeArrayAfterMove(var List: TJclIntfSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfSingleSortedMap.InitializeArrayAfterMove(var List: TJclIntfSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -10566,7 +13584,7 @@ procedure TJclIntfSingleSortedMap.InitializeArrayAfterMove(var List: TJclIntfSin end; end; -procedure TJclIntfSingleSortedMap.MoveArray(var List: TJclIntfSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfSingleSortedMap.MoveArray(var List: TJclIntfSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -10811,6 +13829,160 @@ function TJclIntfSingleSortedMap.ValuesCompare(const A, B: Single): Integer; Result := ItemsCompare(A, B); end; +//=== { TJclIntfSingleSortedMapIterator } =============================================================== + +constructor TJclIntfSingleSortedMapIterator.Create(AOwnMap: TJclIntfSingleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfSingleSortedMapIterator.Add(const AEntry: TJclIntfSingleMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfSingleSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfSingleSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfSingleSortedMapIterator then + begin + ADest := TJclIntfSingleSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfSingleSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfSingleSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfSingleSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfSingleSortedMapIterator.GetEntry: TJclIntfSingleMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfSingleSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfSingleSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfSingleSortedMapIterator.Insert(const AEntry: TJclIntfSingleMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfSingleSortedMapIterator.IteratorEquals(const AIterator: IJclIntfSingleSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfSingleSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfSingleSortedMapIterator then + begin + ItrObj := TJclIntfSingleSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfSingleSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfSingleSortedMapIterator.Next: TJclIntfSingleMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfSingleSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfSingleSortedMapIterator.Previous: TJclIntfSingleMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfSingleSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfSingleSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfSingleSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfSingleSortedMapIterator.SetEntry(const AEntry: TJclIntfSingleMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclSingleSingleSortedMap } ============================================== constructor TJclSingleSingleSortedMap.Create(ACapacity: Integer); @@ -11002,6 +14174,13 @@ function TJclSingleSingleSortedMap.Extract(const Key: Single): Single; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclSingleSingleSortedMap.GetEnumerator: IJclSingleSingleSortedMapIterator; +begin + Result := TJclSingleSingleSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclSingleSingleSortedMap.GetValue(const Key: Single): Single; var Index: Integer; @@ -11176,7 +14355,7 @@ function TJclSingleSingleSortedMap.MapEquals(const AMap: IJclSingleSingleMap): B {$ENDIF THREADSAFE} end; -procedure TJclSingleSingleSortedMap.InitializeArrayAfterMove(var List: TJclSingleSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSingleSingleSortedMap.InitializeArrayAfterMove(var List: TJclSingleSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -11195,7 +14374,7 @@ procedure TJclSingleSingleSortedMap.InitializeArrayAfterMove(var List: TJclSingl end; end; -procedure TJclSingleSingleSortedMap.MoveArray(var List: TJclSingleSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSingleSingleSortedMap.MoveArray(var List: TJclSingleSingleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -11439,35 +14618,189 @@ function TJclSingleSingleSortedMap.ValuesCompare(const A, B: Single): Integer; Result := ItemsCompare(A, B); end; -//=== { TJclDoubleIntfSortedMap } ============================================== +//=== { TJclSingleSingleSortedMapIterator } =============================================================== -constructor TJclDoubleIntfSortedMap.Create(ACapacity: Integer); +constructor TJclSingleSingleSortedMapIterator.Create(AOwnMap: TJclSingleSingleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclDoubleIntfSortedMap.Destroy; +function TJclSingleSingleSortedMapIterator.Add(const AEntry: TJclSingleSingleMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclDoubleIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclSingleSingleSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclDoubleIntfSortedMap; - Index: Integer; + ADest: TJclSingleSingleSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclDoubleIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclSingleSingleSortedMapIterator then begin - MyDest := TJclDoubleIntfSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; - MyDest.FSize := FSize; + ADest := TJclSingleSingleSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclSingleSingleSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclSingleSingleSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclSingleSingleSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclSingleSingleSortedMapIterator.GetEntry: TJclSingleSingleMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSingleSingleSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclSingleSingleSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclSingleSingleSortedMapIterator.Insert(const AEntry: TJclSingleSingleMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclSingleSingleSortedMapIterator.IteratorEquals(const AIterator: IJclSingleSingleSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclSingleSingleSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclSingleSingleSortedMapIterator then + begin + ItrObj := TJclSingleSingleSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclSingleSingleSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclSingleSingleSortedMapIterator.Next: TJclSingleSingleMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSingleSingleSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclSingleSingleSortedMapIterator.Previous: TJclSingleSingleMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSingleSingleSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclSingleSingleSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclSingleSingleSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclSingleSingleSortedMapIterator.SetEntry(const AEntry: TJclSingleSingleMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclDoubleIntfSortedMap } ============================================== + +constructor TJclDoubleIntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclDoubleIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclDoubleIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclDoubleIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclDoubleIntfSortedMap then + begin + MyDest := TJclDoubleIntfSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; + MyDest.FSize := FSize; end; end; @@ -11630,6 +14963,13 @@ function TJclDoubleIntfSortedMap.Extract(const Key: Double): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclDoubleIntfSortedMap.GetEnumerator: IJclDoubleIntfSortedMapIterator; +begin + Result := TJclDoubleIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclDoubleIntfSortedMap.GetValue(const Key: Double): IInterface; var Index: Integer; @@ -11804,7 +15144,7 @@ function TJclDoubleIntfSortedMap.MapEquals(const AMap: IJclDoubleIntfMap): Boole {$ENDIF THREADSAFE} end; -procedure TJclDoubleIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclDoubleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclDoubleIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclDoubleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -11823,7 +15163,7 @@ procedure TJclDoubleIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclDoubleIn end; end; -procedure TJclDoubleIntfSortedMap.InitializeArray(var List: TJclDoubleIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclDoubleIntfSortedMap.InitializeArray(var List: TJclDoubleIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -11837,7 +15177,7 @@ procedure TJclDoubleIntfSortedMap.InitializeArray(var List: TJclDoubleIntfSorted {$ENDIF ~FPC} end; -procedure TJclDoubleIntfSortedMap.InitializeArrayAfterMove(var List: TJclDoubleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclDoubleIntfSortedMap.InitializeArrayAfterMove(var List: TJclDoubleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -11856,7 +15196,7 @@ procedure TJclDoubleIntfSortedMap.InitializeArrayAfterMove(var List: TJclDoubleI end; end; -procedure TJclDoubleIntfSortedMap.MoveArray(var List: TJclDoubleIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclDoubleIntfSortedMap.MoveArray(var List: TJclDoubleIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -12101,6 +15441,160 @@ function TJclDoubleIntfSortedMap.ValuesCompare(const A, B: IInterface): Integer; Result := IntfSimpleCompare(A, B); end; +//=== { TJclDoubleIntfSortedMapIterator } =============================================================== + +constructor TJclDoubleIntfSortedMapIterator.Create(AOwnMap: TJclDoubleIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclDoubleIntfSortedMapIterator.Add(const AEntry: TJclDoubleIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclDoubleIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclDoubleIntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclDoubleIntfSortedMapIterator then + begin + ADest := TJclDoubleIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclDoubleIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclDoubleIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclDoubleIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclDoubleIntfSortedMapIterator.GetEntry: TJclDoubleIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclDoubleIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclDoubleIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclDoubleIntfSortedMapIterator.Insert(const AEntry: TJclDoubleIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclDoubleIntfSortedMapIterator.IteratorEquals(const AIterator: IJclDoubleIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclDoubleIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclDoubleIntfSortedMapIterator then + begin + ItrObj := TJclDoubleIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclDoubleIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclDoubleIntfSortedMapIterator.Next: TJclDoubleIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclDoubleIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclDoubleIntfSortedMapIterator.Previous: TJclDoubleIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclDoubleIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclDoubleIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclDoubleIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclDoubleIntfSortedMapIterator.SetEntry(const AEntry: TJclDoubleIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntfDoubleSortedMap } ============================================== constructor TJclIntfDoubleSortedMap.Create(ACapacity: Integer); @@ -12292,6 +15786,13 @@ function TJclIntfDoubleSortedMap.Extract(const Key: IInterface): Double; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfDoubleSortedMap.GetEnumerator: IJclIntfDoubleSortedMapIterator; +begin + Result := TJclIntfDoubleSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfDoubleSortedMap.GetValue(const Key: IInterface): Double; var Index: Integer; @@ -12466,7 +15967,7 @@ function TJclIntfDoubleSortedMap.MapEquals(const AMap: IJclIntfDoubleMap): Boole {$ENDIF THREADSAFE} end; -procedure TJclIntfDoubleSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfDoubleSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -12485,7 +15986,7 @@ procedure TJclIntfDoubleSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfDoub end; end; -procedure TJclIntfDoubleSortedMap.InitializeArray(var List: TJclIntfDoubleSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfDoubleSortedMap.InitializeArray(var List: TJclIntfDoubleMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -12499,7 +16000,7 @@ procedure TJclIntfDoubleSortedMap.InitializeArray(var List: TJclIntfDoubleSorted {$ENDIF ~FPC} end; -procedure TJclIntfDoubleSortedMap.InitializeArrayAfterMove(var List: TJclIntfDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfDoubleSortedMap.InitializeArrayAfterMove(var List: TJclIntfDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -12518,7 +16019,7 @@ procedure TJclIntfDoubleSortedMap.InitializeArrayAfterMove(var List: TJclIntfDou end; end; -procedure TJclIntfDoubleSortedMap.MoveArray(var List: TJclIntfDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfDoubleSortedMap.MoveArray(var List: TJclIntfDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -12763,6 +16264,160 @@ function TJclIntfDoubleSortedMap.ValuesCompare(const A, B: Double): Integer; Result := ItemsCompare(A, B); end; +//=== { TJclIntfDoubleSortedMapIterator } =============================================================== + +constructor TJclIntfDoubleSortedMapIterator.Create(AOwnMap: TJclIntfDoubleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfDoubleSortedMapIterator.Add(const AEntry: TJclIntfDoubleMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfDoubleSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfDoubleSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfDoubleSortedMapIterator then + begin + ADest := TJclIntfDoubleSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfDoubleSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfDoubleSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfDoubleSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfDoubleSortedMapIterator.GetEntry: TJclIntfDoubleMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfDoubleSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfDoubleSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfDoubleSortedMapIterator.Insert(const AEntry: TJclIntfDoubleMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfDoubleSortedMapIterator.IteratorEquals(const AIterator: IJclIntfDoubleSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfDoubleSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfDoubleSortedMapIterator then + begin + ItrObj := TJclIntfDoubleSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfDoubleSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfDoubleSortedMapIterator.Next: TJclIntfDoubleMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfDoubleSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfDoubleSortedMapIterator.Previous: TJclIntfDoubleMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfDoubleSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfDoubleSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfDoubleSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfDoubleSortedMapIterator.SetEntry(const AEntry: TJclIntfDoubleMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclDoubleDoubleSortedMap } ============================================== constructor TJclDoubleDoubleSortedMap.Create(ACapacity: Integer); @@ -12954,6 +16609,13 @@ function TJclDoubleDoubleSortedMap.Extract(const Key: Double): Double; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclDoubleDoubleSortedMap.GetEnumerator: IJclDoubleDoubleSortedMapIterator; +begin + Result := TJclDoubleDoubleSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclDoubleDoubleSortedMap.GetValue(const Key: Double): Double; var Index: Integer; @@ -13128,7 +16790,7 @@ function TJclDoubleDoubleSortedMap.MapEquals(const AMap: IJclDoubleDoubleMap): B {$ENDIF THREADSAFE} end; -procedure TJclDoubleDoubleSortedMap.InitializeArrayAfterMove(var List: TJclDoubleDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclDoubleDoubleSortedMap.InitializeArrayAfterMove(var List: TJclDoubleDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -13147,7 +16809,7 @@ procedure TJclDoubleDoubleSortedMap.InitializeArrayAfterMove(var List: TJclDoubl end; end; -procedure TJclDoubleDoubleSortedMap.MoveArray(var List: TJclDoubleDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclDoubleDoubleSortedMap.MoveArray(var List: TJclDoubleDoubleMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -13391,40 +17053,194 @@ function TJclDoubleDoubleSortedMap.ValuesCompare(const A, B: Double): Integer; Result := ItemsCompare(A, B); end; -//=== { TJclExtendedIntfSortedMap } ============================================== +//=== { TJclDoubleDoubleSortedMapIterator } =============================================================== -constructor TJclExtendedIntfSortedMap.Create(ACapacity: Integer); +constructor TJclDoubleDoubleSortedMapIterator.Create(AOwnMap: TJclDoubleDoubleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclExtendedIntfSortedMap.Destroy; +function TJclDoubleDoubleSortedMapIterator.Add(const AEntry: TJclDoubleDoubleMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclExtendedIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclDoubleDoubleSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclExtendedIntfSortedMap; - Index: Integer; + ADest: TJclDoubleDoubleSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclExtendedIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclDoubleDoubleSortedMapIterator then begin - MyDest := TJclExtendedIntfSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; - MyDest.FSize := FSize; + ADest := TJclDoubleDoubleSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; end; end; -function TJclExtendedIntfSortedMap.BinarySearch(const Key: Extended): Integer; -var +function TJclDoubleDoubleSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclDoubleDoubleSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclDoubleDoubleSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclDoubleDoubleSortedMapIterator.GetEntry: TJclDoubleDoubleMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclDoubleDoubleSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclDoubleDoubleSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclDoubleDoubleSortedMapIterator.Insert(const AEntry: TJclDoubleDoubleMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclDoubleDoubleSortedMapIterator.IteratorEquals(const AIterator: IJclDoubleDoubleSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclDoubleDoubleSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclDoubleDoubleSortedMapIterator then + begin + ItrObj := TJclDoubleDoubleSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclDoubleDoubleSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclDoubleDoubleSortedMapIterator.Next: TJclDoubleDoubleMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclDoubleDoubleSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclDoubleDoubleSortedMapIterator.Previous: TJclDoubleDoubleMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclDoubleDoubleSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclDoubleDoubleSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclDoubleDoubleSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclDoubleDoubleSortedMapIterator.SetEntry(const AEntry: TJclDoubleDoubleMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclExtendedIntfSortedMap } ============================================== + +constructor TJclExtendedIntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclExtendedIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclExtendedIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclExtendedIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclExtendedIntfSortedMap then + begin + MyDest := TJclExtendedIntfSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; + MyDest.FSize := FSize; + end; +end; + +function TJclExtendedIntfSortedMap.BinarySearch(const Key: Extended): Integer; +var HiPos, LoPos, CompPos: Integer; Comp: Integer; begin @@ -13582,6 +17398,13 @@ function TJclExtendedIntfSortedMap.Extract(const Key: Extended): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclExtendedIntfSortedMap.GetEnumerator: IJclExtendedIntfSortedMapIterator; +begin + Result := TJclExtendedIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclExtendedIntfSortedMap.GetValue(const Key: Extended): IInterface; var Index: Integer; @@ -13756,7 +17579,7 @@ function TJclExtendedIntfSortedMap.MapEquals(const AMap: IJclExtendedIntfMap): B {$ENDIF THREADSAFE} end; -procedure TJclExtendedIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclExtendedIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclExtendedIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclExtendedIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -13775,7 +17598,7 @@ procedure TJclExtendedIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclExtend end; end; -procedure TJclExtendedIntfSortedMap.InitializeArray(var List: TJclExtendedIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclExtendedIntfSortedMap.InitializeArray(var List: TJclExtendedIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -13789,7 +17612,7 @@ procedure TJclExtendedIntfSortedMap.InitializeArray(var List: TJclExtendedIntfSo {$ENDIF ~FPC} end; -procedure TJclExtendedIntfSortedMap.InitializeArrayAfterMove(var List: TJclExtendedIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclExtendedIntfSortedMap.InitializeArrayAfterMove(var List: TJclExtendedIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -13808,7 +17631,7 @@ procedure TJclExtendedIntfSortedMap.InitializeArrayAfterMove(var List: TJclExten end; end; -procedure TJclExtendedIntfSortedMap.MoveArray(var List: TJclExtendedIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclExtendedIntfSortedMap.MoveArray(var List: TJclExtendedIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -14053,6 +17876,160 @@ function TJclExtendedIntfSortedMap.ValuesCompare(const A, B: IInterface): Intege Result := IntfSimpleCompare(A, B); end; +//=== { TJclExtendedIntfSortedMapIterator } =============================================================== + +constructor TJclExtendedIntfSortedMapIterator.Create(AOwnMap: TJclExtendedIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclExtendedIntfSortedMapIterator.Add(const AEntry: TJclExtendedIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclExtendedIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclExtendedIntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclExtendedIntfSortedMapIterator then + begin + ADest := TJclExtendedIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclExtendedIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclExtendedIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclExtendedIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclExtendedIntfSortedMapIterator.GetEntry: TJclExtendedIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclExtendedIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclExtendedIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclExtendedIntfSortedMapIterator.Insert(const AEntry: TJclExtendedIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclExtendedIntfSortedMapIterator.IteratorEquals(const AIterator: IJclExtendedIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclExtendedIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclExtendedIntfSortedMapIterator then + begin + ItrObj := TJclExtendedIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclExtendedIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclExtendedIntfSortedMapIterator.Next: TJclExtendedIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclExtendedIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclExtendedIntfSortedMapIterator.Previous: TJclExtendedIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclExtendedIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclExtendedIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclExtendedIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclExtendedIntfSortedMapIterator.SetEntry(const AEntry: TJclExtendedIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntfExtendedSortedMap } ============================================== constructor TJclIntfExtendedSortedMap.Create(ACapacity: Integer); @@ -14244,6 +18221,13 @@ function TJclIntfExtendedSortedMap.Extract(const Key: IInterface): Extended; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfExtendedSortedMap.GetEnumerator: IJclIntfExtendedSortedMapIterator; +begin + Result := TJclIntfExtendedSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfExtendedSortedMap.GetValue(const Key: IInterface): Extended; var Index: Integer; @@ -14418,7 +18402,7 @@ function TJclIntfExtendedSortedMap.MapEquals(const AMap: IJclIntfExtendedMap): B {$ENDIF THREADSAFE} end; -procedure TJclIntfExtendedSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfExtendedSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -14437,7 +18421,7 @@ procedure TJclIntfExtendedSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfEx end; end; -procedure TJclIntfExtendedSortedMap.InitializeArray(var List: TJclIntfExtendedSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfExtendedSortedMap.InitializeArray(var List: TJclIntfExtendedMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -14451,7 +18435,7 @@ procedure TJclIntfExtendedSortedMap.InitializeArray(var List: TJclIntfExtendedSo {$ENDIF ~FPC} end; -procedure TJclIntfExtendedSortedMap.InitializeArrayAfterMove(var List: TJclIntfExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfExtendedSortedMap.InitializeArrayAfterMove(var List: TJclIntfExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -14470,7 +18454,7 @@ procedure TJclIntfExtendedSortedMap.InitializeArrayAfterMove(var List: TJclIntfE end; end; -procedure TJclIntfExtendedSortedMap.MoveArray(var List: TJclIntfExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfExtendedSortedMap.MoveArray(var List: TJclIntfExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -14715,6 +18699,160 @@ function TJclIntfExtendedSortedMap.ValuesCompare(const A, B: Extended): Integer; Result := ItemsCompare(A, B); end; +//=== { TJclIntfExtendedSortedMapIterator } =============================================================== + +constructor TJclIntfExtendedSortedMapIterator.Create(AOwnMap: TJclIntfExtendedSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfExtendedSortedMapIterator.Add(const AEntry: TJclIntfExtendedMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfExtendedSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfExtendedSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfExtendedSortedMapIterator then + begin + ADest := TJclIntfExtendedSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfExtendedSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfExtendedSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfExtendedSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfExtendedSortedMapIterator.GetEntry: TJclIntfExtendedMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfExtendedSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfExtendedSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfExtendedSortedMapIterator.Insert(const AEntry: TJclIntfExtendedMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfExtendedSortedMapIterator.IteratorEquals(const AIterator: IJclIntfExtendedSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfExtendedSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfExtendedSortedMapIterator then + begin + ItrObj := TJclIntfExtendedSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfExtendedSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfExtendedSortedMapIterator.Next: TJclIntfExtendedMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfExtendedSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfExtendedSortedMapIterator.Previous: TJclIntfExtendedMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfExtendedSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfExtendedSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfExtendedSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfExtendedSortedMapIterator.SetEntry(const AEntry: TJclIntfExtendedMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclExtendedExtendedSortedMap } ============================================== constructor TJclExtendedExtendedSortedMap.Create(ACapacity: Integer); @@ -14906,6 +19044,13 @@ function TJclExtendedExtendedSortedMap.Extract(const Key: Extended): Extended; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclExtendedExtendedSortedMap.GetEnumerator: IJclExtendedExtendedSortedMapIterator; +begin + Result := TJclExtendedExtendedSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclExtendedExtendedSortedMap.GetValue(const Key: Extended): Extended; var Index: Integer; @@ -15080,7 +19225,7 @@ function TJclExtendedExtendedSortedMap.MapEquals(const AMap: IJclExtendedExtende {$ENDIF THREADSAFE} end; -procedure TJclExtendedExtendedSortedMap.InitializeArrayAfterMove(var List: TJclExtendedExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclExtendedExtendedSortedMap.InitializeArrayAfterMove(var List: TJclExtendedExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -15099,7 +19244,7 @@ procedure TJclExtendedExtendedSortedMap.InitializeArrayAfterMove(var List: TJclE end; end; -procedure TJclExtendedExtendedSortedMap.MoveArray(var List: TJclExtendedExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclExtendedExtendedSortedMap.MoveArray(var List: TJclExtendedExtendedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -15343,35 +19488,189 @@ function TJclExtendedExtendedSortedMap.ValuesCompare(const A, B: Extended): Inte Result := ItemsCompare(A, B); end; -//=== { TJclIntegerIntfSortedMap } ============================================== +//=== { TJclExtendedExtendedSortedMapIterator } =============================================================== -constructor TJclIntegerIntfSortedMap.Create(ACapacity: Integer); +constructor TJclExtendedExtendedSortedMapIterator.Create(AOwnMap: TJclExtendedExtendedSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclIntegerIntfSortedMap.Destroy; +function TJclExtendedExtendedSortedMapIterator.Add(const AEntry: TJclExtendedExtendedMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclIntegerIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclExtendedExtendedSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclIntegerIntfSortedMap; - Index: Integer; + ADest: TJclExtendedExtendedSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclIntegerIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclExtendedExtendedSortedMapIterator then begin - MyDest := TJclIntegerIntfSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; - MyDest.FSize := FSize; + ADest := TJclExtendedExtendedSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclExtendedExtendedSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclExtendedExtendedSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclExtendedExtendedSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclExtendedExtendedSortedMapIterator.GetEntry: TJclExtendedExtendedMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclExtendedExtendedSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclExtendedExtendedSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclExtendedExtendedSortedMapIterator.Insert(const AEntry: TJclExtendedExtendedMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclExtendedExtendedSortedMapIterator.IteratorEquals(const AIterator: IJclExtendedExtendedSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclExtendedExtendedSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclExtendedExtendedSortedMapIterator then + begin + ItrObj := TJclExtendedExtendedSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclExtendedExtendedSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclExtendedExtendedSortedMapIterator.Next: TJclExtendedExtendedMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclExtendedExtendedSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclExtendedExtendedSortedMapIterator.Previous: TJclExtendedExtendedMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclExtendedExtendedSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclExtendedExtendedSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclExtendedExtendedSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclExtendedExtendedSortedMapIterator.SetEntry(const AEntry: TJclExtendedExtendedMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclIntegerIntfSortedMap } ============================================== + +constructor TJclIntegerIntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclIntegerIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclIntegerIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclIntegerIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclIntegerIntfSortedMap then + begin + MyDest := TJclIntegerIntfSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; + MyDest.FSize := FSize; end; end; @@ -15534,6 +19833,13 @@ function TJclIntegerIntfSortedMap.Extract(Key: Integer): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntegerIntfSortedMap.GetEnumerator: IJclIntegerIntfSortedMapIterator; +begin + Result := TJclIntegerIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntegerIntfSortedMap.GetValue(Key: Integer): IInterface; var Index: Integer; @@ -15708,7 +20014,7 @@ function TJclIntegerIntfSortedMap.MapEquals(const AMap: IJclIntegerIntfMap): Boo {$ENDIF THREADSAFE} end; -procedure TJclIntegerIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclIntegerIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntegerIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclIntegerIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -15727,7 +20033,7 @@ procedure TJclIntegerIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclInteger end; end; -procedure TJclIntegerIntfSortedMap.InitializeArray(var List: TJclIntegerIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntegerIntfSortedMap.InitializeArray(var List: TJclIntegerIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -15741,7 +20047,7 @@ procedure TJclIntegerIntfSortedMap.InitializeArray(var List: TJclIntegerIntfSort {$ENDIF ~FPC} end; -procedure TJclIntegerIntfSortedMap.InitializeArrayAfterMove(var List: TJclIntegerIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntegerIntfSortedMap.InitializeArrayAfterMove(var List: TJclIntegerIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -15760,7 +20066,7 @@ procedure TJclIntegerIntfSortedMap.InitializeArrayAfterMove(var List: TJclIntege end; end; -procedure TJclIntegerIntfSortedMap.MoveArray(var List: TJclIntegerIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntegerIntfSortedMap.MoveArray(var List: TJclIntegerIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -16005,6 +20311,160 @@ function TJclIntegerIntfSortedMap.ValuesCompare(const A, B: IInterface): Integer Result := IntfSimpleCompare(A, B); end; +//=== { TJclIntegerIntfSortedMapIterator } =============================================================== + +constructor TJclIntegerIntfSortedMapIterator.Create(AOwnMap: TJclIntegerIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntegerIntfSortedMapIterator.Add(const AEntry: TJclIntegerIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntegerIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntegerIntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntegerIntfSortedMapIterator then + begin + ADest := TJclIntegerIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntegerIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntegerIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntegerIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntegerIntfSortedMapIterator.GetEntry: TJclIntegerIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntegerIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntegerIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntegerIntfSortedMapIterator.Insert(const AEntry: TJclIntegerIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntegerIntfSortedMapIterator.IteratorEquals(const AIterator: IJclIntegerIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntegerIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntegerIntfSortedMapIterator then + begin + ItrObj := TJclIntegerIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntegerIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntegerIntfSortedMapIterator.Next: TJclIntegerIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntegerIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntegerIntfSortedMapIterator.Previous: TJclIntegerIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntegerIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntegerIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntegerIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntegerIntfSortedMapIterator.SetEntry(const AEntry: TJclIntegerIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntfIntegerSortedMap } ============================================== constructor TJclIntfIntegerSortedMap.Create(ACapacity: Integer); @@ -16196,6 +20656,13 @@ function TJclIntfIntegerSortedMap.Extract(const Key: IInterface): Integer; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfIntegerSortedMap.GetEnumerator: IJclIntfIntegerSortedMapIterator; +begin + Result := TJclIntfIntegerSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfIntegerSortedMap.GetValue(const Key: IInterface): Integer; var Index: Integer; @@ -16370,7 +20837,7 @@ function TJclIntfIntegerSortedMap.MapEquals(const AMap: IJclIntfIntegerMap): Boo {$ENDIF THREADSAFE} end; -procedure TJclIntfIntegerSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfIntegerSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -16389,7 +20856,7 @@ procedure TJclIntfIntegerSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfInt end; end; -procedure TJclIntfIntegerSortedMap.InitializeArray(var List: TJclIntfIntegerSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfIntegerSortedMap.InitializeArray(var List: TJclIntfIntegerMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -16403,7 +20870,7 @@ procedure TJclIntfIntegerSortedMap.InitializeArray(var List: TJclIntfIntegerSort {$ENDIF ~FPC} end; -procedure TJclIntfIntegerSortedMap.InitializeArrayAfterMove(var List: TJclIntfIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfIntegerSortedMap.InitializeArrayAfterMove(var List: TJclIntfIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -16422,7 +20889,7 @@ procedure TJclIntfIntegerSortedMap.InitializeArrayAfterMove(var List: TJclIntfIn end; end; -procedure TJclIntfIntegerSortedMap.MoveArray(var List: TJclIntfIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfIntegerSortedMap.MoveArray(var List: TJclIntfIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -16667,6 +21134,160 @@ function TJclIntfIntegerSortedMap.ValuesCompare(A, B: Integer): Integer; Result := ItemsCompare(A, B); end; +//=== { TJclIntfIntegerSortedMapIterator } =============================================================== + +constructor TJclIntfIntegerSortedMapIterator.Create(AOwnMap: TJclIntfIntegerSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfIntegerSortedMapIterator.Add(const AEntry: TJclIntfIntegerMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfIntegerSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfIntegerSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfIntegerSortedMapIterator then + begin + ADest := TJclIntfIntegerSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfIntegerSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfIntegerSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfIntegerSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfIntegerSortedMapIterator.GetEntry: TJclIntfIntegerMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfIntegerSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfIntegerSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfIntegerSortedMapIterator.Insert(const AEntry: TJclIntfIntegerMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfIntegerSortedMapIterator.IteratorEquals(const AIterator: IJclIntfIntegerSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfIntegerSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfIntegerSortedMapIterator then + begin + ItrObj := TJclIntfIntegerSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfIntegerSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfIntegerSortedMapIterator.Next: TJclIntfIntegerMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfIntegerSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfIntegerSortedMapIterator.Previous: TJclIntfIntegerMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfIntegerSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfIntegerSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfIntegerSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfIntegerSortedMapIterator.SetEntry(const AEntry: TJclIntfIntegerMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntegerIntegerSortedMap } ============================================== constructor TJclIntegerIntegerSortedMap.Create(ACapacity: Integer); @@ -16858,6 +21479,13 @@ function TJclIntegerIntegerSortedMap.Extract(Key: Integer): Integer; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntegerIntegerSortedMap.GetEnumerator: IJclIntegerIntegerSortedMapIterator; +begin + Result := TJclIntegerIntegerSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntegerIntegerSortedMap.GetValue(Key: Integer): Integer; var Index: Integer; @@ -17032,7 +21660,7 @@ function TJclIntegerIntegerSortedMap.MapEquals(const AMap: IJclIntegerIntegerMap {$ENDIF THREADSAFE} end; -procedure TJclIntegerIntegerSortedMap.InitializeArrayAfterMove(var List: TJclIntegerIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntegerIntegerSortedMap.InitializeArrayAfterMove(var List: TJclIntegerIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -17051,7 +21679,7 @@ procedure TJclIntegerIntegerSortedMap.InitializeArrayAfterMove(var List: TJclInt end; end; -procedure TJclIntegerIntegerSortedMap.MoveArray(var List: TJclIntegerIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntegerIntegerSortedMap.MoveArray(var List: TJclIntegerIntegerMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -17295,40 +21923,194 @@ function TJclIntegerIntegerSortedMap.ValuesCompare(A, B: Integer): Integer; Result := ItemsCompare(A, B); end; -//=== { TJclCardinalIntfSortedMap } ============================================== +//=== { TJclIntegerIntegerSortedMapIterator } =============================================================== -constructor TJclCardinalIntfSortedMap.Create(ACapacity: Integer); +constructor TJclIntegerIntegerSortedMapIterator.Create(AOwnMap: TJclIntegerIntegerSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclCardinalIntfSortedMap.Destroy; +function TJclIntegerIntegerSortedMapIterator.Add(const AEntry: TJclIntegerIntegerMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclCardinalIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclIntegerIntegerSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclCardinalIntfSortedMap; - Index: Integer; + ADest: TJclIntegerIntegerSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclCardinalIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntegerIntegerSortedMapIterator then begin - MyDest := TJclCardinalIntfSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; - MyDest.FSize := FSize; + ADest := TJclIntegerIntegerSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; end; end; -function TJclCardinalIntfSortedMap.BinarySearch(Key: Cardinal): Integer; -var +function TJclIntegerIntegerSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntegerIntegerSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntegerIntegerSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntegerIntegerSortedMapIterator.GetEntry: TJclIntegerIntegerMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntegerIntegerSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntegerIntegerSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntegerIntegerSortedMapIterator.Insert(const AEntry: TJclIntegerIntegerMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntegerIntegerSortedMapIterator.IteratorEquals(const AIterator: IJclIntegerIntegerSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntegerIntegerSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntegerIntegerSortedMapIterator then + begin + ItrObj := TJclIntegerIntegerSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntegerIntegerSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntegerIntegerSortedMapIterator.Next: TJclIntegerIntegerMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntegerIntegerSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntegerIntegerSortedMapIterator.Previous: TJclIntegerIntegerMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntegerIntegerSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntegerIntegerSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntegerIntegerSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntegerIntegerSortedMapIterator.SetEntry(const AEntry: TJclIntegerIntegerMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclCardinalIntfSortedMap } ============================================== + +constructor TJclCardinalIntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclCardinalIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclCardinalIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclCardinalIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclCardinalIntfSortedMap then + begin + MyDest := TJclCardinalIntfSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; + MyDest.FSize := FSize; + end; +end; + +function TJclCardinalIntfSortedMap.BinarySearch(Key: Cardinal): Integer; +var HiPos, LoPos, CompPos: Integer; Comp: Integer; begin @@ -17486,6 +22268,13 @@ function TJclCardinalIntfSortedMap.Extract(Key: Cardinal): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclCardinalIntfSortedMap.GetEnumerator: IJclCardinalIntfSortedMapIterator; +begin + Result := TJclCardinalIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclCardinalIntfSortedMap.GetValue(Key: Cardinal): IInterface; var Index: Integer; @@ -17660,7 +22449,7 @@ function TJclCardinalIntfSortedMap.MapEquals(const AMap: IJclCardinalIntfMap): B {$ENDIF THREADSAFE} end; -procedure TJclCardinalIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclCardinalIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclCardinalIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclCardinalIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -17679,7 +22468,7 @@ procedure TJclCardinalIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclCardin end; end; -procedure TJclCardinalIntfSortedMap.InitializeArray(var List: TJclCardinalIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclCardinalIntfSortedMap.InitializeArray(var List: TJclCardinalIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -17693,7 +22482,7 @@ procedure TJclCardinalIntfSortedMap.InitializeArray(var List: TJclCardinalIntfSo {$ENDIF ~FPC} end; -procedure TJclCardinalIntfSortedMap.InitializeArrayAfterMove(var List: TJclCardinalIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclCardinalIntfSortedMap.InitializeArrayAfterMove(var List: TJclCardinalIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -17712,7 +22501,7 @@ procedure TJclCardinalIntfSortedMap.InitializeArrayAfterMove(var List: TJclCardi end; end; -procedure TJclCardinalIntfSortedMap.MoveArray(var List: TJclCardinalIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclCardinalIntfSortedMap.MoveArray(var List: TJclCardinalIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -17957,6 +22746,160 @@ function TJclCardinalIntfSortedMap.ValuesCompare(const A, B: IInterface): Intege Result := IntfSimpleCompare(A, B); end; +//=== { TJclCardinalIntfSortedMapIterator } =============================================================== + +constructor TJclCardinalIntfSortedMapIterator.Create(AOwnMap: TJclCardinalIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclCardinalIntfSortedMapIterator.Add(const AEntry: TJclCardinalIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclCardinalIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclCardinalIntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclCardinalIntfSortedMapIterator then + begin + ADest := TJclCardinalIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclCardinalIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclCardinalIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclCardinalIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclCardinalIntfSortedMapIterator.GetEntry: TJclCardinalIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclCardinalIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclCardinalIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclCardinalIntfSortedMapIterator.Insert(const AEntry: TJclCardinalIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclCardinalIntfSortedMapIterator.IteratorEquals(const AIterator: IJclCardinalIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclCardinalIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclCardinalIntfSortedMapIterator then + begin + ItrObj := TJclCardinalIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclCardinalIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclCardinalIntfSortedMapIterator.Next: TJclCardinalIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclCardinalIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclCardinalIntfSortedMapIterator.Previous: TJclCardinalIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclCardinalIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclCardinalIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclCardinalIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclCardinalIntfSortedMapIterator.SetEntry(const AEntry: TJclCardinalIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntfCardinalSortedMap } ============================================== constructor TJclIntfCardinalSortedMap.Create(ACapacity: Integer); @@ -18148,6 +23091,13 @@ function TJclIntfCardinalSortedMap.Extract(const Key: IInterface): Cardinal; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfCardinalSortedMap.GetEnumerator: IJclIntfCardinalSortedMapIterator; +begin + Result := TJclIntfCardinalSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfCardinalSortedMap.GetValue(const Key: IInterface): Cardinal; var Index: Integer; @@ -18322,7 +23272,7 @@ function TJclIntfCardinalSortedMap.MapEquals(const AMap: IJclIntfCardinalMap): B {$ENDIF THREADSAFE} end; -procedure TJclIntfCardinalSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfCardinalSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -18341,7 +23291,7 @@ procedure TJclIntfCardinalSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfCa end; end; -procedure TJclIntfCardinalSortedMap.InitializeArray(var List: TJclIntfCardinalSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfCardinalSortedMap.InitializeArray(var List: TJclIntfCardinalMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -18355,7 +23305,7 @@ procedure TJclIntfCardinalSortedMap.InitializeArray(var List: TJclIntfCardinalSo {$ENDIF ~FPC} end; -procedure TJclIntfCardinalSortedMap.InitializeArrayAfterMove(var List: TJclIntfCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfCardinalSortedMap.InitializeArrayAfterMove(var List: TJclIntfCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -18374,7 +23324,7 @@ procedure TJclIntfCardinalSortedMap.InitializeArrayAfterMove(var List: TJclIntfC end; end; -procedure TJclIntfCardinalSortedMap.MoveArray(var List: TJclIntfCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfCardinalSortedMap.MoveArray(var List: TJclIntfCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -18619,6 +23569,160 @@ function TJclIntfCardinalSortedMap.ValuesCompare(A, B: Cardinal): Integer; Result := ItemsCompare(A, B); end; +//=== { TJclIntfCardinalSortedMapIterator } =============================================================== + +constructor TJclIntfCardinalSortedMapIterator.Create(AOwnMap: TJclIntfCardinalSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfCardinalSortedMapIterator.Add(const AEntry: TJclIntfCardinalMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfCardinalSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfCardinalSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfCardinalSortedMapIterator then + begin + ADest := TJclIntfCardinalSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfCardinalSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfCardinalSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfCardinalSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfCardinalSortedMapIterator.GetEntry: TJclIntfCardinalMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfCardinalSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfCardinalSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfCardinalSortedMapIterator.Insert(const AEntry: TJclIntfCardinalMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfCardinalSortedMapIterator.IteratorEquals(const AIterator: IJclIntfCardinalSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfCardinalSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfCardinalSortedMapIterator then + begin + ItrObj := TJclIntfCardinalSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfCardinalSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfCardinalSortedMapIterator.Next: TJclIntfCardinalMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfCardinalSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfCardinalSortedMapIterator.Previous: TJclIntfCardinalMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfCardinalSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfCardinalSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfCardinalSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfCardinalSortedMapIterator.SetEntry(const AEntry: TJclIntfCardinalMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclCardinalCardinalSortedMap } ============================================== constructor TJclCardinalCardinalSortedMap.Create(ACapacity: Integer); @@ -18810,6 +23914,13 @@ function TJclCardinalCardinalSortedMap.Extract(Key: Cardinal): Cardinal; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclCardinalCardinalSortedMap.GetEnumerator: IJclCardinalCardinalSortedMapIterator; +begin + Result := TJclCardinalCardinalSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclCardinalCardinalSortedMap.GetValue(Key: Cardinal): Cardinal; var Index: Integer; @@ -18984,7 +24095,7 @@ function TJclCardinalCardinalSortedMap.MapEquals(const AMap: IJclCardinalCardina {$ENDIF THREADSAFE} end; -procedure TJclCardinalCardinalSortedMap.InitializeArrayAfterMove(var List: TJclCardinalCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclCardinalCardinalSortedMap.InitializeArrayAfterMove(var List: TJclCardinalCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -19003,7 +24114,7 @@ procedure TJclCardinalCardinalSortedMap.InitializeArrayAfterMove(var List: TJclC end; end; -procedure TJclCardinalCardinalSortedMap.MoveArray(var List: TJclCardinalCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclCardinalCardinalSortedMap.MoveArray(var List: TJclCardinalCardinalMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -19247,35 +24358,189 @@ function TJclCardinalCardinalSortedMap.ValuesCompare(A, B: Cardinal): Integer; Result := ItemsCompare(A, B); end; -//=== { TJclInt64IntfSortedMap } ============================================== +//=== { TJclCardinalCardinalSortedMapIterator } =============================================================== -constructor TJclInt64IntfSortedMap.Create(ACapacity: Integer); +constructor TJclCardinalCardinalSortedMapIterator.Create(AOwnMap: TJclCardinalCardinalSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclInt64IntfSortedMap.Destroy; +function TJclCardinalCardinalSortedMapIterator.Add(const AEntry: TJclCardinalCardinalMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclInt64IntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclCardinalCardinalSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclInt64IntfSortedMap; - Index: Integer; + ADest: TJclCardinalCardinalSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclInt64IntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclCardinalCardinalSortedMapIterator then begin - MyDest := TJclInt64IntfSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; - MyDest.FSize := FSize; + ADest := TJclCardinalCardinalSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclCardinalCardinalSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclCardinalCardinalSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclCardinalCardinalSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclCardinalCardinalSortedMapIterator.GetEntry: TJclCardinalCardinalMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclCardinalCardinalSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclCardinalCardinalSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclCardinalCardinalSortedMapIterator.Insert(const AEntry: TJclCardinalCardinalMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclCardinalCardinalSortedMapIterator.IteratorEquals(const AIterator: IJclCardinalCardinalSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclCardinalCardinalSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclCardinalCardinalSortedMapIterator then + begin + ItrObj := TJclCardinalCardinalSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclCardinalCardinalSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclCardinalCardinalSortedMapIterator.Next: TJclCardinalCardinalMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclCardinalCardinalSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclCardinalCardinalSortedMapIterator.Previous: TJclCardinalCardinalMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclCardinalCardinalSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclCardinalCardinalSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclCardinalCardinalSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclCardinalCardinalSortedMapIterator.SetEntry(const AEntry: TJclCardinalCardinalMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclInt64IntfSortedMap } ============================================== + +constructor TJclInt64IntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclInt64IntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclInt64IntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclInt64IntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclInt64IntfSortedMap then + begin + MyDest := TJclInt64IntfSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; + MyDest.FSize := FSize; end; end; @@ -19438,6 +24703,13 @@ function TJclInt64IntfSortedMap.Extract(const Key: Int64): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclInt64IntfSortedMap.GetEnumerator: IJclInt64IntfSortedMapIterator; +begin + Result := TJclInt64IntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclInt64IntfSortedMap.GetValue(const Key: Int64): IInterface; var Index: Integer; @@ -19612,7 +24884,7 @@ function TJclInt64IntfSortedMap.MapEquals(const AMap: IJclInt64IntfMap): Boolean {$ENDIF THREADSAFE} end; -procedure TJclInt64IntfSortedMap.FinalizeArrayBeforeMove(var List: TJclInt64IntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclInt64IntfSortedMap.FinalizeArrayBeforeMove(var List: TJclInt64IntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -19631,7 +24903,7 @@ procedure TJclInt64IntfSortedMap.FinalizeArrayBeforeMove(var List: TJclInt64Intf end; end; -procedure TJclInt64IntfSortedMap.InitializeArray(var List: TJclInt64IntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclInt64IntfSortedMap.InitializeArray(var List: TJclInt64IntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -19645,7 +24917,7 @@ procedure TJclInt64IntfSortedMap.InitializeArray(var List: TJclInt64IntfSortedMa {$ENDIF ~FPC} end; -procedure TJclInt64IntfSortedMap.InitializeArrayAfterMove(var List: TJclInt64IntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclInt64IntfSortedMap.InitializeArrayAfterMove(var List: TJclInt64IntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -19664,7 +24936,7 @@ procedure TJclInt64IntfSortedMap.InitializeArrayAfterMove(var List: TJclInt64Int end; end; -procedure TJclInt64IntfSortedMap.MoveArray(var List: TJclInt64IntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclInt64IntfSortedMap.MoveArray(var List: TJclInt64IntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -19909,6 +25181,160 @@ function TJclInt64IntfSortedMap.ValuesCompare(const A, B: IInterface): Integer; Result := IntfSimpleCompare(A, B); end; +//=== { TJclInt64IntfSortedMapIterator } =============================================================== + +constructor TJclInt64IntfSortedMapIterator.Create(AOwnMap: TJclInt64IntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclInt64IntfSortedMapIterator.Add(const AEntry: TJclInt64IntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclInt64IntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclInt64IntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclInt64IntfSortedMapIterator then + begin + ADest := TJclInt64IntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclInt64IntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclInt64IntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclInt64IntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclInt64IntfSortedMapIterator.GetEntry: TJclInt64IntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclInt64IntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclInt64IntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclInt64IntfSortedMapIterator.Insert(const AEntry: TJclInt64IntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclInt64IntfSortedMapIterator.IteratorEquals(const AIterator: IJclInt64IntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclInt64IntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclInt64IntfSortedMapIterator then + begin + ItrObj := TJclInt64IntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclInt64IntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclInt64IntfSortedMapIterator.Next: TJclInt64IntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclInt64IntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclInt64IntfSortedMapIterator.Previous: TJclInt64IntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclInt64IntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclInt64IntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclInt64IntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclInt64IntfSortedMapIterator.SetEntry(const AEntry: TJclInt64IntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntfInt64SortedMap } ============================================== constructor TJclIntfInt64SortedMap.Create(ACapacity: Integer); @@ -20100,6 +25526,13 @@ function TJclIntfInt64SortedMap.Extract(const Key: IInterface): Int64; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfInt64SortedMap.GetEnumerator: IJclIntfInt64SortedMapIterator; +begin + Result := TJclIntfInt64SortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfInt64SortedMap.GetValue(const Key: IInterface): Int64; var Index: Integer; @@ -20274,7 +25707,7 @@ function TJclIntfInt64SortedMap.MapEquals(const AMap: IJclIntfInt64Map): Boolean {$ENDIF THREADSAFE} end; -procedure TJclIntfInt64SortedMap.FinalizeArrayBeforeMove(var List: TJclIntfInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfInt64SortedMap.FinalizeArrayBeforeMove(var List: TJclIntfInt64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -20293,7 +25726,7 @@ procedure TJclIntfInt64SortedMap.FinalizeArrayBeforeMove(var List: TJclIntfInt64 end; end; -procedure TJclIntfInt64SortedMap.InitializeArray(var List: TJclIntfInt64SortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfInt64SortedMap.InitializeArray(var List: TJclIntfInt64MapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -20307,7 +25740,7 @@ procedure TJclIntfInt64SortedMap.InitializeArray(var List: TJclIntfInt64SortedMa {$ENDIF ~FPC} end; -procedure TJclIntfInt64SortedMap.InitializeArrayAfterMove(var List: TJclIntfInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfInt64SortedMap.InitializeArrayAfterMove(var List: TJclIntfInt64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -20326,7 +25759,7 @@ procedure TJclIntfInt64SortedMap.InitializeArrayAfterMove(var List: TJclIntfInt6 end; end; -procedure TJclIntfInt64SortedMap.MoveArray(var List: TJclIntfInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfInt64SortedMap.MoveArray(var List: TJclIntfInt64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -20571,6 +26004,160 @@ function TJclIntfInt64SortedMap.ValuesCompare(const A, B: Int64): Integer; Result := ItemsCompare(A, B); end; +//=== { TJclIntfInt64SortedMapIterator } =============================================================== + +constructor TJclIntfInt64SortedMapIterator.Create(AOwnMap: TJclIntfInt64SortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfInt64SortedMapIterator.Add(const AEntry: TJclIntfInt64MapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfInt64SortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfInt64SortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfInt64SortedMapIterator then + begin + ADest := TJclIntfInt64SortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfInt64SortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfInt64SortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfInt64SortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfInt64SortedMapIterator.GetEntry: TJclIntfInt64MapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfInt64SortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfInt64SortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfInt64SortedMapIterator.Insert(const AEntry: TJclIntfInt64MapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfInt64SortedMapIterator.IteratorEquals(const AIterator: IJclIntfInt64SortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfInt64SortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfInt64SortedMapIterator then + begin + ItrObj := TJclIntfInt64SortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfInt64SortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfInt64SortedMapIterator.Next: TJclIntfInt64MapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfInt64SortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfInt64SortedMapIterator.Previous: TJclIntfInt64MapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfInt64SortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfInt64SortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfInt64SortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfInt64SortedMapIterator.SetEntry(const AEntry: TJclIntfInt64MapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclInt64Int64SortedMap } ============================================== constructor TJclInt64Int64SortedMap.Create(ACapacity: Integer); @@ -20762,6 +26349,13 @@ function TJclInt64Int64SortedMap.Extract(const Key: Int64): Int64; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclInt64Int64SortedMap.GetEnumerator: IJclInt64Int64SortedMapIterator; +begin + Result := TJclInt64Int64SortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclInt64Int64SortedMap.GetValue(const Key: Int64): Int64; var Index: Integer; @@ -20936,7 +26530,7 @@ function TJclInt64Int64SortedMap.MapEquals(const AMap: IJclInt64Int64Map): Boole {$ENDIF THREADSAFE} end; -procedure TJclInt64Int64SortedMap.InitializeArrayAfterMove(var List: TJclInt64Int64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclInt64Int64SortedMap.InitializeArrayAfterMove(var List: TJclInt64Int64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -20955,7 +26549,7 @@ procedure TJclInt64Int64SortedMap.InitializeArrayAfterMove(var List: TJclInt64In end; end; -procedure TJclInt64Int64SortedMap.MoveArray(var List: TJclInt64Int64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclInt64Int64SortedMap.MoveArray(var List: TJclInt64Int64MapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -21199,40 +26793,194 @@ function TJclInt64Int64SortedMap.ValuesCompare(const A, B: Int64): Integer; Result := ItemsCompare(A, B); end; -//=== { TJclPtrIntfSortedMap } ============================================== +//=== { TJclInt64Int64SortedMapIterator } =============================================================== -constructor TJclPtrIntfSortedMap.Create(ACapacity: Integer); +constructor TJclInt64Int64SortedMapIterator.Create(AOwnMap: TJclInt64Int64SortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclPtrIntfSortedMap.Destroy; +function TJclInt64Int64SortedMapIterator.Add(const AEntry: TJclInt64Int64MapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclPtrIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclInt64Int64SortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclPtrIntfSortedMap; - Index: Integer; + ADest: TJclInt64Int64SortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclPtrIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclInt64Int64SortedMapIterator then begin - MyDest := TJclPtrIntfSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; - MyDest.FSize := FSize; + ADest := TJclInt64Int64SortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; end; end; -function TJclPtrIntfSortedMap.BinarySearch(Key: Pointer): Integer; -var +function TJclInt64Int64SortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclInt64Int64SortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclInt64Int64SortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclInt64Int64SortedMapIterator.GetEntry: TJclInt64Int64MapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclInt64Int64SortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclInt64Int64SortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclInt64Int64SortedMapIterator.Insert(const AEntry: TJclInt64Int64MapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclInt64Int64SortedMapIterator.IteratorEquals(const AIterator: IJclInt64Int64SortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclInt64Int64SortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclInt64Int64SortedMapIterator then + begin + ItrObj := TJclInt64Int64SortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclInt64Int64SortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclInt64Int64SortedMapIterator.Next: TJclInt64Int64MapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclInt64Int64SortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclInt64Int64SortedMapIterator.Previous: TJclInt64Int64MapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclInt64Int64SortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclInt64Int64SortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclInt64Int64SortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclInt64Int64SortedMapIterator.SetEntry(const AEntry: TJclInt64Int64MapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclPtrIntfSortedMap } ============================================== + +constructor TJclPtrIntfSortedMap.Create(ACapacity: Integer); +begin + inherited Create(); + SetCapacity(ACapacity); +end; + +destructor TJclPtrIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclPtrIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclPtrIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclPtrIntfSortedMap then + begin + MyDest := TJclPtrIntfSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; + MyDest.FSize := FSize; + end; +end; + +function TJclPtrIntfSortedMap.BinarySearch(Key: Pointer): Integer; +var HiPos, LoPos, CompPos: Integer; Comp: Integer; begin @@ -21390,6 +27138,13 @@ function TJclPtrIntfSortedMap.Extract(Key: Pointer): IInterface; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclPtrIntfSortedMap.GetEnumerator: IJclPtrIntfSortedMapIterator; +begin + Result := TJclPtrIntfSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclPtrIntfSortedMap.GetValue(Key: Pointer): IInterface; var Index: Integer; @@ -21564,7 +27319,7 @@ function TJclPtrIntfSortedMap.MapEquals(const AMap: IJclPtrIntfMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclPtrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclPtrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclPtrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclPtrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -21583,7 +27338,7 @@ procedure TJclPtrIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclPtrIntfSort end; end; -procedure TJclPtrIntfSortedMap.InitializeArray(var List: TJclPtrIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclPtrIntfSortedMap.InitializeArray(var List: TJclPtrIntfMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -21597,7 +27352,7 @@ procedure TJclPtrIntfSortedMap.InitializeArray(var List: TJclPtrIntfSortedMapEnt {$ENDIF ~FPC} end; -procedure TJclPtrIntfSortedMap.InitializeArrayAfterMove(var List: TJclPtrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclPtrIntfSortedMap.InitializeArrayAfterMove(var List: TJclPtrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -21616,7 +27371,7 @@ procedure TJclPtrIntfSortedMap.InitializeArrayAfterMove(var List: TJclPtrIntfSor end; end; -procedure TJclPtrIntfSortedMap.MoveArray(var List: TJclPtrIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclPtrIntfSortedMap.MoveArray(var List: TJclPtrIntfMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -21861,6 +27616,160 @@ function TJclPtrIntfSortedMap.ValuesCompare(const A, B: IInterface): Integer; Result := IntfSimpleCompare(A, B); end; +//=== { TJclPtrIntfSortedMapIterator } =============================================================== + +constructor TJclPtrIntfSortedMapIterator.Create(AOwnMap: TJclPtrIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclPtrIntfSortedMapIterator.Add(const AEntry: TJclPtrIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclPtrIntfSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclPtrIntfSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclPtrIntfSortedMapIterator then + begin + ADest := TJclPtrIntfSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclPtrIntfSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclPtrIntfSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclPtrIntfSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclPtrIntfSortedMapIterator.GetEntry: TJclPtrIntfMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclPtrIntfSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclPtrIntfSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclPtrIntfSortedMapIterator.Insert(const AEntry: TJclPtrIntfMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclPtrIntfSortedMapIterator.IteratorEquals(const AIterator: IJclPtrIntfSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclPtrIntfSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclPtrIntfSortedMapIterator then + begin + ItrObj := TJclPtrIntfSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclPtrIntfSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclPtrIntfSortedMapIterator.Next: TJclPtrIntfMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclPtrIntfSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclPtrIntfSortedMapIterator.Previous: TJclPtrIntfMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclPtrIntfSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclPtrIntfSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclPtrIntfSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclPtrIntfSortedMapIterator.SetEntry(const AEntry: TJclPtrIntfMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntfPtrSortedMap } ============================================== constructor TJclIntfPtrSortedMap.Create(ACapacity: Integer); @@ -22052,6 +27961,13 @@ function TJclIntfPtrSortedMap.Extract(const Key: IInterface): Pointer; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfPtrSortedMap.GetEnumerator: IJclIntfPtrSortedMapIterator; +begin + Result := TJclIntfPtrSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfPtrSortedMap.GetValue(const Key: IInterface): Pointer; var Index: Integer; @@ -22226,7 +28142,7 @@ function TJclIntfPtrSortedMap.MapEquals(const AMap: IJclIntfPtrMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclIntfPtrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfPtrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -22245,7 +28161,7 @@ procedure TJclIntfPtrSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfPtrSort end; end; -procedure TJclIntfPtrSortedMap.InitializeArray(var List: TJclIntfPtrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfPtrSortedMap.InitializeArray(var List: TJclIntfPtrMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -22259,7 +28175,7 @@ procedure TJclIntfPtrSortedMap.InitializeArray(var List: TJclIntfPtrSortedMapEnt {$ENDIF ~FPC} end; -procedure TJclIntfPtrSortedMap.InitializeArrayAfterMove(var List: TJclIntfPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfPtrSortedMap.InitializeArrayAfterMove(var List: TJclIntfPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -22278,7 +28194,7 @@ procedure TJclIntfPtrSortedMap.InitializeArrayAfterMove(var List: TJclIntfPtrSor end; end; -procedure TJclIntfPtrSortedMap.MoveArray(var List: TJclIntfPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfPtrSortedMap.MoveArray(var List: TJclIntfPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -22523,6 +28439,160 @@ function TJclIntfPtrSortedMap.ValuesCompare(A, B: Pointer): Integer; Result := ItemsCompare(A, B); end; +//=== { TJclIntfPtrSortedMapIterator } =============================================================== + +constructor TJclIntfPtrSortedMapIterator.Create(AOwnMap: TJclIntfPtrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfPtrSortedMapIterator.Add(const AEntry: TJclIntfPtrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfPtrSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfPtrSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfPtrSortedMapIterator then + begin + ADest := TJclIntfPtrSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfPtrSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfPtrSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfPtrSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfPtrSortedMapIterator.GetEntry: TJclIntfPtrMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfPtrSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfPtrSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfPtrSortedMapIterator.Insert(const AEntry: TJclIntfPtrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfPtrSortedMapIterator.IteratorEquals(const AIterator: IJclIntfPtrSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfPtrSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfPtrSortedMapIterator then + begin + ItrObj := TJclIntfPtrSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfPtrSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfPtrSortedMapIterator.Next: TJclIntfPtrMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfPtrSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfPtrSortedMapIterator.Previous: TJclIntfPtrMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfPtrSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfPtrSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfPtrSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfPtrSortedMapIterator.SetEntry(const AEntry: TJclIntfPtrMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclPtrPtrSortedMap } ============================================== constructor TJclPtrPtrSortedMap.Create(ACapacity: Integer); @@ -22714,6 +28784,13 @@ function TJclPtrPtrSortedMap.Extract(Key: Pointer): Pointer; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclPtrPtrSortedMap.GetEnumerator: IJclPtrPtrSortedMapIterator; +begin + Result := TJclPtrPtrSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclPtrPtrSortedMap.GetValue(Key: Pointer): Pointer; var Index: Integer; @@ -22888,7 +28965,7 @@ function TJclPtrPtrSortedMap.MapEquals(const AMap: IJclPtrPtrMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclPtrPtrSortedMap.InitializeArrayAfterMove(var List: TJclPtrPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclPtrPtrSortedMap.InitializeArrayAfterMove(var List: TJclPtrPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -22907,7 +28984,7 @@ procedure TJclPtrPtrSortedMap.InitializeArrayAfterMove(var List: TJclPtrPtrSorte end; end; -procedure TJclPtrPtrSortedMap.MoveArray(var List: TJclPtrPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclPtrPtrSortedMap.MoveArray(var List: TJclPtrPtrMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -23151,35 +29228,189 @@ function TJclPtrPtrSortedMap.ValuesCompare(A, B: Pointer): Integer; Result := ItemsCompare(A, B); end; -//=== { TJclIntfSortedMap } ============================================== +//=== { TJclPtrPtrSortedMapIterator } =============================================================== -constructor TJclIntfSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); +constructor TJclPtrPtrSortedMapIterator.Create(AOwnMap: TJclPtrPtrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - FOwnsValues := AOwnsValues; - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclIntfSortedMap.Destroy; +function TJclPtrPtrSortedMapIterator.Add(const AEntry: TJclPtrPtrMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclPtrPtrSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclIntfSortedMap; - Index: Integer; + ADest: TJclPtrPtrSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclIntfSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclPtrPtrSortedMapIterator then begin - MyDest := TJclIntfSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; + ADest := TJclPtrPtrSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclPtrPtrSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclPtrPtrSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclPtrPtrSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclPtrPtrSortedMapIterator.GetEntry: TJclPtrPtrMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclPtrPtrSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclPtrPtrSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclPtrPtrSortedMapIterator.Insert(const AEntry: TJclPtrPtrMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclPtrPtrSortedMapIterator.IteratorEquals(const AIterator: IJclPtrPtrSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclPtrPtrSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclPtrPtrSortedMapIterator then + begin + ItrObj := TJclPtrPtrSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclPtrPtrSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclPtrPtrSortedMapIterator.Next: TJclPtrPtrMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclPtrPtrSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclPtrPtrSortedMapIterator.Previous: TJclPtrPtrMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclPtrPtrSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclPtrPtrSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclPtrPtrSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclPtrPtrSortedMapIterator.SetEntry(const AEntry: TJclPtrPtrMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclIntfSortedMap } ============================================== + +constructor TJclIntfSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); +begin + inherited Create(); + FOwnsValues := AOwnsValues; + SetCapacity(ACapacity); +end; + +destructor TJclIntfSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclIntfSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclIntfSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclIntfSortedMap then + begin + MyDest := TJclIntfSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; MyDest.FSize := FSize; end; end; @@ -23343,6 +29574,13 @@ function TJclIntfSortedMap.Extract(const Key: IInterface): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfSortedMap.GetEnumerator: IJclIntfObjSortedMapIterator; +begin + Result := TJclIntfObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntfSortedMap.GetValue(const Key: IInterface): TObject; var Index: Integer; @@ -23517,7 +29755,7 @@ function TJclIntfSortedMap.MapEquals(const AMap: IJclIntfMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -23536,7 +29774,7 @@ procedure TJclIntfSortedMap.FinalizeArrayBeforeMove(var List: TJclIntfSortedMapE end; end; -procedure TJclIntfSortedMap.InitializeArray(var List: TJclIntfSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclIntfSortedMap.InitializeArray(var List: TJclIntfObjMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -23550,7 +29788,7 @@ procedure TJclIntfSortedMap.InitializeArray(var List: TJclIntfSortedMapEntryArra {$ENDIF ~FPC} end; -procedure TJclIntfSortedMap.InitializeArrayAfterMove(var List: TJclIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfSortedMap.InitializeArrayAfterMove(var List: TJclIntfObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -23569,7 +29807,7 @@ procedure TJclIntfSortedMap.InitializeArrayAfterMove(var List: TJclIntfSortedMap end; end; -procedure TJclIntfSortedMap.MoveArray(var List: TJclIntfSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntfSortedMap.MoveArray(var List: TJclIntfObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -23827,6 +30065,160 @@ function TJclIntfSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; +//=== { TJclIntfObjSortedMapIterator } =============================================================== + +constructor TJclIntfObjSortedMapIterator.Create(AOwnMap: TJclIntfSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntfObjSortedMapIterator.Add(const AEntry: TJclIntfObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntfObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntfObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntfObjSortedMapIterator then + begin + ADest := TJclIntfObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntfObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntfObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntfObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntfObjSortedMapIterator.GetEntry: TJclIntfObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntfObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntfObjSortedMapIterator.Insert(const AEntry: TJclIntfObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntfObjSortedMapIterator.IteratorEquals(const AIterator: IJclIntfObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntfObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntfObjSortedMapIterator then + begin + ItrObj := TJclIntfObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntfObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntfObjSortedMapIterator.Next: TJclIntfObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntfObjSortedMapIterator.Previous: TJclIntfObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntfObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntfObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntfObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntfObjSortedMapIterator.SetEntry(const AEntry: TJclIntfObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclAnsiStrSortedMap } ============================================== constructor TJclAnsiStrSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); @@ -24019,6 +30411,13 @@ function TJclAnsiStrSortedMap.Extract(const Key: AnsiString): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclAnsiStrSortedMap.GetEnumerator: IJclAnsiStrObjSortedMapIterator; +begin + Result := TJclAnsiStrObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclAnsiStrSortedMap.GetValue(const Key: AnsiString): TObject; var Index: Integer; @@ -24193,7 +30592,7 @@ function TJclAnsiStrSortedMap.MapEquals(const AMap: IJclAnsiStrMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclAnsiStrSortedMap.FinalizeArrayBeforeMove(var List: TJclAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclAnsiStrSortedMap.FinalizeArrayBeforeMove(var List: TJclAnsiStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -24212,7 +30611,7 @@ procedure TJclAnsiStrSortedMap.FinalizeArrayBeforeMove(var List: TJclAnsiStrSort end; end; -procedure TJclAnsiStrSortedMap.InitializeArray(var List: TJclAnsiStrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclAnsiStrSortedMap.InitializeArray(var List: TJclAnsiStrObjMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -24226,7 +30625,7 @@ procedure TJclAnsiStrSortedMap.InitializeArray(var List: TJclAnsiStrSortedMapEnt {$ENDIF ~FPC} end; -procedure TJclAnsiStrSortedMap.InitializeArrayAfterMove(var List: TJclAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclAnsiStrSortedMap.InitializeArrayAfterMove(var List: TJclAnsiStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -24245,7 +30644,7 @@ procedure TJclAnsiStrSortedMap.InitializeArrayAfterMove(var List: TJclAnsiStrSor end; end; -procedure TJclAnsiStrSortedMap.MoveArray(var List: TJclAnsiStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclAnsiStrSortedMap.MoveArray(var List: TJclAnsiStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -24503,6 +30902,160 @@ function TJclAnsiStrSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; +//=== { TJclAnsiStrObjSortedMapIterator } =============================================================== + +constructor TJclAnsiStrObjSortedMapIterator.Create(AOwnMap: TJclAnsiStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclAnsiStrObjSortedMapIterator.Add(const AEntry: TJclAnsiStrObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclAnsiStrObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclAnsiStrObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclAnsiStrObjSortedMapIterator then + begin + ADest := TJclAnsiStrObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclAnsiStrObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclAnsiStrObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclAnsiStrObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclAnsiStrObjSortedMapIterator.GetEntry: TJclAnsiStrObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclAnsiStrObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclAnsiStrObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclAnsiStrObjSortedMapIterator.Insert(const AEntry: TJclAnsiStrObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclAnsiStrObjSortedMapIterator.IteratorEquals(const AIterator: IJclAnsiStrObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclAnsiStrObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclAnsiStrObjSortedMapIterator then + begin + ItrObj := TJclAnsiStrObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclAnsiStrObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclAnsiStrObjSortedMapIterator.Next: TJclAnsiStrObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclAnsiStrObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclAnsiStrObjSortedMapIterator.Previous: TJclAnsiStrObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclAnsiStrObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclAnsiStrObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclAnsiStrObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclAnsiStrObjSortedMapIterator.SetEntry(const AEntry: TJclAnsiStrObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclWideStrSortedMap } ============================================== constructor TJclWideStrSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); @@ -24695,6 +31248,13 @@ function TJclWideStrSortedMap.Extract(const Key: WideString): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclWideStrSortedMap.GetEnumerator: IJclWideStrObjSortedMapIterator; +begin + Result := TJclWideStrObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclWideStrSortedMap.GetValue(const Key: WideString): TObject; var Index: Integer; @@ -24869,7 +31429,7 @@ function TJclWideStrSortedMap.MapEquals(const AMap: IJclWideStrMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclWideStrSortedMap.FinalizeArrayBeforeMove(var List: TJclWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclWideStrSortedMap.FinalizeArrayBeforeMove(var List: TJclWideStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -24888,7 +31448,7 @@ procedure TJclWideStrSortedMap.FinalizeArrayBeforeMove(var List: TJclWideStrSort end; end; -procedure TJclWideStrSortedMap.InitializeArray(var List: TJclWideStrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclWideStrSortedMap.InitializeArray(var List: TJclWideStrObjMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -24902,7 +31462,7 @@ procedure TJclWideStrSortedMap.InitializeArray(var List: TJclWideStrSortedMapEnt {$ENDIF ~FPC} end; -procedure TJclWideStrSortedMap.InitializeArrayAfterMove(var List: TJclWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclWideStrSortedMap.InitializeArrayAfterMove(var List: TJclWideStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -24921,7 +31481,7 @@ procedure TJclWideStrSortedMap.InitializeArrayAfterMove(var List: TJclWideStrSor end; end; -procedure TJclWideStrSortedMap.MoveArray(var List: TJclWideStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclWideStrSortedMap.MoveArray(var List: TJclWideStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -25179,37 +31739,191 @@ function TJclWideStrSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; -{$IFDEF SUPPORTS_UNICODE_STRING} -//=== { TJclUnicodeStrSortedMap } ============================================== +//=== { TJclWideStrObjSortedMapIterator } =============================================================== -constructor TJclUnicodeStrSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); +constructor TJclWideStrObjSortedMapIterator.Create(AOwnMap: TJclWideStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - FOwnsValues := AOwnsValues; - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclUnicodeStrSortedMap.Destroy; +function TJclWideStrObjSortedMapIterator.Add(const AEntry: TJclWideStrObjMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclUnicodeStrSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclWideStrObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclUnicodeStrSortedMap; - Index: Integer; + ADest: TJclWideStrObjSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclUnicodeStrSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclWideStrObjSortedMapIterator then begin - MyDest := TJclUnicodeStrSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); - for Index := 0 to FSize - 1 do - MyDest.FEntries[Index] := FEntries[Index]; - MyDest.FSize := FSize; + ADest := TJclWideStrObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclWideStrObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclWideStrObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclWideStrObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclWideStrObjSortedMapIterator.GetEntry: TJclWideStrObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclWideStrObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclWideStrObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclWideStrObjSortedMapIterator.Insert(const AEntry: TJclWideStrObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclWideStrObjSortedMapIterator.IteratorEquals(const AIterator: IJclWideStrObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclWideStrObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclWideStrObjSortedMapIterator then + begin + ItrObj := TJclWideStrObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclWideStrObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclWideStrObjSortedMapIterator.Next: TJclWideStrObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclWideStrObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclWideStrObjSortedMapIterator.Previous: TJclWideStrObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclWideStrObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclWideStrObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclWideStrObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclWideStrObjSortedMapIterator.SetEntry(const AEntry: TJclWideStrObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +{$IFDEF SUPPORTS_UNICODE_STRING} +//=== { TJclUnicodeStrSortedMap } ============================================== + +constructor TJclUnicodeStrSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); +begin + inherited Create(); + FOwnsValues := AOwnsValues; + SetCapacity(ACapacity); +end; + +destructor TJclUnicodeStrSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclUnicodeStrSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclUnicodeStrSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclUnicodeStrSortedMap then + begin + MyDest := TJclUnicodeStrSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); + for Index := 0 to FSize - 1 do + MyDest.FEntries[Index] := FEntries[Index]; + MyDest.FSize := FSize; end; end; @@ -25372,6 +32086,13 @@ function TJclUnicodeStrSortedMap.Extract(const Key: UnicodeString): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclUnicodeStrSortedMap.GetEnumerator: IJclUnicodeStrObjSortedMapIterator; +begin + Result := TJclUnicodeStrObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclUnicodeStrSortedMap.GetValue(const Key: UnicodeString): TObject; var Index: Integer; @@ -25546,7 +32267,7 @@ function TJclUnicodeStrSortedMap.MapEquals(const AMap: IJclUnicodeStrMap): Boole {$ENDIF THREADSAFE} end; -procedure TJclUnicodeStrSortedMap.FinalizeArrayBeforeMove(var List: TJclUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclUnicodeStrSortedMap.FinalizeArrayBeforeMove(var List: TJclUnicodeStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin Assert(Count > 0); if FromIndex < ToIndex then @@ -25565,7 +32286,7 @@ procedure TJclUnicodeStrSortedMap.FinalizeArrayBeforeMove(var List: TJclUnicodeS end; end; -procedure TJclUnicodeStrSortedMap.InitializeArray(var List: TJclUnicodeStrSortedMapEntryArray; FromIndex, Count: SizeInt); +procedure TJclUnicodeStrSortedMap.InitializeArray(var List: TJclUnicodeStrObjMapEntryArray; FromIndex, Count: SizeInt); begin {$IFDEF FPC} while Count > 0 do @@ -25579,7 +32300,7 @@ procedure TJclUnicodeStrSortedMap.InitializeArray(var List: TJclUnicodeStrSorted {$ENDIF ~FPC} end; -procedure TJclUnicodeStrSortedMap.InitializeArrayAfterMove(var List: TJclUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclUnicodeStrSortedMap.InitializeArrayAfterMove(var List: TJclUnicodeStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Keep reference counting working } if FromIndex < ToIndex then @@ -25598,7 +32319,7 @@ procedure TJclUnicodeStrSortedMap.InitializeArrayAfterMove(var List: TJclUnicode end; end; -procedure TJclUnicodeStrSortedMap.MoveArray(var List: TJclUnicodeStrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclUnicodeStrSortedMap.MoveArray(var List: TJclUnicodeStrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -25858,6 +32579,162 @@ function TJclUnicodeStrSortedMap.ValuesCompare(A, B: TObject): Integer; {$ENDIF SUPPORTS_UNICODE_STRING} +{$IFDEF SUPPORTS_UNICODE_STRING} +//=== { TJclUnicodeStrObjSortedMapIterator } =============================================================== + +constructor TJclUnicodeStrObjSortedMapIterator.Create(AOwnMap: TJclUnicodeStrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclUnicodeStrObjSortedMapIterator.Add(const AEntry: TJclUnicodeStrObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclUnicodeStrObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclUnicodeStrObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclUnicodeStrObjSortedMapIterator then + begin + ADest := TJclUnicodeStrObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclUnicodeStrObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclUnicodeStrObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclUnicodeStrObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclUnicodeStrObjSortedMapIterator.GetEntry: TJclUnicodeStrObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclUnicodeStrObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclUnicodeStrObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclUnicodeStrObjSortedMapIterator.Insert(const AEntry: TJclUnicodeStrObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclUnicodeStrObjSortedMapIterator.IteratorEquals(const AIterator: IJclUnicodeStrObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclUnicodeStrObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclUnicodeStrObjSortedMapIterator then + begin + ItrObj := TJclUnicodeStrObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclUnicodeStrObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclUnicodeStrObjSortedMapIterator.Next: TJclUnicodeStrObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclUnicodeStrObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclUnicodeStrObjSortedMapIterator.Previous: TJclUnicodeStrObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclUnicodeStrObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclUnicodeStrObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclUnicodeStrObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclUnicodeStrObjSortedMapIterator.SetEntry(const AEntry: TJclUnicodeStrObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +{$ENDIF SUPPORTS_UNICODE_STRING} //=== { TJclSingleSortedMap } ============================================== constructor TJclSingleSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); @@ -26050,6 +32927,13 @@ function TJclSingleSortedMap.Extract(const Key: Single): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclSingleSortedMap.GetEnumerator: IJclSingleObjSortedMapIterator; +begin + Result := TJclSingleObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclSingleSortedMap.GetValue(const Key: Single): TObject; var Index: Integer; @@ -26224,7 +33108,7 @@ function TJclSingleSortedMap.MapEquals(const AMap: IJclSingleMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclSingleSortedMap.InitializeArrayAfterMove(var List: TJclSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSingleSortedMap.InitializeArrayAfterMove(var List: TJclSingleObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -26243,7 +33127,7 @@ procedure TJclSingleSortedMap.InitializeArrayAfterMove(var List: TJclSingleSorte end; end; -procedure TJclSingleSortedMap.MoveArray(var List: TJclSingleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSingleSortedMap.MoveArray(var List: TJclSingleObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -26500,6 +33384,160 @@ function TJclSingleSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; +//=== { TJclSingleObjSortedMapIterator } =============================================================== + +constructor TJclSingleObjSortedMapIterator.Create(AOwnMap: TJclSingleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclSingleObjSortedMapIterator.Add(const AEntry: TJclSingleObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclSingleObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclSingleObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclSingleObjSortedMapIterator then + begin + ADest := TJclSingleObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclSingleObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclSingleObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclSingleObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclSingleObjSortedMapIterator.GetEntry: TJclSingleObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSingleObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclSingleObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclSingleObjSortedMapIterator.Insert(const AEntry: TJclSingleObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclSingleObjSortedMapIterator.IteratorEquals(const AIterator: IJclSingleObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclSingleObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclSingleObjSortedMapIterator then + begin + ItrObj := TJclSingleObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclSingleObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclSingleObjSortedMapIterator.Next: TJclSingleObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSingleObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclSingleObjSortedMapIterator.Previous: TJclSingleObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSingleObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclSingleObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclSingleObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclSingleObjSortedMapIterator.SetEntry(const AEntry: TJclSingleObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclDoubleSortedMap } ============================================== constructor TJclDoubleSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); @@ -26692,6 +33730,13 @@ function TJclDoubleSortedMap.Extract(const Key: Double): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclDoubleSortedMap.GetEnumerator: IJclDoubleObjSortedMapIterator; +begin + Result := TJclDoubleObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclDoubleSortedMap.GetValue(const Key: Double): TObject; var Index: Integer; @@ -26866,7 +33911,7 @@ function TJclDoubleSortedMap.MapEquals(const AMap: IJclDoubleMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclDoubleSortedMap.InitializeArrayAfterMove(var List: TJclDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclDoubleSortedMap.InitializeArrayAfterMove(var List: TJclDoubleObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -26885,7 +33930,7 @@ procedure TJclDoubleSortedMap.InitializeArrayAfterMove(var List: TJclDoubleSorte end; end; -procedure TJclDoubleSortedMap.MoveArray(var List: TJclDoubleSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclDoubleSortedMap.MoveArray(var List: TJclDoubleObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -27142,33 +34187,187 @@ function TJclDoubleSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; -//=== { TJclExtendedSortedMap } ============================================== +//=== { TJclDoubleObjSortedMapIterator } =============================================================== -constructor TJclExtendedSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); +constructor TJclDoubleObjSortedMapIterator.Create(AOwnMap: TJclDoubleSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); begin - inherited Create(); - FOwnsValues := AOwnsValues; - SetCapacity(ACapacity); + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; end; -destructor TJclExtendedSortedMap.Destroy; +function TJclDoubleObjSortedMapIterator.Add(const AEntry: TJclDoubleObjMapEntry): Boolean; begin - FReadOnly := False; - Clear; - inherited Destroy; + raise EJclOperationNotSupportedError.Create; end; -procedure TJclExtendedSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +procedure TJclDoubleObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); var - MyDest: TJclExtendedSortedMap; - Index: Integer; + ADest: TJclDoubleObjSortedMapIterator; begin - inherited AssignDataTo(Dest); - if Dest is TJclExtendedSortedMap then + inherited AssignPropertiesTo(Dest); + if Dest is TJclDoubleObjSortedMapIterator then begin - MyDest := TJclExtendedSortedMap(Dest); - MyDest.Clear; - MyDest.SetCapacity(FSize); + ADest := TJclDoubleObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclDoubleObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclDoubleObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclDoubleObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclDoubleObjSortedMapIterator.GetEntry: TJclDoubleObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclDoubleObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclDoubleObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclDoubleObjSortedMapIterator.Insert(const AEntry: TJclDoubleObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclDoubleObjSortedMapIterator.IteratorEquals(const AIterator: IJclDoubleObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclDoubleObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclDoubleObjSortedMapIterator then + begin + ItrObj := TJclDoubleObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclDoubleObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclDoubleObjSortedMapIterator.Next: TJclDoubleObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclDoubleObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclDoubleObjSortedMapIterator.Previous: TJclDoubleObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclDoubleObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclDoubleObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclDoubleObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclDoubleObjSortedMapIterator.SetEntry(const AEntry: TJclDoubleObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; +//=== { TJclExtendedSortedMap } ============================================== + +constructor TJclExtendedSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); +begin + inherited Create(); + FOwnsValues := AOwnsValues; + SetCapacity(ACapacity); +end; + +destructor TJclExtendedSortedMap.Destroy; +begin + FReadOnly := False; + Clear; + inherited Destroy; +end; + +procedure TJclExtendedSortedMap.AssignDataTo(Dest: TJclAbstractContainerBase); +var + MyDest: TJclExtendedSortedMap; + Index: Integer; +begin + inherited AssignDataTo(Dest); + if Dest is TJclExtendedSortedMap then + begin + MyDest := TJclExtendedSortedMap(Dest); + MyDest.Clear; + MyDest.SetCapacity(FSize); for Index := 0 to FSize - 1 do MyDest.FEntries[Index] := FEntries[Index]; MyDest.FSize := FSize; @@ -27334,6 +34533,13 @@ function TJclExtendedSortedMap.Extract(const Key: Extended): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclExtendedSortedMap.GetEnumerator: IJclExtendedObjSortedMapIterator; +begin + Result := TJclExtendedObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclExtendedSortedMap.GetValue(const Key: Extended): TObject; var Index: Integer; @@ -27508,7 +34714,7 @@ function TJclExtendedSortedMap.MapEquals(const AMap: IJclExtendedMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclExtendedSortedMap.InitializeArrayAfterMove(var List: TJclExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclExtendedSortedMap.InitializeArrayAfterMove(var List: TJclExtendedObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -27527,7 +34733,7 @@ procedure TJclExtendedSortedMap.InitializeArrayAfterMove(var List: TJclExtendedS end; end; -procedure TJclExtendedSortedMap.MoveArray(var List: TJclExtendedSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclExtendedSortedMap.MoveArray(var List: TJclExtendedObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -27784,6 +34990,160 @@ function TJclExtendedSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; +//=== { TJclExtendedObjSortedMapIterator } =============================================================== + +constructor TJclExtendedObjSortedMapIterator.Create(AOwnMap: TJclExtendedSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclExtendedObjSortedMapIterator.Add(const AEntry: TJclExtendedObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclExtendedObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclExtendedObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclExtendedObjSortedMapIterator then + begin + ADest := TJclExtendedObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclExtendedObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclExtendedObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclExtendedObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclExtendedObjSortedMapIterator.GetEntry: TJclExtendedObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclExtendedObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclExtendedObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclExtendedObjSortedMapIterator.Insert(const AEntry: TJclExtendedObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclExtendedObjSortedMapIterator.IteratorEquals(const AIterator: IJclExtendedObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclExtendedObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclExtendedObjSortedMapIterator then + begin + ItrObj := TJclExtendedObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclExtendedObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclExtendedObjSortedMapIterator.Next: TJclExtendedObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclExtendedObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclExtendedObjSortedMapIterator.Previous: TJclExtendedObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclExtendedObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclExtendedObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclExtendedObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclExtendedObjSortedMapIterator.SetEntry(const AEntry: TJclExtendedObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclIntegerSortedMap } ============================================== constructor TJclIntegerSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); @@ -27976,6 +35336,13 @@ function TJclIntegerSortedMap.Extract(Key: Integer): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntegerSortedMap.GetEnumerator: IJclIntegerObjSortedMapIterator; +begin + Result := TJclIntegerObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclIntegerSortedMap.GetValue(Key: Integer): TObject; var Index: Integer; @@ -28150,7 +35517,7 @@ function TJclIntegerSortedMap.MapEquals(const AMap: IJclIntegerMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclIntegerSortedMap.InitializeArrayAfterMove(var List: TJclIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntegerSortedMap.InitializeArrayAfterMove(var List: TJclIntegerObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -28169,7 +35536,7 @@ procedure TJclIntegerSortedMap.InitializeArrayAfterMove(var List: TJclIntegerSor end; end; -procedure TJclIntegerSortedMap.MoveArray(var List: TJclIntegerSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclIntegerSortedMap.MoveArray(var List: TJclIntegerObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -28426,6 +35793,160 @@ function TJclIntegerSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; +//=== { TJclIntegerObjSortedMapIterator } =============================================================== + +constructor TJclIntegerObjSortedMapIterator.Create(AOwnMap: TJclIntegerSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclIntegerObjSortedMapIterator.Add(const AEntry: TJclIntegerObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclIntegerObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclIntegerObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclIntegerObjSortedMapIterator then + begin + ADest := TJclIntegerObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclIntegerObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclIntegerObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclIntegerObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclIntegerObjSortedMapIterator.GetEntry: TJclIntegerObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntegerObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclIntegerObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclIntegerObjSortedMapIterator.Insert(const AEntry: TJclIntegerObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclIntegerObjSortedMapIterator.IteratorEquals(const AIterator: IJclIntegerObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclIntegerObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclIntegerObjSortedMapIterator then + begin + ItrObj := TJclIntegerObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclIntegerObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclIntegerObjSortedMapIterator.Next: TJclIntegerObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntegerObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclIntegerObjSortedMapIterator.Previous: TJclIntegerObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclIntegerObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclIntegerObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclIntegerObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclIntegerObjSortedMapIterator.SetEntry(const AEntry: TJclIntegerObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclCardinalSortedMap } ============================================== constructor TJclCardinalSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); @@ -28618,6 +36139,13 @@ function TJclCardinalSortedMap.Extract(Key: Cardinal): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclCardinalSortedMap.GetEnumerator: IJclCardinalObjSortedMapIterator; +begin + Result := TJclCardinalObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclCardinalSortedMap.GetValue(Key: Cardinal): TObject; var Index: Integer; @@ -28792,7 +36320,7 @@ function TJclCardinalSortedMap.MapEquals(const AMap: IJclCardinalMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclCardinalSortedMap.InitializeArrayAfterMove(var List: TJclCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclCardinalSortedMap.InitializeArrayAfterMove(var List: TJclCardinalObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -28811,7 +36339,7 @@ procedure TJclCardinalSortedMap.InitializeArrayAfterMove(var List: TJclCardinalS end; end; -procedure TJclCardinalSortedMap.MoveArray(var List: TJclCardinalSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclCardinalSortedMap.MoveArray(var List: TJclCardinalObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -29068,6 +36596,160 @@ function TJclCardinalSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; +//=== { TJclCardinalObjSortedMapIterator } =============================================================== + +constructor TJclCardinalObjSortedMapIterator.Create(AOwnMap: TJclCardinalSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclCardinalObjSortedMapIterator.Add(const AEntry: TJclCardinalObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclCardinalObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclCardinalObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclCardinalObjSortedMapIterator then + begin + ADest := TJclCardinalObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclCardinalObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclCardinalObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclCardinalObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclCardinalObjSortedMapIterator.GetEntry: TJclCardinalObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclCardinalObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclCardinalObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclCardinalObjSortedMapIterator.Insert(const AEntry: TJclCardinalObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclCardinalObjSortedMapIterator.IteratorEquals(const AIterator: IJclCardinalObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclCardinalObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclCardinalObjSortedMapIterator then + begin + ItrObj := TJclCardinalObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclCardinalObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclCardinalObjSortedMapIterator.Next: TJclCardinalObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclCardinalObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclCardinalObjSortedMapIterator.Previous: TJclCardinalObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclCardinalObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclCardinalObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclCardinalObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclCardinalObjSortedMapIterator.SetEntry(const AEntry: TJclCardinalObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclInt64SortedMap } ============================================== constructor TJclInt64SortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); @@ -29260,6 +36942,13 @@ function TJclInt64SortedMap.Extract(const Key: Int64): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclInt64SortedMap.GetEnumerator: IJclInt64ObjSortedMapIterator; +begin + Result := TJclInt64ObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclInt64SortedMap.GetValue(const Key: Int64): TObject; var Index: Integer; @@ -29434,7 +37123,7 @@ function TJclInt64SortedMap.MapEquals(const AMap: IJclInt64Map): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclInt64SortedMap.InitializeArrayAfterMove(var List: TJclInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclInt64SortedMap.InitializeArrayAfterMove(var List: TJclInt64ObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -29453,7 +37142,7 @@ procedure TJclInt64SortedMap.InitializeArrayAfterMove(var List: TJclInt64SortedM end; end; -procedure TJclInt64SortedMap.MoveArray(var List: TJclInt64SortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclInt64SortedMap.MoveArray(var List: TJclInt64ObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -29666,50 +37355,204 @@ function TJclInt64SortedMap.Values: IJclCollection; if FThreadSafe then SyncReaderWriter.EndRead; end; - {$ENDIF THREADSAFE} + {$ENDIF THREADSAFE} +end; + +function TJclInt64SortedMap.CreateEmptyContainer: TJclAbstractContainerBase; +begin + Result := TJclInt64SortedMap.Create(FSize, False); + AssignPropertiesTo(Result); +end; + +function TJclInt64SortedMap.FreeKey(var Key: Int64): Int64; +begin + Result := Key; + Key := 0; +end; + +function TJclInt64SortedMap.FreeValue(var Value: TObject): TObject; +begin + if FOwnsValues then + begin + Result := nil; + FreeAndNil(Value); + end + else + begin + Result := Value; + Value := nil; + end; +end; + +function TJclInt64SortedMap.GetOwnsValues: Boolean; +begin + Result := FOwnsValues; +end; + +function TJclInt64SortedMap.KeysCompare(const A, B: Int64): Integer; +begin + Result := ItemsCompare(A, B); +end; + +function TJclInt64SortedMap.ValuesCompare(A, B: TObject): Integer; +begin + Result := SimpleCompare(A, B); +end; + +//=== { TJclInt64ObjSortedMapIterator } =============================================================== + +constructor TJclInt64ObjSortedMapIterator.Create(AOwnMap: TJclInt64SortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclInt64ObjSortedMapIterator.Add(const AEntry: TJclInt64ObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclInt64ObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclInt64ObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclInt64ObjSortedMapIterator then + begin + ADest := TJclInt64ObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclInt64ObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclInt64ObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclInt64ObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclInt64ObjSortedMapIterator.GetEntry: TJclInt64ObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclInt64ObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclInt64ObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclInt64ObjSortedMapIterator.Insert(const AEntry: TJclInt64ObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclInt64ObjSortedMapIterator.IteratorEquals(const AIterator: IJclInt64ObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclInt64ObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclInt64ObjSortedMapIterator then + begin + ItrObj := TJclInt64ObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; end; -function TJclInt64SortedMap.CreateEmptyContainer: TJclAbstractContainerBase; +{$IFDEF SUPPORTS_FOR_IN} +function TJclInt64ObjSortedMapIterator.MoveNext: Boolean; begin - Result := TJclInt64SortedMap.Create(FSize, False); - AssignPropertiesTo(Result); + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; end; +{$ENDIF SUPPORTS_FOR_IN} -function TJclInt64SortedMap.FreeKey(var Key: Int64): Int64; +function TJclInt64ObjSortedMapIterator.Next: TJclInt64ObjMapEntry; begin - Result := Key; - Key := 0; + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; end; -function TJclInt64SortedMap.FreeValue(var Value: TObject): TObject; +function TJclInt64ObjSortedMapIterator.NextIndex: Integer; begin - if FOwnsValues then - begin - Result := nil; - FreeAndNil(Value); - end + if Valid then + Result := FCursor + 1 else - begin - Result := Value; - Value := nil; - end; + Result := FCursor; end; -function TJclInt64SortedMap.GetOwnsValues: Boolean; +function TJclInt64ObjSortedMapIterator.Previous: TJclInt64ObjMapEntry; begin - Result := FOwnsValues; + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; end; -function TJclInt64SortedMap.KeysCompare(const A, B: Int64): Integer; +function TJclInt64ObjSortedMapIterator.PreviousIndex: Integer; begin - Result := ItemsCompare(A, B); + if Valid then + Result := FCursor - 1 + else + Result := FCursor; end; -function TJclInt64SortedMap.ValuesCompare(A, B: TObject): Integer; +procedure TJclInt64ObjSortedMapIterator.Remove; begin - Result := SimpleCompare(A, B); + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclInt64ObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; end; +procedure TJclInt64ObjSortedMapIterator.SetEntry(const AEntry: TJclInt64ObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclPtrSortedMap } ============================================== constructor TJclPtrSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean); @@ -29902,6 +37745,13 @@ function TJclPtrSortedMap.Extract(Key: Pointer): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclPtrSortedMap.GetEnumerator: IJclPtrObjSortedMapIterator; +begin + Result := TJclPtrObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclPtrSortedMap.GetValue(Key: Pointer): TObject; var Index: Integer; @@ -30076,7 +37926,7 @@ function TJclPtrSortedMap.MapEquals(const AMap: IJclPtrMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclPtrSortedMap.InitializeArrayAfterMove(var List: TJclPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclPtrSortedMap.InitializeArrayAfterMove(var List: TJclPtrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -30095,7 +37945,7 @@ procedure TJclPtrSortedMap.InitializeArrayAfterMove(var List: TJclPtrSortedMapEn end; end; -procedure TJclPtrSortedMap.MoveArray(var List: TJclPtrSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclPtrSortedMap.MoveArray(var List: TJclPtrObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -30352,6 +38202,160 @@ function TJclPtrSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; +//=== { TJclPtrObjSortedMapIterator } =============================================================== + +constructor TJclPtrObjSortedMapIterator.Create(AOwnMap: TJclPtrSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclPtrObjSortedMapIterator.Add(const AEntry: TJclPtrObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclPtrObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclPtrObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclPtrObjSortedMapIterator then + begin + ADest := TJclPtrObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclPtrObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclPtrObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclPtrObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclPtrObjSortedMapIterator.GetEntry: TJclPtrObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclPtrObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclPtrObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclPtrObjSortedMapIterator.Insert(const AEntry: TJclPtrObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclPtrObjSortedMapIterator.IteratorEquals(const AIterator: IJclPtrObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclPtrObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclPtrObjSortedMapIterator then + begin + ItrObj := TJclPtrObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclPtrObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclPtrObjSortedMapIterator.Next: TJclPtrObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclPtrObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclPtrObjSortedMapIterator.Previous: TJclPtrObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclPtrObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclPtrObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclPtrObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclPtrObjSortedMapIterator.SetEntry(const AEntry: TJclPtrObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; //=== { TJclSortedMap } ============================================== constructor TJclSortedMap.Create(ACapacity: Integer; AOwnsValues: Boolean; AOwnsKeys: Boolean); @@ -30545,6 +38549,13 @@ function TJclSortedMap.Extract(Key: TObject): TObject; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclSortedMap.GetEnumerator: IJclObjObjSortedMapIterator; +begin + Result := TJclObjObjSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclSortedMap.GetValue(Key: TObject): TObject; var Index: Integer; @@ -30719,7 +38730,7 @@ function TJclSortedMap.MapEquals(const AMap: IJclMap): Boolean; {$ENDIF THREADSAFE} end; -procedure TJclSortedMap.InitializeArrayAfterMove(var List: TJclSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSortedMap.InitializeArrayAfterMove(var List: TJclObjObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin { Clean array } if FromIndex < ToIndex then @@ -30738,7 +38749,7 @@ procedure TJclSortedMap.InitializeArrayAfterMove(var List: TJclSortedMapEntryArr end; end; -procedure TJclSortedMap.MoveArray(var List: TJclSortedMapEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSortedMap.MoveArray(var List: TJclObjObjMapEntryArray; FromIndex, ToIndex, Count: SizeInt); begin if Count > 0 then begin @@ -31008,6 +39019,160 @@ function TJclSortedMap.ValuesCompare(A, B: TObject): Integer; Result := SimpleCompare(A, B); end; +//=== { TJclObjObjSortedMapIterator } =============================================================== + +constructor TJclObjObjSortedMapIterator.Create(AOwnMap: TJclSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclObjObjSortedMapIterator.Add(const AEntry: TJclObjObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclObjObjSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclObjObjSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclObjObjSortedMapIterator then + begin + ADest := TJclObjObjSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclObjObjSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclObjObjSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclObjObjSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclObjObjSortedMapIterator.GetEntry: TJclObjObjMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclObjObjSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclObjObjSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclObjObjSortedMapIterator.Insert(const AEntry: TJclObjObjMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclObjObjSortedMapIterator.IteratorEquals(const AIterator: IJclObjObjSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclObjObjSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclObjObjSortedMapIterator then + begin + ItrObj := TJclObjObjSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclObjObjSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclObjObjSortedMapIterator.Next: TJclObjObjMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclObjObjSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclObjObjSortedMapIterator.Previous: TJclObjObjMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclObjObjSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclObjObjSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclObjObjSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclObjObjSortedMapIterator.SetEntry(const AEntry: TJclObjObjMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; {$IFDEF SUPPORTS_GENERICS} @@ -31207,6 +39372,13 @@ function TJclSortedMap.Extract(const Key: TKey): TValue; {$ENDIF THREADSAFE} end; +{$IFDEF SUPPORTS_FOR_IN} +function TJclSortedMap.GetEnumerator: IJclSortedMapIterator; +begin + Result := TJclSortedMapIterator.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function TJclSortedMap.GetValue(const Key: TKey): TValue; var Index: Integer; @@ -31381,7 +39553,7 @@ function TJclSortedMap.MapEquals(const AMap: IJclMap): {$ENDIF THREADSAFE} end; -procedure TJclSortedMap.MoveArray(var List: TSortedEntryArray; FromIndex, ToIndex, Count: SizeInt); +procedure TJclSortedMap.MoveArray(var List: TMapEntryArray; FromIndex, ToIndex, Count: SizeInt); var I: SizeInt; begin @@ -31393,11 +39565,11 @@ procedure TJclSortedMap.MoveArray(var List: TSortedEntryArray; From if (ToIndex - FromIndex) < Count then // overlapped source and target for I := 0 to ToIndex - FromIndex - 1 do - List[FromIndex + I] := Default(TSortedEntry) + List[FromIndex + I] := Default(TMapEntry) else // independant for I := 0 to Count - 1 do - List[FromIndex + I] := Default(TSortedEntry); + List[FromIndex + I] := Default(TMapEntry); end else begin @@ -31407,11 +39579,11 @@ procedure TJclSortedMap.MoveArray(var List: TSortedEntryArray; From if (FromIndex - ToIndex) < Count then // overlapped source and target for I := Count - FromIndex + ToIndex to Count - 1 do - List[FromIndex + I] := Default(TSortedEntry) + List[FromIndex + I] := Default(TMapEntry) else // independant for I := 0 to Count - 1 do - List[FromIndex + I] := Default(TSortedEntry); + List[FromIndex + I] := Default(TMapEntry); end; end; @@ -31660,6 +39832,161 @@ function TJclSortedMap.GetOwnsValues: Boolean; Result := FOwnsValues; end; +//=== { TJclSortedMapIterator } =============================================================== + +constructor TJclSortedMapIterator.Create(AOwnMap: TJclSortedMap; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function TJclSortedMapIterator.Add(const AEntry: TJclMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure TJclSortedMapIterator.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: TJclSortedMapIterator; +begin + inherited AssignPropertiesTo(Dest); + if Dest is TJclSortedMapIterator then + begin + ADest := TJclSortedMapIterator(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function TJclSortedMapIterator.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := TJclSortedMapIterator.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure TJclSortedMapIterator.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function TJclSortedMapIterator.GetEntry: TJclMapEntry; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSortedMapIterator.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function TJclSortedMapIterator.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function TJclSortedMapIterator.Insert(const AEntry: TJclMapEntry): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function TJclSortedMapIterator.IteratorEquals(const AIterator: IJclSortedMapIterator): Boolean; +var + Obj: TObject; + ItrObj: TJclSortedMapIterator; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is TJclSortedMapIterator then + begin + ItrObj := TJclSortedMapIterator(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function TJclSortedMapIterator.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function TJclSortedMapIterator.Next: TJclMapEntry; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSortedMapIterator.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function TJclSortedMapIterator.Previous: TJclMapEntry; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function TJclSortedMapIterator.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure TJclSortedMapIterator.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure TJclSortedMapIterator.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure TJclSortedMapIterator.SetEntry(const AEntry: TJclMapEntry); +begin + raise EJclOperationNotSupportedError.Create; +end; + //=== { TJclSortedMapE } ======================================= constructor TJclSortedMapE.Create(const AKeyComparer: IJclComparer; diff --git a/jcl/source/prototypes/JclContainerIntf.pas b/jcl/source/prototypes/JclContainerIntf.pas index 39f408038f..68d2dfd38d 100644 --- a/jcl/source/prototypes/JclContainerIntf.pas +++ b/jcl/source/prototypes/JclContainerIntf.pas @@ -119,6 +119,17 @@ interface //DOM-IGNORE-END {$ENDIF SUPPORTS_GENERICS} + // map entry types +(*$JPPLOOP ALLMAPINDEX ALLMAPCOUNT + {$JPPEXPANDMACRO JCLSORTEDMAPTYPESINT(,,,)} + +*) + {$IFDEF SUPPORTS_GENERICS} + //DOM-IGNORE-BEGIN + (*$JPPEXPANDMACRO JCLSORTEDMAPTYPESINT(TJclMapEntry,TJclMapEntryArray,TKey,TValue)*) + //DOM-IGNORE-END + {$ENDIF SUPPORTS_GENERICS} + IJclLockable = interface ['{524AD65E-AE1B-4BC6-91C8-8181F0198BA9}'] procedure ReadLock; @@ -471,6 +482,16 @@ interface //DOM-IGNORE-END {$ENDIF SUPPORTS_GENERICS} +(*$JPPLOOP ALLMAPINDEX ALLMAPCOUNT + {$JPPEXPANDMACRO SORTEDMAPENTRYITERATOR(,,,)} + +*) + {$IFDEF SUPPORTS_GENERICS} + //DOM-IGNORE-BEGIN + (*$JPPEXPANDMACRO SORTEDMAPENTRYITERATOR(IJclSortedMapIterator,IJclAbstractIterator,{570920D8-05ED-4CA5-8355-6A899555EBC0},TJclMapEntry)*) + //DOM-IGNORE-END + {$ENDIF SUPPORTS_GENERICS} + (*$JPPLOOP ALLTYPEINDEX ALLTYPECOUNT {$JPPEXPANDMACRO COLLECTION(,,,,,,)} diff --git a/jcl/source/prototypes/JclSortedMaps.pas b/jcl/source/prototypes/JclSortedMaps.pas index ba6136f97b..db47c8c61c 100644 --- a/jcl/source/prototypes/JclSortedMaps.pas +++ b/jcl/source/prototypes/JclSortedMaps.pas @@ -55,25 +55,20 @@ interface {$I containers\JclAlgorithms.imp} type (*$JPPLOOP ALLMAPINDEX ALLMAPCOUNT - {$JPPEXPANDMACRO JCLSORTEDMAPTYPESINT(,,,)} + {$JPPEXPANDMACRO JCLSORTEDMAPINT(,,,,,,,,,,,,,,,,)} - {$JPPEXPANDMACRO JCLSORTEDMAPINT(,,,,,,,,,,,,,,,)} + {$JPPEXPANDMACRO JCLSORTEDMAPITRINT(,,,)} *) {$IFDEF SUPPORTS_GENERICS}{$JPPDEFINE KEYGENERIC}{$JPPDEFINE VALUEGENERIC}{$JPPUNDEF KEYREFCOUNTED}{$JPPUNDEF VALUEREFCOUNTED}{$JPPUNDEF KEYZEROINIT}{$JPPUNDEF VALUEZEROINIT} //DOM-IGNORE-BEGIN - TJclSortedEntry = record - Key: TKey; - Value: TValue; - end; - - (*$JPPEXPANDMACRO JCLSORTEDMAPINT(TSortedEntry,TSortedEntryArray,TJclSortedMap,TJclAbstractContainerBase,IJclMap,IJclSortedMap,IJclSet,IJclCollection, IJclPairOwner\,, + (*$JPPEXPANDMACRO JCLSORTEDMAPINT(TMapEntry,TMapEntryArray,TJclSortedMap,TJclAbstractContainerBase,IJclMap,IJclSortedMap,IJclSortedMapIterator,IJclSet,IJclCollection, IJclPairOwner\,, protected type - TSortedEntry = TJclSortedEntry; - TSortedEntryArray = array of TSortedEntry; + TMapEntry = TJclMapEntry; + TMapEntryArray = array of TMapEntry; private FOwnsKeys: Boolean; FOwnsValues: Boolean; @@ -91,6 +86,8 @@ TJclSortedEntry = record property OwnsKeys: Boolean read FOwnsKeys; property OwnsValues: Boolean read FOwnsValues;,; AOwnsKeys: Boolean,; AOwnsValues: Boolean,const ,TKey,const ,TValue)*) + {$JPPEXPANDMACRO JCLSORTEDMAPITRINT(TJclSortedMapIterator,IJclSortedMapIterator,TJclSortedMap,TJclMapEntry)} + // E = external helper to compare items TJclSortedMapE = class(TJclSortedMap, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} IJclIntfCloneable, IJclCloneable, IJclPackable, IJclBaseContainer, IJclMap, IJclSortedMap, IJclPairOwner) @@ -201,14 +198,15 @@ implementation {$ENDIF ~HAS_UNITSCOPE} (*$JPPLOOP TRUEMAPINDEX TRUEMAPCOUNT -{$JPPEXPANDMACRO JCLSORTEDMAPIMP(,,,,,,,,,,,,,,,,,,)} +{$JPPEXPANDMACRO JCLSORTEDMAPIMP(,,,,,,,,,,,,,,,,,,,,)} +{$JPPEXPANDMACRO JCLSORTEDMAPITRIMP(,,,)} *) {$IFDEF SUPPORTS_GENERICS}{$JPPDEFINE KEYGENERIC}{$JPPDEFINE VALUEGENERIC}{$JPPUNDEF KEYREFCOUNTED}{$JPPUNDEF VALUEREFCOUNTED}{$JPPUNDEF KEYZEROINIT}{$JPPUNDEF VALUEZEROINIT} //DOM-IGNORE-BEGIN -(*$JPPEXPANDMACRO JCLSORTEDMAPIMP(TSortedEntry,TSortedEntryArray,TJclSortedMap,IJclMap,IJclSortedMap,IJclSet,IJclIterator,IJclCollection,; AOwnsKeys: Boolean,; AOwnsValues: Boolean, +(*$JPPEXPANDMACRO JCLSORTEDMAPIMP(TMapEntry,TMapEntryArray,TJclSortedMap,IJclMap,IJclSortedMap,IJclSortedMapIterator,TJclSortedMapIterator,IJclSet,IJclIterator,IJclCollection,; AOwnsKeys: Boolean,; AOwnsValues: Boolean, FOwnsKeys := AOwnsKeys; FOwnsValues := AOwnsValues;,const ,TKey,Default(TKey),const ,TValue,Default(TValue),CreateEmptyArraySet(FSize, False),CreateEmptyArrayList(FSize, False))*) @@ -251,6 +249,8 @@ function TJclSortedMap.GetOwnsValues: Boolean; Result := FOwnsValues; end; +{$JPPEXPANDMACRO JCLSORTEDMAPITRIMP(TJclSortedMapIterator,IJclSortedMapIterator,TJclSortedMap,TJclMapEntry)} + //=== { TJclSortedMapE } ======================================= constructor TJclSortedMapE.Create(const AKeyComparer: IJclComparer; diff --git a/jcl/source/prototypes/containers/JclContainerIntf.int b/jcl/source/prototypes/containers/JclContainerIntf.int index aa219a0ead..9847b4e3d4 100644 --- a/jcl/source/prototypes/containers/JclContainerIntf.int +++ b/jcl/source/prototypes/containers/JclContainerIntf.int @@ -10,6 +10,13 @@ EQUALITYCOMPAREFUNCTIONTYPENAME = function(CONSTKEYWORDObj1, Obj2: TYPENAME): Bo HASHCONVERTFUNCTIONTYPENAME = function(CONSTKEYWORDPARAMETERNAME: TYPENAME): Integer;*) (*$JPPDEFINEMACRO SORTPROC(SORTPROCEDURETYPENAME, LISTINTERFACENAME, COMPAREFUNCTIONTYPENAME) SORTPROCEDURETYPENAME = procedure(const AList: LISTINTERFACENAME; L, R: Integer; AComparator: COMPAREFUNCTIONTYPENAME);*) +(*$JPPDEFINEMACRO JCLSORTEDMAPTYPESINT(ENTRYTYPENAME, ENTRYARRAYTYPENAME, KEYTYPENAME, VALUETYPENAME) +ENTRYTYPENAME = record + Key: KEYTYPENAME; + Value: VALUETYPENAME; +end; + +ENTRYARRAYTYPENAME = array of ENTRYTYPENAME;*) (*$JPPDEFINEMACRO CONTAINER(INTERFACENAME, GUID) INTERFACENAME = interface(IJclBaseContainer) ['GUID'] @@ -106,6 +113,28 @@ INTERFACENAME = interface(ANCESTORNAME) function Left: TYPENAME; function Right: TYPENAME; end;*) +(*$JPPDEFINEMACRO SORTEDMAPENTRYITERATOR(INTERFACENAME, ANCESTORNAME, GUID, TYPENAME) +INTERFACENAME = interface(ANCESTORNAME) + ['GUID'] + function Add(const AEntry: TYPENAME): Boolean; + procedure Extract; + function GetEntry: TYPENAME; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TYPENAME): Boolean; + function IteratorEquals(const AIterator: INTERFACENAME): Boolean; + function Next: TYPENAME; + function NextIndex: Integer; + function Previous: TYPENAME; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TYPENAME); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TYPENAME read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} +end;*) (*$JPPDEFINEMACRO COLLECTION(INTERFACENAME, ANCESTORNAME, GUID, CONSTKEYWORD, PARAMETERNAME, TYPENAME, ITRNAME) INTERFACENAME = interface(ANCESTORNAME) ['GUID'] diff --git a/jcl/source/prototypes/containers/JclSortedMaps.imp b/jcl/source/prototypes/containers/JclSortedMaps.imp index bfa298f469..84bc1a22fe 100644 --- a/jcl/source/prototypes/containers/JclSortedMaps.imp +++ b/jcl/source/prototypes/containers/JclSortedMaps.imp @@ -1,5 +1,161 @@ +(*$JPPDEFINEMACRO JCLSORTEDMAPITRIMP(SELFCLASSNAME, ITRINTERFACENAME, MAPCLASSNAME, TYPENAME) +//=== { SELFCLASSNAME } =============================================================== + +constructor SELFCLASSNAME.Create(AOwnMap: MAPCLASSNAME; ACursor: Integer; AValid: Boolean; AStart: TItrStart); +begin + inherited Create(AValid); + FOwnMap := AOwnMap; + FStart := AStart; + FCursor := ACursor; +end; + +function SELFCLASSNAME.Add(const AEntry: TYPENAME): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +procedure SELFCLASSNAME.AssignPropertiesTo(Dest: TJclAbstractIterator); +var + ADest: SELFCLASSNAME; +begin + inherited AssignPropertiesTo(Dest); + if Dest is SELFCLASSNAME then + begin + ADest := SELFCLASSNAME(Dest); + ADest.FOwnMap := FOwnMap; + ADest.FCursor := FCursor; + ADest.FStart := FStart; + end; +end; + +function SELFCLASSNAME.CreateEmptyIterator: TJclAbstractIterator; +begin + Result := SELFCLASSNAME.Create(FOwnMap, FCursor, Valid, FStart); +end; + +procedure SELFCLASSNAME.Extract; +begin + CheckValid; + Valid := False; + FOwnMap.Extract(FOwnMap.FEntries[FCursor].Key); +end; + +function SELFCLASSNAME.GetEntry: TYPENAME; +begin + CheckValid; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function SELFCLASSNAME.HasNext: Boolean; +begin + if Valid then + Result := FCursor < (FOwnMap.Size - 1) + else + Result := FCursor < FOwnMap.Size; +end; + +function SELFCLASSNAME.HasPrevious: Boolean; +begin + if Valid then + Result := FCursor > 0 + else + Result := FCursor >= 0; +end; + +function SELFCLASSNAME.Insert(const AEntry: TYPENAME): Boolean; +begin + raise EJclOperationNotSupportedError.Create; +end; + +function SELFCLASSNAME.IteratorEquals(const AIterator: ITRINTERFACENAME): Boolean; +var + Obj: TObject; + ItrObj: SELFCLASSNAME; +begin + Result := False; + if AIterator = nil then + Exit; + Obj := AIterator.GetIteratorReference; + if Obj is SELFCLASSNAME then + begin + ItrObj := SELFCLASSNAME(Obj); + Result := (FOwnMap = ItrObj.FOwnMap) and (FCursor = ItrObj.FCursor) and (Valid = ItrObj.Valid); + end; +end; + +{$IFDEF SUPPORTS_FOR_IN} +function SELFCLASSNAME.MoveNext: Boolean; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result := FCursor < FOwnMap.Size; +end; +{$ENDIF SUPPORTS_FOR_IN} + +function SELFCLASSNAME.Next: TYPENAME; +begin + if Valid then + Inc(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function SELFCLASSNAME.NextIndex: Integer; +begin + if Valid then + Result := FCursor + 1 + else + Result := FCursor; +end; + +function SELFCLASSNAME.Previous: TYPENAME; +begin + if Valid then + Dec(FCursor) + else + Valid := True; + Result.Key := FOwnMap.FEntries[FCursor].Key; + Result.Value := FOwnMap.FEntries[FCursor].Value; +end; + +function SELFCLASSNAME.PreviousIndex: Integer; +begin + if Valid then + Result := FCursor - 1 + else + Result := FCursor; +end; + +procedure SELFCLASSNAME.Remove; +begin + CheckValid; + Valid := False; + FOwnMap.Remove(FOwnMap.FEntries[FCursor].Key); +end; + +procedure SELFCLASSNAME.Reset; +begin + Valid := False; + case FStart of + isFirst: + FCursor := 0; + isLast: + FCursor := FOwnMap.Size - 1; + end; +end; + +procedure SELFCLASSNAME.SetEntry(const AEntry: TYPENAME); +begin + raise EJclOperationNotSupportedError.Create; +end;*) (*$JPPDEFINEMACRO JCLSORTEDMAPIMP(ENTRYTYPENAME, ENTRYARRAYTYPENAME, SELFCLASSNAME, - STDMAPINTERFACENAME, SORTEDMAPINTERFACENAME, KEYSETINTERFACENAME, KEYITRINTERFACENAME, VALUECOLLECTIONINTERFACENAME, + STDMAPINTERFACENAME, SORTEDMAPINTERFACENAME, ENTRYITRINTERFACENAME, ENTRYITRCLASSNAME, + KEYSETINTERFACENAME, KEYITRINTERFACENAME, VALUECOLLECTIONINTERFACENAME, KEYOWNERSHIPDECLARATION, VALUEOWNERSHIPDECLARATION, OWNERSHIPASSIGNMENTS, KEYCONSTKEYWORD, KEYTYPENAME, KEYDEFAULT, VALUECONSTKEYWORD, VALUETYPENAME, VALUEDEFAULT, CREATEKEYSET, CREATEVALUECOLLECTION) @@ -136,6 +292,13 @@ begin {$JPPEXPANDMACRO UNLOCK} end; +{$IFDEF SUPPORTS_FOR_IN} +function SELFCLASSNAME.GetEnumerator: ENTRYITRINTERFACENAME; +begin + Result := ENTRYITRCLASSNAME.Create(Self, 0, False, isFirst); +end; +{$ENDIF SUPPORTS_FOR_IN} + function SELFCLASSNAME.GetValue(KEYCONSTKEYWORDKey: KEYTYPENAME): VALUETYPENAME; var Index: Integer; diff --git a/jcl/source/prototypes/containers/JclSortedMaps.int b/jcl/source/prototypes/containers/JclSortedMaps.int index 4cfbf3d3ac..5a21eb02c0 100644 --- a/jcl/source/prototypes/containers/JclSortedMaps.int +++ b/jcl/source/prototypes/containers/JclSortedMaps.int @@ -1,12 +1,5 @@ -(*$JPPDEFINEMACRO JCLSORTEDMAPTYPESINT(ENTRYTYPENAME, ENTRYARRAYTYPENAME, KEYTYPENAME, VALUETYPENAME) -ENTRYTYPENAME = record - Key: KEYTYPENAME; - Value: VALUETYPENAME; -end; - -ENTRYARRAYTYPENAME = array of ENTRYTYPENAME;*) (*$JPPDEFINEMACRO JCLSORTEDMAPINT(ENTRYTYPENAME, ENTRYARRAYTYPENAME, - SELFCLASSNAME, ANCESTORNAME, STDMAPINTERFACENAME, SORTEDMAPINTERFACENAME, KEYSETINTERFACENAME, VALUECOLLECTIONINTERFACENAME, + SELFCLASSNAME, ANCESTORNAME, STDMAPINTERFACENAME, SORTEDMAPINTERFACENAME, ITRINTERFACENAME, KEYSETINTERFACENAME, VALUECOLLECTIONINTERFACENAME, INTERFACEADDITIONAL, SECTIONADDITIONAL, KEYOWNERSHIPDECLARATION, VALUEOWNERSHIPDECLARATION, KEYCONSTKEYWORD, KEYTYPENAME, VALUECONSTKEYWORD, VALUETYPENAME) SELFCLASSNAME = class(ANCESTORNAME, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} @@ -44,4 +37,39 @@ public function LastKey: KEYTYPENAME; function SubMap(KEYCONSTKEYWORDFromKey, ToKey: KEYTYPENAME): SORTEDMAPINTERFACENAME; function TailMap(KEYCONSTKEYWORDFromKey: KEYTYPENAME): SORTEDMAPINTERFACENAME; + {$IFDEF SUPPORTS_FOR_IN} + function GetEnumerator: ITRINTERFACENAME; + {$ENDIF SUPPORTS_FOR_IN} +end;*) +(*$JPPDEFINEMACRO JCLSORTEDMAPITRINT(SELFCLASSNAME, ITRINTERFACENAME, MAPCLASSNAME, TYPENAME) +SELFCLASSNAME = class(TJclAbstractIterator, ITRINTERFACENAME, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE} + IJclIntfCloneable, IJclCloneable) +private + FCursor: Integer; + FStart: TItrStart; + FOwnMap: MAPCLASSNAME; +protected + procedure AssignPropertiesTo(Dest: TJclAbstractIterator); override; + function CreateEmptyIterator: TJclAbstractIterator; override; +public + constructor Create(AOwnMap: MAPCLASSNAME; ACursor: Integer; AValid: Boolean; AStart: TItrStart); + { ITRINTERFACENAME } + function Add(const AEntry: TYPENAME): Boolean; + procedure Extract; + function GetEntry: TYPENAME; + function HasNext: Boolean; + function HasPrevious: Boolean; + function Insert(const AEntry: TYPENAME): Boolean; + function IteratorEquals(const AIterator: ITRINTERFACENAME): Boolean; + function Next: TYPENAME; + function NextIndex: Integer; + function Previous: TYPENAME; + function PreviousIndex: Integer; + procedure Remove; + procedure Reset; + procedure SetEntry(const AEntry: TYPENAME); + {$IFDEF SUPPORTS_FOR_IN} + function MoveNext: Boolean; + property Current: TYPENAME read GetEntry; + {$ENDIF SUPPORTS_FOR_IN} end;*)