Changes in libcfa/src/bits/stack.hfa [9536761:7d4ce2a]

File:

• libcfa/src/bits/stack.hfa (modified) (7 diffs)

libcfa/src/bits/stack.hfa

@@ -3 +3 @@
 #include "bits/collection.hfa"
 
-// A Stack(T) is a Collection(T) defining the ordering that nodes are returned by drop() in the reverse order from those
-// added by add(). T must be a public descendant of uColable.
-
-// The implementation is a typical singly-linked list, except the next field of the last element points to itself
-// instead of being null.
-
-forall( dtype T | { T *& Next ( T * ); } ) {
+forall( dtype T ) {
         struct Stack {
                 inline Collection;                                                              // Plan 9 inheritance
@@ -31 +25 @@
                 }
 
-                T & addHead( Stack(T) & s, T & n ) with( s ) {
+                void addHead( Stack(T) & s, T & n ) with( s ) {
                         #ifdef __CFA_DEBUG__
                         if ( listed( (Colable &)(n) ) ) abort( "(Stack &)%p.addHead( %p ) : Node is already on another list.", &s, n );
@@ -37 +31 @@
                         Next( &n ) = &head( s ) ? &head( s ) : &n;
                         root = &n;
-                        return n;
                 }
 
-                T & add( Stack(T) & s, T & n ) with( s ) {
-                        return addHead( s, n );
+                void add( Stack(T) & s, T & n ) with( s ) {
+                        addHead( s, n );
                 }
 
-                T & push( Stack(T) & s, T & n ) with( s ) {
-                        return addHead( s, n );
+                void push( Stack(T) & s, T & n ) with( s ) {
+                        addHead( s, n );
                 }
 
@@ -51 +44 @@
                         T & t = head( s );
                         if ( root ) {
-                                root = ( T *)Next( (T *)root );
+                                root = ( T *)Next( root );
                                 if ( &head( s ) == &t ) root = 0p;              // only one element ?
                                 Next( &t ) = 0p;
@@ -64 +57 @@
 } // distribution
 
-// A StackIter(T) is a subclass of ColIter(T) that generates the elements of a Stack(T).  It returns the elements in the
-// order returned by drop().
 
-forall( dtype T | { T *& Next ( T * ); } ) {
+forall( dtype T ) {
         struct StackIter {
                 inline ColIter;                                                                 // Plan 9 inheritance
@@ -77 +68 @@
                 } // post: curr == 0p
 
-                // create an iterator active in stack s
+                // create an iterator active in Stack s
                 void ?{}( StackIter(T) & si, Stack(T) & s ) with( si ) {
                         curr = &head( s );
@@ -86 +77 @@
                 } // post: curr = {e in s}
 
-                // make existing iterator active in stack s
+                // make existing iterator active in Stack q
                 void over( StackIter(T) & si, Stack(T) & s ) with( si ) {
                         curr = &head( s );
                 } // post: curr = {e in s}
 
-                bool ?|?( StackIter(T) & si, T && tp ) with( si ) {
+                bool ?>>?( StackIter(T) & si, T && tp ) with( si ) {
                         if ( curr ) {
                                 &tp = Curr( si );