class BT_NODE_DBG{KEY<$IS_LT{KEY},ELT} < $BT_NODE{KEY,ELT,BT_NODE_DBG{KEY,ELT}}

---

Ancestors

$BT_NODE{_,_,_}

BT_NODE{_,_}

AREF{_}

---

Public

Readable Attributes

attr size: INT; .. Included as size

****	Current fill ratio of the node.

Writable Attributes

attr size: INT; .. Included as size

****	Current fill ratio of the node.

Constants

const maxSize: INT := 4; .. Included as maxSize

****	maximal number of elt tuples. MUST BE EVEN AND GREATER THAN 2.

const minSize: INT := maxSize / 2; .. Included as minSize

Features

aclear .. Included as aclear

****	Set each element of self to nil. Built-in.

acopy(src:SAME) .. Included as acopy

****	Copy as many elements from `src' to self as will fit. Built-in.

acopy(beg:INT, src:SAME) .. Included as acopy

****	Copy as many elements from `src' to self as will fit when starting at index `beg' of self.

acopy(beg,num:INT, src:SAME) .. Included as acopy

****	Copy `num' elements from `src' to self starting at index `beg' of self.

acopy(beg,num,srcbeg:INT, src:SAME) .. Included as acopy

****	Copy `num' elements from `src' to self starting at index `beg' of self and index `srcbeg' of `src'. Built-in.

aget(ind:INT):T .. Included as aget

****	The element of self with index `ind'. Built-in.

array_ptr:C_PTR .. Included as array_ptr

asize:INT .. Included as asize

****	The number of elements in self. Classes which inherit this may replace this by a constant to get constant sized objects (and the compiler may optimize certain operations in this case). Built-in.

create(n:INT):SAME .. Included as create

****	A new array with `n' elements.

create( t: TUP{KEY,ELT} ): SAME .. Included as create

create: SAME .. Included as create

debug: STR

find( k: KEY, stack: A_STACK{TUP{INT,SAME}} ): BOOL .. Included as find

findPred( stack: A_STACK{TUP{INT,SAME}} ) .. Included as findPred

is_eq( n: SAME ): BOOL .. Included as is_eq

joinLeft( pos: INT, stack: A_STACK{TUP{INT,SAME}} ) .. Included as joinLeft

joinRight( pos: INT, stack: A_STACK{TUP{INT,SAME}} ) .. Included as joinRight

leftFree( stack: A_STACK{TUP{INT,SAME}} ): BOOL .. Included as leftFree

leftSpare( stack: A_STACK{TUP{INT,SAME}} ): BOOL .. Included as leftSpare

nodeDelete( pos: INT ) .. Included as nodeDelete

nodeInsert( n: SAME, pos: INT ) .. Included as nodeInsert

pullLeft( pos: INT, stack: A_STACK{TUP{INT,SAME}} ) .. Included as pullLeft

pullRight( pos: INT, stack: A_STACK{TUP{INT,SAME}} ) .. Included as pullRight

pushLeft( e: SAME, pos: INT, stack: A_STACK{TUP{INT,SAME}} ) .. Included as pushLeft

pushRight( e: SAME, pos: INT, stack: A_STACK{TUP{INT,SAME}} ) .. Included as pushRight

rightFree( stack: A_STACK{TUP{INT,SAME}} ): BOOL .. Included as rightFree

rightSpare( stack: A_STACK{TUP{INT,SAME}} ): BOOL .. Included as rightSpare

setItem( pos: INT, t: TUP{KEY,ELT} ) .. Included as setItem

setNode( pos: INT, node: SAME ) .. Included as setNode

split( e: SAME, pos: INT ): SAME .. Included as split

Iters

aelt!(once beg:INT):T .. Included as aelt!

****	Yield each element of self starting at `beg'. Built-in.

aelt!(once beg,once num:INT):T .. Included as aelt!

****	Yield `num' successive elements of self starting at index `beg'. Built-in.

aelt!(once beg,once num,once step:INT):T .. Included as aelt!

****	Yield `num' elements of self starting at `beg' and stepping by `step' which must not be zero. Built-in.

aelt!:T .. Included as aelt!

****	Yield each element of self in order. Built-in.

aind!:INT .. Included as aind!

****	Yield the indices of self in order.

aset!(val:T) .. Included as aset!

****	Set successive elements of self to the values `val'. Built-in.

aset!(once beg:INT,val:T) .. Included as aset!

****	Set successive elements of self starting at `beg' to the values `val'.

aset!(once beg,once num:INT,val:T) .. Included as aset!

****	Set `num' successive elements of self starting at `beg' to the values `val'.

aset!(once beg,once num,once step:INT, val:T) .. Included as aset!

****	Set `num' elements of self starting at `beg' stepping by `step' to the values `val'. `step' must not be zero.

elt!: ELT .. Included as elt!

ind!: KEY .. Included as ind!

pair!: TUP{KEY,ELT} .. Included as pair!

---

Private

aset(ind:INT, val:T) .. Included as aset

****	Set the element of self with index `ind' to `val'. Built-in.

is_legal_aelts_arg( beg, num, step:INT) :BOOL .. Included as is_legal_aelts_arg

****	True if the arguments are legal values for `aelts'.

---

The Sather Home Page

---