(*
17.3 Unbounded Priority Non-Balking Deque Interface

The interface to the non-balking form of priority deque differs only
slightly from the balking form: the operations Leave and PositionOf
have been removed.
*)

DEFINITION MODULE DQPNSUMI;
(*===========================================================
    Version  : 1.00  16 May 1989  C. Lins
    Compiler : TopSpeed Modula-2
    Component: Monolithic Structures - Deque (Opaque version)
      Priority Non-Balking Sequential Unbounded Managed Iterator

    REVISION HISTORY
    v1.00  16 May 1989  C. Lins:
	  Initial TopSpeed Modula-2 implementation.
	(C) Copyright 1989 Charles A. Lins
===========================================================*)

FROM ErrorHandling IMPORT
    (*--Type*) HandlerProc;

FROM Items IMPORT
    (*--Type*) Item, AccessProc, LoopAccessProc;

FROM QEnum IMPORT
    (*--Type*) Exceptions;

FROM Relations IMPORT
    (*--Type*) Relation;

FROM TypeManager IMPORT
    (*--Type*) TypeID;

    (*--------------------*)

(*
17.3.1 Type Declarations

A deque is declared as the abstract data type, Deque.  As insertions and
removals can occur at either end of a double-ended queue, the enumeration
type Location defined these options.  A constant representing an undefined
deque is also provided allowing a simple (in)equality test to be made for
such objects.

An item's priority is declared as a generic entity, allowing the client
module to have priorities of any complexity.  All that is needed for
the priority form of deque is the ability to retrieve an item's priority
and to compare priorities for the relational ordering between them.
*)

TYPE  Deque;
TYPE  Location  = (front, back);
CONST NullDeque = Deque(NIL);

TYPE  Priority;
TYPE  PriorityProc    = PROCEDURE (Item) : Priority;
TYPE  PriorityCompare = PROCEDURE (Priority, Priority) : Relation;


(*
17.3.2 Exceptions

The ModuleID uniquely identifies this module from all others.

DequeError returns the most recent deque exception, or noerr if the
last operation was successful.  While SetHandler and GetHandler allow
assignment and retrieval of exception handling routines for specific
exceptions.
*)

CONST ModuleID = 11;

PROCEDURE DequeError () : Exceptions (*-- out   *);

PROCEDURE SetHandler (    theError   : Exceptions  (*-- in    *);
	theHandler : HandlerProc (*-- in    *));

PROCEDURE GetHandler (    theError   : Exceptions  (*-- in    *))
	: HandlerProc (*-- out   *);


(*
17.3.3 Constructors

The constructor Create has been changed from the non-priority
non-balking form of queue to accomodate procedure parameters to (1)
retrieve the priority for an item, and (2) compare two priorities.

All other constructors remain unchanged from the non-priority
non-balking form of deque.
*)

PROCEDURE Create  (    theType    : TypeID	(*-- in    *);
					   priorityOf : PriorityProc    (*-- in    *);
					   comparison : PriorityCompare (*-- in    *))
	: Deque	(*-- out   *);

PROCEDURE Destroy (VAR theDeque : Deque     (*-- inout *));

PROCEDURE Clear   (VAR theDeque : Deque     (*-- inout *));

PROCEDURE Assign  (    theDeque : Deque     (*-- in    *);
	VAR toDeque  : Deque     (*-- inout *));

PROCEDURE Arrive  (VAR theDeque : Deque     (*-- inout *);
       	       	       theItem  : Item      (*-- in    *);
					   theEnd   : Location  (*-- in    *));

PROCEDURE Depart  (VAR theDeque : Deque     (*-- inout *);
					   theEnd   : Location  (*-- in    *));


(*
17.3.4 Selectors

All of the selector interfaces are unchanged from the non-priority
non-balking form of deque.
*)

PROCEDURE IsDefined (    theDeque : Deque    (*-- in    *))
	: BOOLEAN  (*-- out   *);

PROCEDURE IsEmpty   (    theDeque : Deque    (*-- in    *))
	: BOOLEAN  (*-- out   *);

PROCEDURE IsEqual   (    left     : Deque    (*-- in    *);
	right    : Deque    (*-- in    *))
	: BOOLEAN  (*-- out   *);

PROCEDURE LengthOf  (    theDeque : Deque    (*-- in    *))
	: CARDINAL (*-- out   *);

PROCEDURE TypeOf    (    theDeque : Deque    (*-- in    *))
	: TypeID   (*-- out   *);

PROCEDURE FrontOf   (    theDeque : Deque    (*-- in    *))
       	       		: Item     (*-- out   *);

PROCEDURE RearOf    (    theDeque : Deque    (*-- in    *))
       	       		: Item     (*-- out   *);

PROCEDURE EndOf     (    theDeque : Deque    (*-- in    *);
	theEnd   : Location (*-- in    *))
       	       		: Item     (*-- out   *);


(*
17.3.5 Iterators

The interfaces to both iterators are unchanged from the non-priority
non-balking form of deque.
*)

PROCEDURE LoopOver (    theDeque  : Deque	(*-- in    *);
	theProcess: LoopAccessProc (*-- in    *);
						theEnd    : Location       (*-- in    *));

PROCEDURE Traverse (    theDeque  : Deque	(*-- in    *);
	theProcess: AccessProc     (*-- in    *);
						theEnd    : Location       (*-- in    *));

END DQPNSUMI.