2466 lines
61 KiB
ObjectPascal
2466 lines
61 KiB
ObjectPascal
{
|
|
:: X2UtHashes contains a base class for hashes (also known as associative
|
|
:: arrays), as well as various default implementations.
|
|
::
|
|
:: The useable implementations have a naming convention of TX2<tt>Hash,
|
|
:: where <tt> are two characters representing the key and value types,
|
|
:: according to the following table:
|
|
::
|
|
:: P = Pointer
|
|
:: I = Integer
|
|
:: O = Object
|
|
:: S = String
|
|
::
|
|
:: For example; TX2SOHash indicates that it uses String keys to identify
|
|
:: Object values.
|
|
::
|
|
:: As of Delphi 2006, all default hashes support the for...in structure.
|
|
:: To enumerate all keys, use "for x in Hash". As of yet, there is no
|
|
:: direct support for value enumeration yet; you can use
|
|
:: First/Next/CurrentValue for that.
|
|
::
|
|
:: Last changed: $Date$
|
|
:: Revision: $Rev$
|
|
:: Author: $Author$
|
|
}
|
|
unit X2UtHashes;
|
|
|
|
{$I X2UtCompilerVersion.inc}
|
|
|
|
interface
|
|
uses
|
|
Classes,
|
|
SysUtils;
|
|
|
|
const
|
|
// Do NOT change these values unless you really know
|
|
// what you are doing!
|
|
LeafSize = 256;
|
|
BucketSize = 8;
|
|
|
|
type
|
|
//:$ Raised when the cursor is not available
|
|
EX2HashNoCursor = class(Exception);
|
|
|
|
// Forward declarations
|
|
TX2CustomHash = class;
|
|
|
|
|
|
{$IFDEF D2005PLUS}
|
|
{$REGION 'Internal hash structures'}
|
|
{$ENDIF}
|
|
{
|
|
:$ Internal representation of a hash item.
|
|
}
|
|
PX2HashCookie = Pointer;
|
|
|
|
PX2HashItem = ^TX2HashItem;
|
|
TX2HashItem = record
|
|
ID: Cardinal;
|
|
end;
|
|
|
|
|
|
PX2HashBucket = ^TX2HashBucket;
|
|
TX2HashBucket = record
|
|
ID: Cardinal;
|
|
Level: Integer;
|
|
Count: Integer;
|
|
Items: array[0..Pred(LeafSize)] of PX2HashItem;
|
|
end;
|
|
|
|
|
|
PX2HashValue = ^TX2HashValue;
|
|
TX2HashValue = record
|
|
ID: Cardinal;
|
|
Next: PX2HashValue;
|
|
Key: PX2HashCookie;
|
|
Value: PX2HashCookie;
|
|
end;
|
|
|
|
|
|
TX2BucketPath = record
|
|
Bucket: PX2HashBucket;
|
|
Index: Integer;
|
|
end;
|
|
|
|
|
|
PX2HashStringCookie = ^TX2HashStringCookie;
|
|
TX2HashStringCookie = record
|
|
Length: Cardinal;
|
|
Value: PChar;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Default cursor implementation.
|
|
|
|
:: Traverses the hash tree from top-to-bottom, left-to-right.
|
|
}
|
|
TX2HashCursor = class(TObject)
|
|
private
|
|
FBucketPath: array of TX2BucketPath;
|
|
FCurrent: PX2HashValue;
|
|
protected
|
|
function GetCurrent: PX2HashValue; virtual;
|
|
public
|
|
constructor Create(const ABucket: PX2HashBucket); virtual;
|
|
|
|
procedure First; virtual;
|
|
function Next: Boolean; virtual;
|
|
|
|
property Current: PX2HashValue read GetCurrent;
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Internal value managers'}
|
|
{$ENDIF}
|
|
{
|
|
:$ Base value manager.
|
|
}
|
|
TX2CustomHashManager = class(TObject)
|
|
protected
|
|
procedure FreeCookie(var ACookie: PX2HashCookie); virtual;
|
|
|
|
function Hash(ACookie: PX2HashCookie): Cardinal; virtual; abstract;
|
|
function Compare(const ACookie1, ACookie2: PX2HashCookie): Boolean; virtual; abstract;
|
|
function Clone(const ACookie: PX2HashCookie): PX2HashCookie; virtual; abstract;
|
|
end;
|
|
|
|
|
|
TX2HashPointerManager = class(TX2CustomHashManager)
|
|
protected
|
|
function CreateCookie(const AValue: Pointer): PX2HashCookie; overload;
|
|
function GetValue(const ACookie: PX2HashCookie): Pointer; overload;
|
|
|
|
function Hash(ACookie: PX2HashCookie): Cardinal; override;
|
|
function Compare(const ACookie1, ACookie2: PX2HashCookie): Boolean; override;
|
|
function Clone(const ACookie: PX2HashCookie): PX2HashCookie; override;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Integer value class.
|
|
}
|
|
TX2HashIntegerManager = class(TX2CustomHashManager)
|
|
protected
|
|
function CreateCookie(const AValue: Integer): PX2HashCookie; overload;
|
|
function GetValue(const ACookie: PX2HashCookie): Integer; overload;
|
|
|
|
function Hash(ACookie: PX2HashCookie): Cardinal; override;
|
|
function Compare(const ACookie1, ACookie2: PX2HashCookie): Boolean; override;
|
|
function Clone(const ACookie: PX2HashCookie): PX2HashCookie; override;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Object value class.
|
|
}
|
|
TX2HashObjectManager = class(TX2CustomHashManager)
|
|
private
|
|
FOwnsObjects: Boolean;
|
|
protected
|
|
procedure FreeCookie(var ACookie: PX2HashCookie); override;
|
|
|
|
function CreateCookie(const AValue: TObject): PX2HashCookie; overload;
|
|
function GetValue(const ACookie: PX2HashCookie): TObject; overload;
|
|
|
|
function Hash(ACookie: PX2HashCookie): Cardinal; override;
|
|
function Compare(const ACookie1, ACookie2: PX2HashCookie): Boolean; override;
|
|
function Clone(const ACookie: PX2HashCookie): PX2HashCookie; override;
|
|
|
|
property OwnsObjects: Boolean read FOwnsObjects write FOwnsObjects;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ String value class.
|
|
}
|
|
TX2HashStringManager = class(TX2CustomHashManager)
|
|
protected
|
|
procedure FreeCookie(var ACookie: PX2HashCookie); override;
|
|
|
|
function CreateCookie(const AValue: string): PX2HashCookie; overload;
|
|
function GetValue(const ACookie: PX2HashCookie): string; overload;
|
|
|
|
function Hash(ACookie: PX2HashCookie): Cardinal; override;
|
|
function Compare(const ACookie1, ACookie2: PX2HashCookie): Boolean; override;
|
|
function Clone(const ACookie: PX2HashCookie): PX2HashCookie; override;
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Delphi 2006 enumerator support'}
|
|
{$ENDIF}
|
|
{
|
|
:$ Base enumerator class.
|
|
}
|
|
TX2HashEnumerator = class(TObject)
|
|
private
|
|
FCursor: TX2HashCursor;
|
|
FManager: TX2CustomHashManager;
|
|
FEnumKeys: Boolean;
|
|
|
|
function GetCursor: PX2HashCookie;
|
|
protected
|
|
property Manager: TX2CustomHashManager read FManager;
|
|
property Cursor: PX2HashCookie read GetCursor;
|
|
public
|
|
constructor Create(const AHash: TX2CustomHash;
|
|
const AEnumKeys: Boolean);
|
|
destructor Destroy; override;
|
|
|
|
function MoveNext: Boolean;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Enumerator for pointer values.
|
|
}
|
|
TX2HashPointerEnumerator = class(TX2HashEnumerator)
|
|
private
|
|
function GetCurrent: Pointer;
|
|
public
|
|
property Current: Pointer read GetCurrent;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Enumerator for integer values.
|
|
}
|
|
TX2HashIntegerEnumerator = class(TX2HashEnumerator)
|
|
private
|
|
function GetCurrent: Integer;
|
|
public
|
|
property Current: Integer read GetCurrent;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Enumerator for object values.
|
|
}
|
|
TX2HashObjectEnumerator = class(TX2HashEnumerator)
|
|
private
|
|
function GetCurrent: TObject;
|
|
public
|
|
property Current: TObject read GetCurrent;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Enumerator for string values
|
|
}
|
|
TX2HashStringEnumerator = class(TX2HashEnumerator)
|
|
private
|
|
function GetCurrent: String;
|
|
public
|
|
property Current: String read GetCurrent;
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Abstract hash implementation'}
|
|
{$ENDIF}
|
|
{
|
|
:$ Hash implementation.
|
|
}
|
|
TX2CustomHash = class(TPersistent)
|
|
private
|
|
FRoot: PX2HashBucket;
|
|
FCount: Integer;
|
|
|
|
FCursor: TX2HashCursor;
|
|
FKeyManager: TX2CustomHashManager;
|
|
FValueManager: TX2CustomHashManager;
|
|
protected
|
|
function CreateCursor: TX2HashCursor; virtual;
|
|
function CreateKeyManager: TX2CustomHashManager; virtual; abstract;
|
|
function CreateValueManager: TX2CustomHashManager; virtual; abstract;
|
|
procedure InvalidateCursor;
|
|
|
|
function CursorRequired(const ARaiseException: Boolean = True): Boolean;
|
|
|
|
function InternalFind(const ABucket: PX2HashBucket;
|
|
const AHash: Cardinal; const AKey: PX2HashCookie;
|
|
const AAllowCreate: Boolean;
|
|
const AExisting: PX2HashValue = nil): PX2HashValue;
|
|
function InternalDelete(const ABucket: PX2HashBucket;
|
|
const AHash: Cardinal; const AKey: PX2HashCookie): Boolean;
|
|
|
|
{ :$ AKey will be freed by these methods, so make sure to pass a Clone
|
|
:$ if you need it afterwards! }
|
|
function Find(const AKey: PX2HashCookie; const AAllowCreate: Boolean): PX2HashValue; overload;
|
|
function Exists(const AKey: PX2HashCookie): Boolean; overload;
|
|
function Delete(const AKey: PX2HashCookie): Boolean; overload;
|
|
|
|
procedure SetValue(const AValue: PX2HashValue; const AData: Pointer);
|
|
|
|
property Cursor: TX2HashCursor read FCursor;
|
|
property KeyManager: TX2CustomHashManager read FKeyManager;
|
|
property ValueManager: TX2CustomHashManager read FValueManager;
|
|
public
|
|
constructor Create; virtual;
|
|
destructor Destroy; override;
|
|
|
|
procedure Clear;
|
|
|
|
procedure First;
|
|
function Next: Boolean;
|
|
|
|
property Count: Integer read FCount;
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Base hash classes'}
|
|
{$ENDIF}
|
|
{
|
|
:$ Base hash implementation for pointer keys.
|
|
}
|
|
TX2CustomPointerHash = class(TX2CustomHash)
|
|
private
|
|
function GetCurrentKey: Pointer;
|
|
function GetKeyManager: TX2HashPointerManager;
|
|
protected
|
|
function CreateKeyManager: TX2CustomHashManager; override;
|
|
function Find(const AKey: Pointer; const AAllowCreate: Boolean): PX2HashValue; overload;
|
|
|
|
property KeyManager: TX2HashPointerManager read GetKeyManager;
|
|
public
|
|
function GetEnumerator: TX2HashPointerEnumerator;
|
|
|
|
function Exists(const AKey: Pointer): Boolean; overload;
|
|
function Delete(const AKey: Pointer): Boolean; overload;
|
|
|
|
property CurrentKey: Pointer read GetCurrentKey;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Base hash implementation for integer keys.
|
|
}
|
|
TX2CustomIntegerHash = class(TX2CustomHash)
|
|
private
|
|
function GetCurrentKey: Integer;
|
|
function GetKeyManager: TX2HashIntegerManager;
|
|
protected
|
|
function CreateKeyManager: TX2CustomHashManager; override;
|
|
function Find(const AKey: Integer; const AAllowCreate: Boolean): PX2HashValue; overload;
|
|
|
|
property KeyManager: TX2HashIntegerManager read GetKeyManager;
|
|
public
|
|
function GetEnumerator: TX2HashIntegerEnumerator;
|
|
|
|
function Exists(const AKey: Integer): Boolean; overload;
|
|
function Delete(const AKey: Integer): Boolean; overload;
|
|
|
|
property CurrentKey: Integer read GetCurrentKey;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Base hash implementation for object keys.
|
|
}
|
|
TX2CustomObjectHash = class(TX2CustomHash)
|
|
private
|
|
function GetCurrentKey: TObject;
|
|
function GetKeyManager: TX2HashObjectManager;
|
|
protected
|
|
function CreateKeyManager: TX2CustomHashManager; override;
|
|
function Find(const AKey: TObject; const AAllowCreate: Boolean): PX2HashValue; overload;
|
|
|
|
property KeyManager: TX2HashObjectManager read GetKeyManager;
|
|
public
|
|
function GetEnumerator: TX2HashObjectEnumerator;
|
|
|
|
function Exists(const AKey: TObject): Boolean; overload;
|
|
function Delete(const AKey: TObject): Boolean; overload;
|
|
|
|
property CurrentKey: TObject read GetCurrentKey;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Base hash implementation for string keys.
|
|
}
|
|
TX2CustomStringHash = class(TX2CustomHash)
|
|
protected
|
|
function GetCurrentKey: String;
|
|
private
|
|
function GetKeyManager: TX2HashStringManager;
|
|
protected
|
|
function CreateKeyManager: TX2CustomHashManager; override;
|
|
function Find(const AKey: String; const AAllowCreate: Boolean): PX2HashValue; overload;
|
|
|
|
property KeyManager: TX2HashStringManager read GetKeyManager;
|
|
public
|
|
function GetEnumerator: TX2HashStringEnumerator;
|
|
|
|
function Exists(const AKey: String): Boolean; overload;
|
|
function Delete(const AKey: String): Boolean; overload;
|
|
|
|
property CurrentKey: String read GetCurrentKey;
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Concrete hash classes'}
|
|
{$ENDIF}
|
|
{
|
|
:$ Pointer-to-Pointer hash.
|
|
}
|
|
TX2PPHash = class(TX2CustomPointerHash)
|
|
protected
|
|
function GetCurrentValue: Pointer;
|
|
function GetValue(Key: Pointer): Pointer;
|
|
procedure SetValue(Key: Pointer; const Value: Pointer);
|
|
private
|
|
function GetValueManager: TX2HashPointerManager;
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashPointerManager read GetValueManager;
|
|
public
|
|
property CurrentValue: Pointer read GetCurrentValue;
|
|
property Values[Key: Pointer]: Pointer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Pointer-to-Integer hash.
|
|
}
|
|
TX2PIHash = class(TX2CustomPointerHash)
|
|
protected
|
|
function GetCurrentValue: Integer;
|
|
function GetValue(Key: Pointer): Integer;
|
|
procedure SetValue(Key: Pointer; const Value: Integer);
|
|
private
|
|
function GetValueManager: TX2HashIntegerManager;
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashIntegerManager read GetValueManager;
|
|
public
|
|
property CurrentValue: Integer read GetCurrentValue;
|
|
property Values[Key: Pointer]: Integer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Pointer-to-Object hash.
|
|
}
|
|
TX2POHash = class(TX2CustomPointerHash)
|
|
protected
|
|
function GetCurrentValue: TObject;
|
|
function GetOwnsObjects: Boolean;
|
|
procedure SetOwnsObjects(const Value: Boolean);
|
|
function GetValue(Key: Pointer): TObject;
|
|
procedure SetValue(Key: Pointer; const Value: TObject);
|
|
private
|
|
function GetValueManager: TX2HashObjectManager;
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashObjectManager read GetValueManager;
|
|
public
|
|
constructor Create(const AOwnsObjects: Boolean = False); reintroduce;
|
|
|
|
property CurrentValue: TObject read GetCurrentValue;
|
|
property OwnsObjects: Boolean read GetOwnsObjects write SetOwnsObjects;
|
|
property Values[Key: Pointer]: TObject read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Pointer-to-String hash.
|
|
}
|
|
TX2PSHash = class(TX2CustomPointerHash)
|
|
protected
|
|
function GetCurrentValue: String;
|
|
function GetValue(Key: Pointer): String;
|
|
procedure SetValue(Key: Pointer; const Value: String);
|
|
private
|
|
function GetValueManager: TX2HashStringManager;
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashStringManager read GetValueManager;
|
|
public
|
|
property CurrentValue: String read GetCurrentValue;
|
|
property Values[Key: Pointer]: String read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Integer-to-Pointer hash.
|
|
}
|
|
TX2IPHash = class(TX2CustomIntegerHash)
|
|
protected
|
|
function GetCurrentValue: Pointer;
|
|
function GetValue(Key: Integer): Pointer;
|
|
procedure SetValue(Key: Integer; const Value: Pointer);
|
|
private
|
|
function GetValueManager: TX2HashPointerManager;
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashPointerManager read GetValueManager;
|
|
public
|
|
property CurrentValue: Pointer read GetCurrentValue;
|
|
property Values[Key: Integer]: Pointer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Integer-to-Integer hash.
|
|
}
|
|
TX2IIHash = class(TX2CustomIntegerHash)
|
|
protected
|
|
function GetCurrentValue: Integer;
|
|
function GetValue(Key: Integer): Integer;
|
|
procedure SetValue(Key: Integer; const Value: Integer);
|
|
private
|
|
function GetValueManager: TX2HashIntegerManager;
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashIntegerManager read GetValueManager;
|
|
public
|
|
property CurrentValue: Integer read GetCurrentValue;
|
|
property Values[Key: Integer]: Integer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Integer-to-Object hash.
|
|
}
|
|
TX2IOHash = class(TX2CustomIntegerHash)
|
|
private
|
|
function GetValueManager: TX2HashObjectManager;
|
|
protected
|
|
function GetCurrentValue: TObject;
|
|
function GetOwnsObjects: Boolean;
|
|
procedure SetOwnsObjects(const Value: Boolean);
|
|
function GetValue(Key: Integer): TObject;
|
|
procedure SetValue(Key: Integer; const Value: TObject);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashObjectManager read GetValueManager;
|
|
public
|
|
constructor Create(const AOwnsObjects: Boolean = False); reintroduce;
|
|
|
|
property CurrentValue: TObject read GetCurrentValue;
|
|
property OwnsObjects: Boolean read GetOwnsObjects write SetOwnsObjects;
|
|
property Values[Key: Integer]: TObject read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Integer-to-String hash.
|
|
}
|
|
TX2ISHash = class(TX2CustomIntegerHash)
|
|
private
|
|
function GetValueManager: TX2HashStringManager;
|
|
protected
|
|
function GetCurrentValue: String;
|
|
function GetValue(Key: Integer): String;
|
|
procedure SetValue(Key: Integer; const Value: String);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashStringManager read GetValueManager;
|
|
public
|
|
property CurrentValue: String read GetCurrentValue;
|
|
property Values[Key: Integer]: String read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Object-to-Pointer hash.
|
|
}
|
|
TX2OPHash = class(TX2CustomObjectHash)
|
|
private
|
|
function GetValueManager: TX2HashPointerManager;
|
|
protected
|
|
function GetCurrentValue: Pointer;
|
|
function GetValue(Key: TObject): Pointer;
|
|
procedure SetValue(Key: TObject; const Value: Pointer);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashPointerManager read GetValueManager;
|
|
public
|
|
property CurrentValue: Pointer read GetCurrentValue;
|
|
property Values[Key: TObject]: Pointer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Object-to-Integer hash.
|
|
}
|
|
TX2OIHash = class(TX2CustomObjectHash)
|
|
private
|
|
function GetValueManager: TX2HashIntegerManager;
|
|
protected
|
|
function GetCurrentValue: Integer;
|
|
function GetValue(Key: TObject): Integer;
|
|
procedure SetValue(Key: TObject; const Value: Integer);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashIntegerManager read GetValueManager;
|
|
public
|
|
property CurrentValue: Integer read GetCurrentValue;
|
|
property Values[Key: TObject]: Integer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Object-to-Object hash.
|
|
}
|
|
TX2OOHash = class(TX2CustomObjectHash)
|
|
private
|
|
function GetValueManager: TX2HashObjectManager;
|
|
protected
|
|
function GetCurrentValue: TObject;
|
|
function GetOwnsObjects: Boolean;
|
|
procedure SetOwnsObjects(const Value: Boolean);
|
|
function GetValue(Key: TObject): TObject;
|
|
procedure SetValue(Key: TObject; const Value: TObject);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashObjectManager read GetValueManager;
|
|
public
|
|
constructor Create(const AOwnsObjects: Boolean = False); reintroduce;
|
|
|
|
property CurrentValue: TObject read GetCurrentValue;
|
|
property OwnsObjects: Boolean read GetOwnsObjects write SetOwnsObjects;
|
|
property Values[Key: TObject]: TObject read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ Object-to-String hash.
|
|
}
|
|
TX2OSHash = class(TX2CustomObjectHash)
|
|
private
|
|
function GetValueManager: TX2HashStringManager;
|
|
protected
|
|
function GetCurrentValue: String;
|
|
function GetValue(Key: TObject): String;
|
|
procedure SetValue(Key: TObject; const Value: String);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashStringManager read GetValueManager;
|
|
public
|
|
property CurrentValue: String read GetCurrentValue;
|
|
property Values[Key: TObject]: String read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ String-to-Pointer hash.
|
|
}
|
|
TX2SPHash = class(TX2CustomStringHash)
|
|
private
|
|
function GetValueManager: TX2HashPointerManager;
|
|
protected
|
|
function GetCurrentValue: Pointer;
|
|
function GetValue(Key: String): Pointer;
|
|
procedure SetValue(Key: String; const Value: Pointer);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashPointerManager read GetValueManager;
|
|
public
|
|
property CurrentValue: Pointer read GetCurrentValue;
|
|
property Values[Key: String]: Pointer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ String-to-Integer hash.
|
|
}
|
|
TX2SIHash = class(TX2CustomStringHash)
|
|
private
|
|
function GetValueManager: TX2HashIntegerManager;
|
|
protected
|
|
function GetCurrentValue: Integer;
|
|
function GetValue(Key: String): Integer;
|
|
procedure SetValue(Key: String; const Value: Integer);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashIntegerManager read GetValueManager;
|
|
public
|
|
property CurrentValue: Integer read GetCurrentValue;
|
|
property Values[Key: String]: Integer read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ String-to-Object hash.
|
|
}
|
|
TX2SOHash = class(TX2CustomStringHash)
|
|
private
|
|
function GetValueManager: TX2HashObjectManager;
|
|
protected
|
|
function GetCurrentValue: TObject;
|
|
function GetOwnsObjects: Boolean;
|
|
procedure SetOwnsObjects(const Value: Boolean);
|
|
function GetValue(Key: String): TObject;
|
|
procedure SetValue(Key: String; const Value: TObject);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashObjectManager read GetValueManager;
|
|
public
|
|
constructor Create(const AOwnsObjects: Boolean = False); reintroduce;
|
|
|
|
property CurrentValue: TObject read GetCurrentValue;
|
|
property OwnsObjects: Boolean read GetOwnsObjects write SetOwnsObjects;
|
|
property Values[Key: String]: TObject read GetValue write SetValue; default;
|
|
end;
|
|
|
|
|
|
{
|
|
:$ String-to-String hash.
|
|
}
|
|
TX2SSHash = class(TX2CustomStringHash)
|
|
private
|
|
function GetValueManager: TX2HashStringManager;
|
|
protected
|
|
function GetCurrentValue: String;
|
|
function GetValue(Key: String): String;
|
|
procedure SetValue(Key: String; const Value: String);
|
|
protected
|
|
function CreateValueManager: TX2CustomHashManager; override;
|
|
|
|
property ValueManager: TX2HashStringManager read GetValueManager;
|
|
public
|
|
property CurrentValue: String read GetCurrentValue;
|
|
property Values[Key: String]: String read GetValue write SetValue; default;
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
{$ENDIF}
|
|
|
|
|
|
implementation
|
|
const
|
|
HIDBucket = 1;
|
|
HIDValue = 2;
|
|
|
|
CRC32Poly = $edb88320;
|
|
|
|
var
|
|
CRC32Table: array[Byte] of Cardinal;
|
|
|
|
|
|
{========================================
|
|
CRC32
|
|
========================================}
|
|
procedure CRC32Init;
|
|
var
|
|
iItem: Integer;
|
|
iPoly: Integer;
|
|
iValue: Cardinal;
|
|
|
|
begin
|
|
for iItem := 255 downto 0 do
|
|
begin
|
|
iValue := iItem;
|
|
|
|
for iPoly := 8 downto 1 do
|
|
if (iValue and $1) <> 0 then
|
|
iValue := (iValue shr $1) xor CRC32Poly
|
|
else
|
|
iValue := iValue shr $1;
|
|
|
|
CRC32Table[iItem] := iValue;
|
|
end;
|
|
end;
|
|
|
|
|
|
function CRC32(const AKey: Pointer; const ASize: Cardinal): Cardinal;
|
|
var
|
|
iByte: Integer;
|
|
pByte: ^Byte;
|
|
|
|
begin
|
|
Result := $FFFFFFFF;
|
|
pByte := AKey;
|
|
|
|
for iByte := Pred(ASize) downto 0 do
|
|
begin
|
|
Result := (((Result shr 8) and $00FFFFFF) xor
|
|
(CRC32Table[(Result xor pByte^) and $FF]));
|
|
Inc(pByte);
|
|
end;
|
|
end;
|
|
|
|
|
|
{$IFDEF D2005PLUS}
|
|
{$REGION 'Internal hash structures'}
|
|
{$ENDIF}
|
|
{========================================
|
|
TX2HashCursor
|
|
========================================}
|
|
constructor TX2HashCursor.Create(const ABucket: PX2HashBucket);
|
|
begin
|
|
inherited Create;
|
|
|
|
SetLength(FBucketPath, 1);
|
|
with FBucketPath[0] do
|
|
begin
|
|
Bucket := ABucket;
|
|
Index := 0;
|
|
end;
|
|
|
|
FCurrent := nil;
|
|
end;
|
|
|
|
|
|
function TX2HashCursor.GetCurrent: PX2HashValue;
|
|
begin
|
|
Result := FCurrent;
|
|
end;
|
|
|
|
|
|
procedure TX2HashCursor.First;
|
|
begin
|
|
if Length(FBucketPath) > 1 then
|
|
SetLength(FBucketPath, 1);
|
|
|
|
FBucketPath[0].Index := 0;
|
|
FCurrent := nil;
|
|
end;
|
|
|
|
|
|
function TX2HashCursor.Next: Boolean;
|
|
var
|
|
bFound: Boolean;
|
|
iIndex: Integer;
|
|
pBucket: PX2HashBucket;
|
|
pItem: PX2HashItem;
|
|
|
|
begin
|
|
Result := False;
|
|
iIndex := High(FBucketPath);
|
|
if iIndex = -1 then
|
|
exit;
|
|
|
|
if Assigned(FCurrent) and Assigned(FCurrent^.Next) then
|
|
begin
|
|
FCurrent := FCurrent^.Next;
|
|
Result := True;
|
|
exit;
|
|
end;
|
|
|
|
repeat
|
|
pBucket := FBucketPath[iIndex].Bucket;
|
|
bFound := False;
|
|
|
|
while FBucketPath[iIndex].Index < LeafSize do
|
|
begin
|
|
pItem := pBucket^.Items[FBucketPath[iIndex].Index];
|
|
|
|
if pItem = nil then
|
|
Inc(FBucketPath[iIndex].Index)
|
|
else
|
|
case pItem^.ID of
|
|
HIDBucket:
|
|
begin
|
|
// Bucket, continue down the path
|
|
Inc(iIndex);
|
|
SetLength(FBucketPath, iIndex + 1);
|
|
with FBucketPath[iIndex] do
|
|
begin
|
|
Bucket := PX2HashBucket(pItem);
|
|
Index := 0;
|
|
end;
|
|
bFound := True;
|
|
break;
|
|
end;
|
|
HIDValue:
|
|
begin
|
|
// Got a value
|
|
FCurrent := PX2HashValue(pItem);
|
|
Result := True;
|
|
Inc(FBucketPath[iIndex].Index);
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if not bFound then
|
|
// Nothing found
|
|
if iIndex > 0 then
|
|
begin
|
|
// Go up in the bucket path
|
|
SetLength(FBucketPath, iIndex);
|
|
Dec(iIndex);
|
|
Inc(FBucketPath[iIndex].Index);
|
|
end else
|
|
// No more items
|
|
break;
|
|
until False;
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Internal value managers'}
|
|
{$ENDIF}
|
|
{========================================
|
|
TX2CustomHashManager
|
|
========================================}
|
|
procedure TX2CustomHashManager.FreeCookie(var ACookie: Pointer);
|
|
begin
|
|
ACookie := nil;
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2HashPointerManager
|
|
========================================}
|
|
function TX2HashPointerManager.CreateCookie(const AValue: Pointer): PX2HashCookie;
|
|
begin
|
|
Result := AValue;
|
|
end;
|
|
|
|
|
|
function TX2HashPointerManager.GetValue(const ACookie: PX2HashCookie): Pointer;
|
|
begin
|
|
Result := ACookie;
|
|
end;
|
|
|
|
|
|
function TX2HashPointerManager.Hash(ACookie: PX2HashCookie): Cardinal;
|
|
var
|
|
value: Pointer;
|
|
|
|
begin
|
|
value := GetValue(ACookie);
|
|
Result := CRC32(@value, SizeOf(Pointer));
|
|
end;
|
|
|
|
|
|
function TX2HashPointerManager.Compare(const ACookie1, ACookie2: PX2HashCookie): Boolean;
|
|
begin
|
|
Result := (GetValue(ACookie1) = GetValue(ACookie2));
|
|
end;
|
|
|
|
|
|
function TX2HashPointerManager.Clone(const ACookie: PX2HashCookie): PX2HashCookie;
|
|
begin
|
|
Result := ACookie;
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2HashIntegerManager
|
|
========================================}
|
|
function TX2HashIntegerManager.CreateCookie(const AValue: Integer): PX2HashCookie;
|
|
begin
|
|
Result := PX2HashCookie(AValue);
|
|
end;
|
|
|
|
|
|
function TX2HashIntegerManager.GetValue(const ACookie: PX2HashCookie): Integer;
|
|
begin
|
|
Result := Integer(ACookie);
|
|
end;
|
|
|
|
|
|
function TX2HashIntegerManager.Hash(ACookie: PX2HashCookie): Cardinal;
|
|
var
|
|
value: Integer;
|
|
|
|
begin
|
|
value := GetValue(ACookie);
|
|
Result := CRC32(@value, SizeOf(Integer));
|
|
end;
|
|
|
|
|
|
function TX2HashIntegerManager.Compare(const ACookie1, ACookie2: PX2HashCookie): Boolean;
|
|
begin
|
|
Result := (GetValue(ACookie1) = GetValue(ACookie2));
|
|
end;
|
|
|
|
|
|
function TX2HashIntegerManager.Clone(const ACookie: PX2HashCookie): PX2HashCookie;
|
|
begin
|
|
Result := ACookie;
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2HashObjectManager
|
|
========================================}
|
|
procedure TX2HashObjectManager.FreeCookie(var ACookie: PX2HashCookie);
|
|
begin
|
|
if Assigned(ACookie) and (FOwnsObjects) then
|
|
GetValue(ACookie).Free;
|
|
|
|
inherited;
|
|
end;
|
|
|
|
|
|
function TX2HashObjectManager.CreateCookie(const AValue: TObject): PX2HashCookie;
|
|
begin
|
|
Result := PX2HashCookie(AValue);
|
|
end;
|
|
|
|
|
|
function TX2HashObjectManager.GetValue(const ACookie: PX2HashCookie): TObject;
|
|
begin
|
|
Result := TObject(ACookie);
|
|
end;
|
|
|
|
|
|
function TX2HashObjectManager.Hash(ACookie: PX2HashCookie): Cardinal;
|
|
var
|
|
value: TObject;
|
|
|
|
begin
|
|
value := GetValue(ACookie);
|
|
Result := CRC32(@value, SizeOf(TObject));
|
|
end;
|
|
|
|
|
|
function TX2HashObjectManager.Compare(const ACookie1, ACookie2: PX2HashCookie): Boolean;
|
|
begin
|
|
Result := (GetValue(ACookie1) = GetValue(ACookie2));
|
|
end;
|
|
|
|
|
|
function TX2HashObjectManager.Clone(const ACookie: PX2HashCookie): PX2HashCookie;
|
|
begin
|
|
Result := ACookie;
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2HashStringManager
|
|
========================================}
|
|
procedure TX2HashStringManager.FreeCookie(var ACookie: PX2HashCookie);
|
|
var
|
|
stringCookie: PX2HashStringCookie;
|
|
|
|
begin
|
|
if Assigned(ACookie) then
|
|
begin
|
|
stringCookie := ACookie;
|
|
|
|
if stringCookie^.Length > 0 then
|
|
FreeMem(stringCookie^.Value, Succ(stringCookie^.Length));
|
|
|
|
Dispose(stringCookie);
|
|
end;
|
|
|
|
inherited;
|
|
end;
|
|
|
|
|
|
function TX2HashStringManager.CreateCookie(const AValue: string): PX2HashCookie;
|
|
var
|
|
stringCookie: PX2HashStringCookie;
|
|
|
|
begin
|
|
New(stringCookie);
|
|
stringCookie^.Length := Length(AValue);
|
|
|
|
GetMem(stringCookie^.Value, Succ(Length(AValue)));
|
|
StrPCopy(stringCookie^.Value, AValue);
|
|
|
|
Result := stringCookie;
|
|
end;
|
|
|
|
|
|
function TX2HashStringManager.GetValue(const ACookie: PX2HashCookie): string;
|
|
var
|
|
stringCookie: PX2HashStringCookie;
|
|
|
|
begin
|
|
Result := '';
|
|
if Assigned(ACookie) then
|
|
begin
|
|
stringCookie := ACookie;
|
|
if stringCookie^.Length > 0 then
|
|
begin
|
|
SetLength(Result, stringCookie^.Length);
|
|
Move(stringCookie^.Value^, Result[1], stringCookie^.Length);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TX2HashStringManager.Hash(ACookie: PX2HashCookie): Cardinal;
|
|
var
|
|
stringCookie: PX2HashStringCookie;
|
|
|
|
begin
|
|
Result := 0;
|
|
if Assigned(ACookie) then
|
|
begin
|
|
stringCookie := ACookie;
|
|
Result := CRC32(stringCookie^.Value, stringCookie^.Length);
|
|
end;
|
|
end;
|
|
|
|
|
|
function TX2HashStringManager.Compare(const ACookie1, ACookie2: PX2HashCookie): Boolean;
|
|
begin
|
|
Result := (GetValue(ACookie1) = GetValue(ACookie2));
|
|
end;
|
|
|
|
|
|
function TX2HashStringManager.Clone(const ACookie: PX2HashCookie): PX2HashCookie;
|
|
begin
|
|
Result := CreateCookie(GetValue(ACookie));
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Abstract hash implementation'}
|
|
{$ENDIF}
|
|
{========================== TX2CustomHash
|
|
Initialization
|
|
========================================}
|
|
constructor TX2CustomHash.Create;
|
|
begin
|
|
inherited;
|
|
|
|
FKeyManager := CreateKeyManager;
|
|
FValueManager := CreateValueManager;
|
|
end;
|
|
|
|
|
|
destructor TX2CustomHash.Destroy;
|
|
begin
|
|
Clear;
|
|
FreeAndNil(FValueManager);
|
|
FreeAndNil(FKeyManager);
|
|
FreeAndNil(FCursor);
|
|
|
|
inherited;
|
|
end;
|
|
|
|
|
|
function TX2CustomHash.CreateCursor: TX2HashCursor;
|
|
begin
|
|
Result := nil;
|
|
if Assigned(FRoot) then
|
|
Result := TX2HashCursor.Create(FRoot);
|
|
end;
|
|
|
|
|
|
procedure TX2CustomHash.InvalidateCursor;
|
|
begin
|
|
FreeAndNil(FCursor);
|
|
end;
|
|
|
|
|
|
{========================== TX2CustomHash
|
|
Item Management
|
|
========================================}
|
|
function ROR(const AValue: Cardinal; const AShift: Byte = 8): Cardinal;
|
|
asm
|
|
MOV cl, dl
|
|
ROR eax, cl
|
|
end;
|
|
|
|
|
|
function TX2CustomHash.CursorRequired(const ARaiseException: Boolean): Boolean;
|
|
begin
|
|
Result := True;
|
|
if not Assigned(FCursor) then
|
|
if Assigned(FRoot) then
|
|
FCursor := CreateCursor
|
|
else
|
|
begin
|
|
Result := False;
|
|
if ARaiseException then
|
|
raise EX2HashNoCursor.Create('Cursor not available!');
|
|
end;
|
|
end;
|
|
|
|
|
|
function TX2CustomHash.InternalFind(const ABucket: PX2HashBucket;
|
|
const AHash: Cardinal; const AKey: PX2HashCookie;
|
|
const AAllowCreate: Boolean;
|
|
const AExisting: PX2HashValue): PX2HashValue;
|
|
function CreateValue: PX2HashValue;
|
|
begin
|
|
if AExisting = nil then
|
|
begin
|
|
GetMem(Result, SizeOf(TX2HashValue));
|
|
FillChar(Result^, SizeOf(TX2HashValue), #0);
|
|
|
|
Result^.ID := HIDValue;
|
|
Result^.Key := KeyManager.Clone(AKey);
|
|
Inc(FCount);
|
|
end else
|
|
Result := AExisting;
|
|
|
|
InvalidateCursor;
|
|
end;
|
|
|
|
var
|
|
bucketCount: Integer;
|
|
bucketIndex: Integer;
|
|
bucket: PX2HashBucket;
|
|
key: Pointer;
|
|
nextValue: PX2HashValue;
|
|
value: PX2HashValue;
|
|
|
|
begin
|
|
Result := nil;
|
|
bucketIndex := (AHash and $FF);
|
|
|
|
if ABucket^.Items[bucketIndex] = nil then
|
|
begin
|
|
if AAllowCreate then
|
|
begin
|
|
// New value
|
|
Result := CreateValue;
|
|
ABucket^.Items[bucketIndex] := PX2HashItem(Result);
|
|
Inc(ABucket^.Count);
|
|
end;
|
|
end else
|
|
case ABucket^.Items[bucketIndex]^.ID of
|
|
HIDBucket:
|
|
// Bucket, continue down
|
|
Result := InternalFind(PX2HashBucket(ABucket^.Items[bucketIndex]),
|
|
ROR(AHash), AKey, AAllowCreate);
|
|
HIDValue:
|
|
begin
|
|
bucketCount := 0;
|
|
value := PX2HashValue(ABucket^.Items[bucketIndex]);
|
|
while Assigned(value) do
|
|
begin
|
|
if KeyManager.Compare(value^.Key, AKey) then
|
|
begin
|
|
// Found existing key
|
|
Result := value;
|
|
exit;
|
|
end;
|
|
|
|
value := value^.Next;
|
|
Inc(bucketCount);
|
|
end;
|
|
|
|
if AAllowCreate then
|
|
if (bucketCount >= BucketSize) then
|
|
begin
|
|
// Bucket full
|
|
GetMem(bucket, SizeOf(TX2HashBucket));
|
|
FillChar(bucket^, SizeOf(TX2HashBucket), #0);
|
|
bucket^.ID := HIDBucket;
|
|
bucket^.Level := ABucket^.Level + 1;
|
|
|
|
value := PX2HashValue(ABucket^.Items[bucketIndex]);
|
|
while Assigned(value) do
|
|
begin
|
|
// Transfer item
|
|
key := KeyManager.Clone(value^.Key);
|
|
nextValue := value^.Next;
|
|
value^.Next := nil;
|
|
|
|
InternalFind(bucket, ROR(KeyManager.Hash(key), bucket^.Level * 8),
|
|
key, True, value);
|
|
|
|
value := nextValue;
|
|
end;
|
|
|
|
Result := InternalFind(bucket, ROR(AHash), AKey, True);
|
|
ABucket^.Items[bucketIndex] := PX2HashItem(bucket);
|
|
end else
|
|
begin
|
|
// New value
|
|
Result := CreateValue;
|
|
Result^.Next := PX2HashValue(ABucket^.Items[bucketIndex]);
|
|
ABucket^.Items[bucketIndex] := PX2HashItem(Result);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TX2CustomHash.InternalDelete(const ABucket: PX2HashBucket;
|
|
const AHash: Cardinal;
|
|
const AKey: PX2HashCookie): Boolean;
|
|
var
|
|
iIndex: Integer;
|
|
pBucket: PX2HashBucket;
|
|
pPrev: PX2HashValue;
|
|
pValue: PX2HashValue;
|
|
|
|
begin
|
|
Result := False;
|
|
iIndex := (AHash and $FF);
|
|
|
|
if Assigned(ABucket^.Items[iIndex]) then
|
|
case ABucket^.Items[iIndex]^.ID of
|
|
HIDBucket:
|
|
begin
|
|
// Bucket, continue down
|
|
pBucket := PX2HashBucket(ABucket^.Items[iIndex]);
|
|
Result := InternalDelete(pBucket, ROR(AHash), AKey);
|
|
|
|
if pBucket^.Count = 0 then
|
|
begin
|
|
FreeMem(pBucket, SizeOf(TX2HashBucket));
|
|
ABucket^.Items[iIndex] := nil;
|
|
end;
|
|
end;
|
|
HIDValue:
|
|
begin
|
|
pPrev := nil;
|
|
pValue := PX2HashValue(ABucket^.Items[iIndex]);
|
|
while Assigned(pValue) do
|
|
begin
|
|
if KeyManager.Compare(pValue^.Key, AKey) then
|
|
begin
|
|
// Found key
|
|
if pPrev = nil then
|
|
begin
|
|
ABucket^.Items[iIndex] := PX2HashItem(pValue^.Next);
|
|
if ABucket^.Items[iIndex] = nil then
|
|
Dec(ABucket^.Count);
|
|
end else
|
|
pPrev^.Next := pValue^.Next;
|
|
|
|
KeyManager.FreeCookie(pValue^.Key);
|
|
ValueManager.FreeCookie(pValue^.Value);
|
|
FreeMem(pValue, SizeOf(TX2HashValue));
|
|
Dec(FCount);
|
|
|
|
Result := True;
|
|
exit;
|
|
end;
|
|
|
|
pPrev := pValue;
|
|
pValue := pValue^.Next;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TX2CustomHash.Find(const AKey: PX2HashCookie; const AAllowCreate: Boolean): PX2HashValue;
|
|
var
|
|
cookie: PX2HashCookie;
|
|
|
|
begin
|
|
Result := nil;
|
|
try
|
|
if not Assigned(FRoot) then
|
|
if AAllowCreate then
|
|
begin
|
|
// Create root bucket
|
|
GetMem(FRoot, SizeOf(TX2HashBucket));
|
|
FillChar(FRoot^, SizeOf(TX2HashBucket), #0);
|
|
FRoot^.ID := HIDBucket;
|
|
end else
|
|
exit;
|
|
|
|
Result := InternalFind(FRoot, KeyManager.Hash(AKey), AKey, AAllowCreate);
|
|
finally
|
|
cookie := AKey;
|
|
KeyManager.FreeCookie(cookie);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TX2CustomHash.Clear;
|
|
procedure DestroyBucket(const ABucket: PX2HashBucket);
|
|
var
|
|
iItem: Integer;
|
|
pNext: PX2HashValue;
|
|
pValue: PX2HashValue;
|
|
|
|
begin
|
|
for iItem := Pred(LeafSize) downto 0 do
|
|
if Assigned(ABucket^.Items[iItem]) then
|
|
case ABucket^.Items[iItem].ID of
|
|
HIDBucket:
|
|
DestroyBucket(PX2HashBucket(ABucket^.Items[iItem]));
|
|
HIDValue:
|
|
begin
|
|
pValue := PX2HashValue(ABucket^.Items[iItem]);
|
|
repeat
|
|
KeyManager.FreeCookie(pValue^.Key);
|
|
ValueManager.FreeCookie(pValue^.Value);
|
|
|
|
pNext := pValue^.Next;
|
|
FreeMem(pValue, SizeOf(TX2HashValue));
|
|
pValue := pNext;
|
|
until pValue = nil;
|
|
end;
|
|
end;
|
|
|
|
FreeMem(ABucket, SizeOf(TX2HashBucket));
|
|
end;
|
|
|
|
begin
|
|
if Assigned(FRoot) then
|
|
begin
|
|
DestroyBucket(FRoot);
|
|
InvalidateCursor;
|
|
FCount := 0;
|
|
FRoot := nil;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TX2CustomHash.Exists(const AKey: PX2HashCookie): Boolean;
|
|
begin
|
|
Result := Assigned(Find(AKey, False));
|
|
end;
|
|
|
|
|
|
function TX2CustomHash.Delete(const AKey: PX2HashCookie): Boolean;
|
|
var
|
|
cookie: PX2HashCookie;
|
|
|
|
begin
|
|
try
|
|
Result := False;
|
|
if not Assigned(FRoot) then
|
|
exit;
|
|
|
|
Result := InternalDelete(FRoot, KeyManager.Hash(AKey), AKey);
|
|
if Result then
|
|
InvalidateCursor;
|
|
finally
|
|
cookie := AKey;
|
|
KeyManager.FreeCookie(cookie);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TX2CustomHash.SetValue(const AValue: PX2HashValue;
|
|
const AData: Pointer);
|
|
begin
|
|
ValueManager.FreeCookie(AValue^.Value);
|
|
AValue^.Value := AData;
|
|
end;
|
|
|
|
|
|
procedure TX2CustomHash.First;
|
|
begin
|
|
if not CursorRequired(False) then
|
|
exit;
|
|
|
|
Cursor.First;
|
|
end;
|
|
|
|
|
|
function TX2CustomHash.Next: Boolean;
|
|
begin
|
|
Result := False;
|
|
if not CursorRequired(False) then
|
|
exit;
|
|
|
|
Result := Cursor.Next;
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Delphi 2006 enumerator support'}
|
|
{$ENDIF}
|
|
{========================================
|
|
TX2HashEnumerator
|
|
========================================}
|
|
constructor TX2HashEnumerator.Create(const AHash: TX2CustomHash;
|
|
const AEnumKeys: Boolean);
|
|
begin
|
|
inherited Create;
|
|
|
|
FEnumKeys := AEnumKeys;
|
|
if AEnumKeys then
|
|
FManager := AHash.KeyManager
|
|
else
|
|
FManager := AHash.ValueManager;
|
|
|
|
FCursor := AHash.CreateCursor;
|
|
end;
|
|
|
|
|
|
destructor TX2HashEnumerator.Destroy;
|
|
begin
|
|
FreeAndNil(FCursor);
|
|
|
|
inherited;
|
|
end;
|
|
|
|
|
|
function TX2HashEnumerator.GetCursor: PX2HashCookie;
|
|
begin
|
|
if FEnumKeys then
|
|
Result := FCursor.Current^.Key
|
|
else
|
|
Result := FCursor.Current^.Value;
|
|
end;
|
|
|
|
|
|
function TX2HashEnumerator.MoveNext: Boolean;
|
|
begin
|
|
Result := False;
|
|
if Assigned(FCursor) then
|
|
Result := FCursor.Next;
|
|
end;
|
|
|
|
|
|
{ TX2HashPointerEnumerator }
|
|
function TX2HashPointerEnumerator.GetCurrent: Pointer;
|
|
begin
|
|
Result := TX2HashPointerManager(Manager).GetValue(Cursor);
|
|
end;
|
|
|
|
|
|
{ TX2HashIntegerEnumerator }
|
|
function TX2HashIntegerEnumerator.GetCurrent: Integer;
|
|
begin
|
|
Result := TX2HashIntegerManager(Manager).GetValue(Cursor);
|
|
end;
|
|
|
|
|
|
{ TX2HashObjectEnumerator }
|
|
function TX2HashObjectEnumerator.GetCurrent: TObject;
|
|
begin
|
|
Result := TX2HashObjectManager(Manager).GetValue(Cursor);
|
|
end;
|
|
|
|
|
|
{ TX2HashStringEnumerator }
|
|
function TX2HashStringEnumerator.GetCurrent: String;
|
|
begin
|
|
Result := TX2HashStringManager(Manager).GetValue(Cursor);
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Base hash classes'}
|
|
{$ENDIF}
|
|
{========================================
|
|
TX2CustomPointerHash
|
|
========================================}
|
|
function TX2CustomPointerHash.CreateKeyManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashPointerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2CustomPointerHash.GetCurrentKey: Pointer;
|
|
begin
|
|
CursorRequired;
|
|
Result := KeyManager.GetValue(Cursor.Current^.Key);
|
|
end;
|
|
|
|
|
|
function TX2CustomPointerHash.GetEnumerator: TX2HashPointerEnumerator;
|
|
begin
|
|
Result := TX2HashPointerEnumerator.Create(Self, True);
|
|
end;
|
|
|
|
|
|
function TX2CustomPointerHash.Find(const AKey: Pointer;
|
|
const AAllowCreate: Boolean): PX2HashValue;
|
|
begin
|
|
Result := inherited Find(KeyManager.CreateCookie(AKey), AAllowCreate);
|
|
end;
|
|
|
|
|
|
function TX2CustomPointerHash.Exists(const AKey: Pointer): Boolean;
|
|
begin
|
|
Result := inherited Exists(KeyManager.CreateCookie(AKey));
|
|
end;
|
|
|
|
|
|
function TX2CustomPointerHash.Delete(const AKey: Pointer): Boolean;
|
|
begin
|
|
Result := inherited Delete(KeyManager.CreateCookie(AKey));
|
|
end;
|
|
|
|
|
|
function TX2CustomPointerHash.GetKeyManager: TX2HashPointerManager;
|
|
begin
|
|
Result := TX2HashPointerManager(inherited KeyManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2CustomIntegerHash
|
|
========================================}
|
|
function TX2CustomIntegerHash.CreateKeyManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashIntegerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2CustomIntegerHash.GetCurrentKey: Integer;
|
|
begin
|
|
CursorRequired;
|
|
Result := KeyManager.GetValue(Cursor.Current^.Key);
|
|
end;
|
|
|
|
|
|
function TX2CustomIntegerHash.GetEnumerator: TX2HashIntegerEnumerator;
|
|
begin
|
|
Result := TX2HashIntegerEnumerator.Create(Self, True);
|
|
end;
|
|
|
|
|
|
function TX2CustomIntegerHash.Find(const AKey: Integer;
|
|
const AAllowCreate: Boolean): PX2HashValue;
|
|
begin
|
|
Result := inherited Find(KeyManager.CreateCookie(AKey), AAllowCreate);
|
|
end;
|
|
|
|
|
|
function TX2CustomIntegerHash.Exists(const AKey: Integer): Boolean;
|
|
begin
|
|
Result := inherited Exists(KeyManager.CreateCookie(AKey));
|
|
end;
|
|
|
|
|
|
function TX2CustomIntegerHash.Delete(const AKey: Integer): Boolean;
|
|
begin
|
|
Result := inherited Delete(KeyManager.CreateCookie(AKey));
|
|
end;
|
|
|
|
|
|
function TX2CustomIntegerHash.GetKeyManager: TX2HashIntegerManager;
|
|
begin
|
|
Result := TX2HashIntegerManager(inherited KeyManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2CustomObjectHash
|
|
========================================}
|
|
function TX2CustomObjectHash.CreateKeyManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashObjectManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2CustomObjectHash.GetCurrentKey: TObject;
|
|
begin
|
|
CursorRequired;
|
|
Result := KeyManager.GetValue(Cursor.Current^.Key);
|
|
end;
|
|
|
|
|
|
function TX2CustomObjectHash.GetEnumerator: TX2HashObjectEnumerator;
|
|
begin
|
|
Result := TX2HashObjectEnumerator.Create(Self, True);
|
|
end;
|
|
|
|
|
|
function TX2CustomObjectHash.Find(const AKey: TObject;
|
|
const AAllowCreate: Boolean): PX2HashValue;
|
|
begin
|
|
Result := inherited Find(KeyManager.CreateCookie(AKey), AAllowCreate);
|
|
end;
|
|
|
|
|
|
function TX2CustomObjectHash.Exists(const AKey: TObject): Boolean;
|
|
begin
|
|
Result := inherited Exists(KeyManager.CreateCookie(AKey));
|
|
end;
|
|
|
|
|
|
function TX2CustomObjectHash.Delete(const AKey: TObject): Boolean;
|
|
begin
|
|
Result := inherited Delete(KeyManager.CreateCookie(AKey));
|
|
end;
|
|
|
|
|
|
function TX2CustomObjectHash.GetKeyManager: TX2HashObjectManager;
|
|
begin
|
|
Result := TX2HashObjectManager(inherited KeyManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2CustomStringHash
|
|
========================================}
|
|
function TX2CustomStringHash.CreateKeyManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashStringManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2CustomStringHash.GetCurrentKey: String;
|
|
begin
|
|
CursorRequired;
|
|
Result := TX2HashStringManager(KeyManager).GetValue(Cursor.Current^.Key);
|
|
end;
|
|
|
|
|
|
function TX2CustomStringHash.GetEnumerator: TX2HashStringEnumerator;
|
|
begin
|
|
Result := TX2HashStringEnumerator.Create(Self, True);
|
|
end;
|
|
|
|
|
|
function TX2CustomStringHash.Find(const AKey: String;
|
|
const AAllowCreate: Boolean): PX2HashValue;
|
|
begin
|
|
Result := inherited Find(KeyManager.CreateCookie(AKey), AAllowCreate);
|
|
end;
|
|
|
|
|
|
function TX2CustomStringHash.Exists(const AKey: String): Boolean;
|
|
begin
|
|
Result := inherited Exists(KeyManager.CreateCookie(AKey));
|
|
end;
|
|
|
|
|
|
function TX2CustomStringHash.Delete(const AKey: String): Boolean;
|
|
begin
|
|
Result := inherited Delete(KeyManager.CreateCookie(AKey));
|
|
end;
|
|
|
|
|
|
function TX2CustomStringHash.GetKeyManager: TX2HashStringManager;
|
|
begin
|
|
Result := TX2HashStringManager(inherited KeyManager);
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
|
|
|
|
{$REGION 'Concrete hash classes'}
|
|
{$ENDIF}
|
|
{========================================
|
|
TX2PPHash
|
|
========================================}
|
|
function TX2PPHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashPointerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2PPHash.GetCurrentValue: Pointer;
|
|
begin
|
|
CursorRequired;
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2PPHash.GetValue(Key: Pointer): Pointer;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := nil;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2PPHash.SetValue(Key: Pointer; const Value: Pointer);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2PPHash.GetValueManager: TX2HashPointerManager;
|
|
begin
|
|
Result := TX2HashPointerManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2PIHash
|
|
========================================}
|
|
function TX2PIHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashIntegerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2PIHash.GetCurrentValue: Integer;
|
|
begin
|
|
CursorRequired;
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2PIHash.GetValue(Key: Pointer): Integer;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := 0;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2PIHash.SetValue(Key: Pointer; const Value: Integer);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2PIHash.GetValueManager: TX2HashIntegerManager;
|
|
begin
|
|
Result := TX2HashIntegerManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2POHash
|
|
========================================}
|
|
constructor TX2POHash.Create(const AOwnsObjects: Boolean);
|
|
begin
|
|
inherited Create;
|
|
OwnsObjects := AOwnsObjects;
|
|
end;
|
|
|
|
|
|
function TX2POHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashObjectManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2POHash.GetCurrentValue: TObject;
|
|
begin
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2POHash.GetOwnsObjects: Boolean;
|
|
begin
|
|
Result := ValueManager.OwnsObjects;
|
|
end;
|
|
|
|
|
|
procedure TX2POHash.SetOwnsObjects(const Value: Boolean);
|
|
begin
|
|
ValueManager.OwnsObjects := Value;
|
|
end;
|
|
|
|
|
|
function TX2POHash.GetValue(Key: Pointer): TObject;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := nil;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2POHash.SetValue(Key: Pointer; const Value: TObject);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2POHash.GetValueManager: TX2HashObjectManager;
|
|
begin
|
|
Result := TX2HashObjectManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2PSHash
|
|
========================================}
|
|
function TX2PSHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashStringManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2PSHash.GetCurrentValue: String;
|
|
begin
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2PSHash.GetValue(Key: Pointer): String;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := '';
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2PSHash.SetValue(Key: Pointer; const Value: String);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2PSHash.GetValueManager: TX2HashStringManager;
|
|
begin
|
|
Result := TX2HashStringManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2IPHash
|
|
========================================}
|
|
function TX2IPHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashPointerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2IPHash.GetCurrentValue: Pointer;
|
|
begin
|
|
CursorRequired;
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2IPHash.GetValue(Key: Integer): Pointer;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := nil;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2IPHash.SetValue(Key: Integer; const Value: Pointer);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2IPHash.GetValueManager: TX2HashPointerManager;
|
|
begin
|
|
Result := TX2HashPointerManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2IIHash
|
|
========================================}
|
|
function TX2IIHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashIntegerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2IIHash.GetCurrentValue: Integer;
|
|
begin
|
|
CursorRequired;
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2IIHash.GetValue(Key: Integer): Integer;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := 0;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2IIHash.SetValue(Key: Integer; const Value: Integer);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2IIHash.GetValueManager: TX2HashIntegerManager;
|
|
begin
|
|
Result := TX2HashIntegerManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2IOHash
|
|
========================================}
|
|
constructor TX2IOHash.Create(const AOwnsObjects: Boolean);
|
|
begin
|
|
inherited Create;
|
|
OwnsObjects := AOwnsObjects;
|
|
end;
|
|
|
|
|
|
function TX2IOHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashObjectManager.Create;
|
|
end;
|
|
|
|
function TX2IOHash.GetCurrentValue: TObject;
|
|
begin
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2IOHash.GetOwnsObjects: Boolean;
|
|
begin
|
|
Result := ValueManager.OwnsObjects;
|
|
end;
|
|
|
|
|
|
procedure TX2IOHash.SetOwnsObjects(const Value: Boolean);
|
|
begin
|
|
ValueManager.OwnsObjects := Value;
|
|
end;
|
|
|
|
|
|
function TX2IOHash.GetValue(Key: Integer): TObject;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := nil;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2IOHash.SetValue(Key: Integer; const Value: TObject);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2IOHash.GetValueManager: TX2HashObjectManager;
|
|
begin
|
|
Result := TX2HashObjectManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2ISHash
|
|
========================================}
|
|
function TX2ISHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashStringManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2ISHash.GetCurrentValue: String;
|
|
begin
|
|
Result := TX2HashStringManager(ValueManager).GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2ISHash.GetValue(Key: Integer): String;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := '';
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2ISHash.SetValue(Key: Integer; const Value: String);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2ISHash.GetValueManager: TX2HashStringManager;
|
|
begin
|
|
Result := TX2HashStringManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2OPHash
|
|
========================================}
|
|
function TX2OPHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashPointerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2OPHash.GetCurrentValue: Pointer;
|
|
begin
|
|
CursorRequired;
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2OPHash.GetValue(Key: TObject): Pointer;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := nil;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2OPHash.SetValue(Key: TObject; const Value: Pointer);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2OPHash.GetValueManager: TX2HashPointerManager;
|
|
begin
|
|
Result := TX2HashPointerManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2OIHash
|
|
========================================}
|
|
function TX2OIHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashIntegerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2OIHash.GetCurrentValue: Integer;
|
|
begin
|
|
CursorRequired;
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2OIHash.GetValue(Key: TObject): Integer;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := 0;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2OIHash.SetValue(Key: TObject; const Value: Integer);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2OIHash.GetValueManager: TX2HashIntegerManager;
|
|
begin
|
|
Result := TX2HashIntegerManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2OOHash
|
|
========================================}
|
|
constructor TX2OOHash.Create(const AOwnsObjects: Boolean);
|
|
begin
|
|
inherited Create;
|
|
OwnsObjects := AOwnsObjects;
|
|
end;
|
|
|
|
|
|
function TX2OOHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashObjectManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2OOHash.GetCurrentValue: TObject;
|
|
begin
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2OOHash.GetOwnsObjects: Boolean;
|
|
begin
|
|
Result := ValueManager.OwnsObjects;
|
|
end;
|
|
|
|
|
|
procedure TX2OOHash.SetOwnsObjects(const Value: Boolean);
|
|
begin
|
|
TX2HashObjectManager(ValueManager).OwnsObjects := Value;
|
|
end;
|
|
|
|
|
|
function TX2OOHash.GetValue(Key: TObject): TObject;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := nil;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2OOHash.SetValue(Key: TObject; const Value: TObject);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2OOHash.GetValueManager: TX2HashObjectManager;
|
|
begin
|
|
Result := TX2HashObjectManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2OSHash
|
|
========================================}
|
|
function TX2OSHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashStringManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2OSHash.GetCurrentValue: String;
|
|
begin
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2OSHash.GetValue(Key: TObject): String;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := '';
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2OSHash.SetValue(Key: TObject; const Value: String);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2OSHash.GetValueManager: TX2HashStringManager;
|
|
begin
|
|
Result := TX2HashStringManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2SPHash
|
|
========================================}
|
|
function TX2SPHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashPointerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2SPHash.GetCurrentValue: Pointer;
|
|
begin
|
|
CursorRequired;
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2SPHash.GetValue(Key: String): Pointer;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := nil;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2SPHash.SetValue(Key: String; const Value: Pointer);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2SPHash.GetValueManager: TX2HashPointerManager;
|
|
begin
|
|
Result := TX2HashPointerManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2SIHash
|
|
========================================}
|
|
function TX2SIHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashIntegerManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2SIHash.GetCurrentValue: Integer;
|
|
begin
|
|
CursorRequired;
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2SIHash.GetValue(Key: String): Integer;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := 0;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2SIHash.SetValue(Key: String; const Value: Integer);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2SIHash.GetValueManager: TX2HashIntegerManager;
|
|
begin
|
|
Result := TX2HashIntegerManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2SOHash
|
|
========================================}
|
|
constructor TX2SOHash.Create(const AOwnsObjects: Boolean);
|
|
begin
|
|
inherited Create;
|
|
OwnsObjects := AOwnsObjects;
|
|
end;
|
|
|
|
|
|
function TX2SOHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashObjectManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2SOHash.GetCurrentValue: TObject;
|
|
begin
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2SOHash.GetOwnsObjects: Boolean;
|
|
begin
|
|
Result := ValueManager.OwnsObjects;
|
|
end;
|
|
|
|
|
|
procedure TX2SOHash.SetOwnsObjects(const Value: Boolean);
|
|
begin
|
|
TX2HashObjectManager(ValueManager).OwnsObjects := Value;
|
|
end;
|
|
|
|
|
|
function TX2SOHash.GetValue(Key: String): TObject;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := nil;
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2SOHash.SetValue(Key: String; const Value: TObject);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2SOHash.GetValueManager: TX2HashObjectManager;
|
|
begin
|
|
Result := TX2HashObjectManager(inherited ValueManager);
|
|
end;
|
|
|
|
|
|
{========================================
|
|
TX2SSHash
|
|
========================================}
|
|
function TX2SSHash.CreateValueManager: TX2CustomHashManager;
|
|
begin
|
|
Result := TX2HashStringManager.Create;
|
|
end;
|
|
|
|
|
|
function TX2SSHash.GetCurrentValue: String;
|
|
begin
|
|
Result := ValueManager.GetValue(Cursor.Current^.Value);
|
|
end;
|
|
|
|
|
|
function TX2SSHash.GetValue(Key: String): String;
|
|
var
|
|
item: PX2HashValue;
|
|
|
|
begin
|
|
Result := '';
|
|
item := Find(Key, False);
|
|
if Assigned(item) then
|
|
Result := ValueManager.GetValue(item^.Value);
|
|
end;
|
|
|
|
|
|
procedure TX2SSHash.SetValue(Key: String; const Value: String);
|
|
begin
|
|
inherited SetValue(Find(Key, True), ValueManager.CreateCookie(Value));
|
|
end;
|
|
|
|
|
|
function TX2SSHash.GetValueManager: TX2HashStringManager;
|
|
begin
|
|
Result := TX2HashStringManager(inherited ValueManager);
|
|
end;
|
|
{$IFDEF D2005PLUS}
|
|
{$ENDREGION}
|
|
{$ENDIF}
|
|
|
|
|
|
initialization
|
|
CRC32Init;
|
|
|
|
end.
|
|
|