unit UMap;

interface

uses
  UList;

type
  TMap<T: class> = class
  private type
    TBlock = class
    public
      Key: Integer;
      Value: T;
      constructor Create(Key: Integer; Value: T);
    end;

    TBlockList = TList<TBlock>;

  private
    Map: array of TBlockList;

    function Hash(Key: Integer): Integer;
  public
    constructor Create(Size: Integer);
    procedure Add(Key: Integer; Value: T);
    function Get(Key: Integer): T;
    procedure Remove(Key: Integer);
  end;

implementation

{ TMap<K, V> }

function TMap<T>.Hash(Key: Integer): Integer;
begin
  Result := Key;
end;

procedure TMap<T>.Remove(Key: Integer);
var
  Iterator: TBlockList.TIterator;
  Index: Integer;
  Temp: TBlock;
begin
  Index := Hash(Key) mod Length(Map);
  Iterator := Map[Index].GetIterator;
  while Iterator.HasNext do
  begin
    Temp := Iterator.Next;
    if Temp.Key = Key then
      Map[Index].Remove(Temp);
  end;
end;

procedure TMap<T>.Add(Key: Integer; Value: T);
var
  Index: Integer;
begin
  Index := Hash(Key) mod Length(Map);
  Map[Index].Append(TBlock.Create(Key, Value));
end;

constructor TMap<T>.Create(Size: Integer);
var
  I: Integer;
begin
  SetLength(Map, Size);
  for I := Low(Map) to High(Map) do
    Map[I] := TList<TBlock>.Create;
end;

function TMap<T>.Get(Key: Integer): T;
var
  Iterator: TBlockList.TIterator;
  Index: Integer;
  Temp: TBlock;
begin
  Result := Nil;
  Index := Hash(Key) mod Length(Map);
  Iterator := Map[Index].GetIterator;
  while Iterator.HasNext do
  begin
    Temp := Iterator.Next;
    if Temp.Key = Key then
      Result := Temp.Value;
  end;
end;

{ TMap<K, V>.TBlock }

constructor TMap<T>.TBlock.Create(Key: Integer; Value: T);
begin
  Self.Key := Key;
  Self.Value := Value;
end;

end.