ArrayList: Generic Java-/JavaScript-class for handling a list of values for FreePascal and Delphi

gistfile1.pas

(**
  * ArrayList.pas
  * Provides a Java-/JavaScript-like generic class for handling a list of
  * values
  *
  * This is free and unencumbered software released into the public domain.
  *
  * Anyone is free to copy, modify, publish, use, compile, sell, or
  * distribute this software, either in source code form or as a compiled
  * binary, for any purpose, commercial or non-commercial, and by any
  * means.
  *
  * In jurisdictions that recognize copyright laws, the author or authors
  * of this software dedicate any and all copyright interest in the
  * software to the public domain. We make this dedication for the benefit
  * of the public at large and to the detriment of our heirs and
  * successors. We intend this dedication to be an overt act of
  * relinquishment in perpetuity of all present and future rights to this
  * software under copyright law.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  *
  * For more information, please refer to <http://unlicense.org/>
  *
  *)
unit ArrayList;

{$ifdef fpc}
  {$mode delphi}
{$endif}

interface

uses
  SysUtils, Classes;

type
  TArrayList<T> = class
  private
    fArray: array of T;
    fSize: Integer;

    function Grow(): Integer;
    function Shrink(): Integer;

    function GetValue(anIndex: Integer): T;
    procedure SetValue(anIndex: Integer; aValue: T);
  public
    constructor Create(); Overload;
    constructor Create(aValue: array of T); Overload;

    destructor Destroy(); Override;

    procedure Clear();

    procedure Push(const aValue: T);
    function Pop(): T;
  public
    property Value[Index: Integer]: T read GetValue write SetValue; default;
  published
    property Size: Integer read fSize;
  end;

implementation

function TArrayList<T>.Grow(): Integer;
var
  oldLength: Integer;
begin
  oldLength := fSize;

  fSize := fSize + 1;
  SetLength(fArray, fSize);
  
  Result := oldLength;
end;

function TArrayList<T>.Shrink(): Integer;
var
  oldLength: Integer;
begin
  oldLength := fSize;

  fSize := fSize - 1;
  SetLength(fArray, fSize);
  
  Result := oldLength;
end;

function TArrayList<T>.GetValue(anIndex: Integer): T;
begin
  if anIndex < 0 then anIndex := 0;
  if anIndex > fSize - 1 then anIndex := fSize - 1;
  Result := fArray[anIndex];
end;

procedure TArrayList<T>.SetValue(anIndex: Integer; aValue: T);
begin
  if anIndex < 0 then anIndex := 0;
  if anIndex > fSize - 1 then anIndex := fSize - 1;
  fArray[anIndex] := aValue;
end;

constructor TArrayList<T>.Create();
begin
  Self.Clear();
end;

constructor TArrayList<T>.Create(aValue: array of T);
var
  i, len: Integer;
begin
  Create;

  len := Length(aValue) - 1;

  for i := 0 to len do
  begin
    Self.Push(aValue[i]);
  end;
end;

destructor TArrayList<T>.Destroy;
begin
  inherited Destroy;
end;

procedure TArrayList<T>.Clear();
begin
  fSize := 0;
  SetLength(fArray, fSize);
end;

procedure TArrayList<T>.Push(const aValue: T);
var
  newPos: Integer;
begin
  newPos := Self.Grow();
  fArray[newPos] := aValue;
end;

function TArrayList<T>.Pop(): T;
var
  poppedValue: T;
begin
  poppedValue := fArray[fSize - 1];

  Result := poppedValue;

  Self.Shrink();
end;

end.