arrayhelpers.pas

//-----------------------------------------------------------------------------------
//  Helpers Package © 2026 by Alexander Tverskoy
//  Licensed under the MIT License
//  You may obtain a copy of the License at https://opensource.org/licenses/MIT
//-----------------------------------------------------------------------------------

unit arrayhelpers;

{$mode objfpc}{$H+}
{$modeswitch typehelpers}

interface

uses
  Classes,
  Math,
  SysUtils;

type
  TIntegerArray = array of integer;

type

  { TIntegerArrayHelper }

  TIntegerArrayHelper = type helper for TIntegerArray
  public
    /// Inserts a value at the specified position, shifting elements by an optional delta
    procedure InsertAtPos(Pos, Value: integer; Delta: integer = 0);

    /// Deletes the element at the given position from the array
    procedure DeleteAtPos(Pos: integer);

    /// Creates and returns an independent copy of the source array
    function CloneArray: TIntegerArray;

    /// Copies all elements from the source array into the destination array
    procedure CopyToArray(const Dest: TIntegerArray);
  end;

  { TStringArrayHelper }

  TStringArrayHelper = type helper for TStringArray
  public
    // Append all elements from another array to the current array
    procedure AddArray(const AOther: TStringArray);

    // Return a new array that combines current array and another array
    function ConcatArray(const AOther: TStringArray): TStringArray;
  end;

implementation

{ TIntegerArrayHelper }

procedure TIntegerArrayHelper.InsertAtPos(Pos, Value: integer; Delta: integer = 0);
var
  i, Len: integer;
begin
  Len := Length(Self);
  if (Pos < 0) or (Pos > Len) then
    Exit; // Out of bounds

  // Increase array size
  SetLength(Self, Len + 1);

  // Shift elements to the right
  for i := Len - 1 downto Pos do
    Self[i + 1] := Self[i];

  // Insert new value
  Self[Pos] := Value;

  // Increase all following elements by Delta
  for i := Pos + 1 to High(Self) do
    Self[i] := Self[i] + Delta;
end;

procedure TIntegerArrayHelper.DeleteAtPos(Pos: integer);
var
  i, Len: integer;
begin
  Len := Length(Self);
  if (Pos < 0) or (Pos >= Len) then
    Exit; // Out of bounds

  // Shift left
  for i := Pos to Len - 2 do
    Self[i] := Self[i + 1];

  // Decrease array size
  SetLength(Self, Len - 1);
end;

function TIntegerArrayHelper.CloneArray: TIntegerArray;
begin
  Result := Copy(Self, 0, Length(Self));
end;

procedure TIntegerArrayHelper.CopyToArray(const Dest: TIntegerArray);
var
  CopyCount, i: integer;
begin
  // Determine how many elements to copy: take the smaller of Dest length and Src length
  CopyCount := Min(Length(Dest), Length(Self));
  for i := 0 to CopyCount - 1 do
    Dest[i] := Self[i];
end;

{ TStringArrayHelper }

procedure TStringArrayHelper.AddArray(const AOther: TStringArray);
var
  OldLen: integer;
  i: integer;
begin
  OldLen := Length(Self);
  SetLength(Self, OldLen + Length(AOther));

  for i := 0 to High(AOther) do
    Self[OldLen + i] := AOther[i];
end;

function TStringArrayHelper.ConcatArray(const AOther: TStringArray): TStringArray;
var
  i: integer;
begin
  Result := nil;
  SetLength(Result, Length(Self) + Length(AOther));

  // Copy current array
  for i := 0 to High(Self) do
    Result[i] := Self[i];

  // Copy other array
  for i := 0 to High(AOther) do
    Result[Length(Self) + i] := AOther[i];
end;

end.