// Simplified DoubleLinkedList of Records
// I am <ger-alex@seznam.cz>
//
// LICENSE: both BSD or MIT
//
// Have no idea how exactly Pascal
// handles AnsiStrings
// and if there is any point to
// implement DoubleLinkedList
// whereas Pascal anyway will run throught
// to count references
unit doublelinked;
{$mode objfpc}{$H+}

interface

type
  // copypasted from arlan.pas
  TItem = record
    ItemType: char;
    DisplayString: string;
    Selector: string;
    HostName: string;
    Port: UInt16;
  end;

  PNode = ^TNode;
  TNode = Record
    Item: TItem;
    PreviousNodePtr: PNode;
    NextNodePtr: PNode;
  End;

  TDLinkedList = class
  public
    FirstNodePtr: PNode;
    CurrentNodePtr: PNode;
    procedure Insert(const Item: TItem);
    function MoveBack: TItem;
    function MoveForward: TItem;
    constructor Create(const Item: TItem);
    destructor Destroy;
  end;



implementation

constructor TDLinkedList.Create(const Item: TItem);
begin
  New(CurrentNodePtr);
  CurrentNodePtr^.Item := Item;
  CurrentNodePtr^.PreviousNodePtr := nil;
  CurrentNodePtr^.NextNodePtr := nil;
  FirstNodePtr := CurrentNodePtr;
end;

destructor TDLinkedList.Destroy;
var
NodePtr: PNode;
NextPtr: PNode;
begin
  NodePtr := FirstNodePtr;
  NextPtr := NodePtr^.NextNodePtr;
  while Assigned(NextPtr) do
  begin
    //cz zvladne Pascal se v tom vyznat?
    //cz Skutecne vynulovat retezce
    //cz a uvolnit pamet?
    Dispose(NodePtr);
    NodePtr := NextPtr;
    NextPtr := NodePtr^.NextNodePtr;
  end;
  Dispose(NodePtr);
end;

procedure TDLinkedList.Insert(const Item: TItem);
var
  NodePtr: PNode;
begin
  New(NodePtr);
  NodePtr^.Item := Item;
  NodePtr^.PreviousNodePtr := CurrentNodePtr;
  NodePtr^.NextNodePtr := CurrentNodePtr^.NextNodePtr;
  CurrentNodePtr^.NextNodePtr := NodePtr;
  CurrentNodePtr := NodePtr;
  NodePtr := CurrentNodePtr^.NextNodePtr;
  NodePtr^.PreviousNodePtr := CurrentNodePtr;
end;

function TDLinkedList.MoveBack: TItem;
var
  PreviousPtr: PNode;
begin
  PreviousPtr := CurrentNodePtr^.PreviousNodePtr;
  if Assigned(PreviousPtr) then
    CurrentNodePtr := PreviousPtr;
  Result := CurrentNodePtr^.Item
end;

function TDLinkedList.MoveForward: TItem;
var
  NextPtr: PNode;
begin
  NextPtr := CurrentNodePtr^.NextNodePtr;
  if Assigned(NextPtr) then
    CurrentNodePtr := CurrentNodePtr^.NextNodePtr;
  Result := CurrentNodePtr^.Item
end;

end.