unit baseiter;

interface

uses
  iterimpl;

type
  // Base iterator interfaces
  IIterator<T> = interface
    function Next(out AValue: T): Boolean;
  end;

  IGenericIterator = IIterator<Pointer>;
  IStringIterator = IIterator<String>;
  IIntegerIterator = IIterator<Integer>;
  IFloatIterator = IIterator<Double>;

  IResettable = interface
  ['{3CC2EE46-A542-4954-BCC0-523C68B60089}']
    procedure Reset;
  end;

// --------

  // Base iterator classes
  TIterator<T> = class(TInterfacedObject, IIterator<T>)
  private
    FCurrent: T;
    function NopGetCurrent: TObject;
  public
    function Next(out AValue: T): Boolean; virtual; abstract;
    procedure Reset; virtual;
    // IEnumerator
    function MoveNext: Boolean;
    function GetCurrent: T;
    property Current: T read GetCurrent;
    // for-in support
    function GetEnumerator: TIterator<T>;
    function Copy: TIterator<T>;
  end;

  TGenericIterator = TIterator<Pointer>;
  TStringIterator = TIterator<String>;
  TIntegerIterator = TIterator<Integer>;
  TFloatIterator = TIterator<Double>;

// --------

  // Base fiber iterator classes
  TBaseIterator<T> = class(TIterator<T>, IResettable)
  private
    FIter: TFiberIterator;
  protected
    procedure Yield(const AValue: T);
    procedure Iterate; virtual; //abstract;
  public
    constructor Create(AStackSize: Integer =cDefStackSize);
    destructor Destroy; override;
    function Next(out AValue: T): Boolean; override; final;
    procedure Reset; override; final;
  end;

  TBaseGenericIterator = TBaseIterator<Pointer>;
  TBaseStringIterator = TBaseIterator<String>;
  TBaseIntegerIterator = TBaseIterator<Integer>;
  TBaseFloatIterator = TBaseIterator<Double>;

  // *optional* way to stop iterator early
  // do not catch
  EStopIteration = iterimpl.EStopIteration;

// --------

type
  TExtIterator<T> = class(TIterator<T>)
  private
    FIter: TIterator<T>;
  public
    constructor Create(AIter: TIterator<T>);
    function Next(out AValue: T): Boolean; override;
    procedure Reset; override;
  end;

  TIterateMethod = procedure of object;

function CreateFiberIterator(ADoIterate: TIterateMethod;
  AStackSize: Integer): TFiberIterator;

implementation

type
  TMethodIterator = class(TFiberIterator)
  private
    FDoIterate: TIterateMethod;
  protected
    procedure Iterate; override;
  public
    constructor Create(ADoIterate: TIterateMethod;
      AStackSize: Integer);
  end;

{ TExtIterator<T> }
constructor TExtIterator<T>.Create(AIter: TIterator<T>);
begin
  inherited Create;
  FIter := AIter;
end;

function TExtIterator<T>.Next(out AValue: T): Boolean;
begin
  Result := FIter.Next(AValue);
end;

procedure TExtIterator<T>.Reset;
begin
  FIter.Reset;
end;

{ TIterator<T> }
function TIterator<T>.MoveNext: Boolean;
begin
  Result := Next(FCurrent);
end;

function TIterator<T>.NopGetCurrent: TObject;
begin
  Result := nil;
end;

function TIterator<T>.GetCurrent: T;
begin
  Result := FCurrent;
end;

procedure TIterator<T>.Reset;
begin
  // do nothing
end;

function TIterator<T>.GetEnumerator: TIterator<T>;
begin
  Result := Self;
end;

function TIterator<T>.Copy: TIterator<T>;
begin
  Result := TExtIterator<T>.Create(Self);
end;

function CreateFiberIterator(ADoIterate: TIterateMethod;
  AStackSize: Integer): TFiberIterator;
begin
  Result := TMethodIterator.Create(ADoIterate, AStackSize);
end;

{ TMethodIterator }
constructor TMethodIterator.Create(ADoIterate: TIterateMethod;
  AStackSize: Integer);
begin
  inherited Create(AStackSize);
  FDoIterate := ADoIterate;
end;

procedure TMethodIterator.Iterate;
begin
  FDoIterate;
end;

{ TBaseIterator<T> }
constructor TBaseIterator<T>.Create(AStackSize: Integer);
begin
  inherited Create;
  FIter := CreateFiberIterator(Iterate, AStackSize);
end;

destructor TBaseIterator<T>.Destroy;
begin
  FIter.Free;
  inherited;
end;

procedure TBaseIterator<T>.Yield(const AValue: T);
begin
  FIter.Yield(Addr(AValue));
end;

procedure TBaseIterator<T>.Iterate;
begin

end;

function TBaseIterator<T>.Next(out AValue: T): Boolean;
var
  Value: Pointer;
begin
  Result := FIter.GetNext(Value);
  if Value <> nil then
    AValue := T(Value^);
end;

procedure TBaseIterator<T>.Reset;
begin
  FIter.Reset;
end;

end.