Changes in libcfa/src/bits/stack.hfa [636d3715:5e82d56]

File:

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

libcfa/src/bits/stack.hfa

@@ -14 +14 @@
                 } // post: empty() & head() == 0 | !empty() & head() in *this
 
+                bool empty( Stack(T) & s ) with( s ) {                  // 0 <=> *this contains no elements
+                        return empty( (Collection &)s );
+                }
+
+                T *& Next( T * n ) {
+                        return (T *)Next( (Colable *)n );
+                }
+
+                T * Root( Stack(T) & s ) with( s ) {
+                        return (T *)root;
+                }
+
                 void ?{}( Stack(T) &, const Stack(T) & ) = void; // no copy
                 Stack(T) & ?=?( const Stack(T) & ) = void;              // no assignment
@@ -21 +33 @@
                 } // post: empty()
 
-                T & top( Stack(T) & s ) with( s ) {
-                        return *head( s );
+                T * top( Stack(T) & s ) with( s ) {
+                        return head( s );
                 }
 
-                void 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 );
+                        if ( listed( (Colable &)(*n) ) ) abort( "(Stack &)%p.addHead( %p ) : Node is already on another list.", &s, n );
 #endif // __CFA_DEBUG__
-                        Next( &n ) = head( s ) ? head( s ) : &n;
-                        root = &n;
+                        Next( n ) = Root( s ) ? Root( s ) : n;
+                        root = n;
                 }
 
-                void add( Stack(T) & s, T & n ) with( s ) {
+                void add( Stack(T) & s, T * n ) with( s ) {
                         addHead( s, n );
                 }
 
-                void push( Stack(T) & s, T & n ) with( s ) {
+                void push( Stack(T) & s, T * n ) with( s ) {
                         addHead( s, n );
                 }
 
-                T & drop( Stack(T) & s ) with( s ) {
-                        T & t = *head( s );
+                T * drop( Stack(T) & s ) with( s ) {
+                        T * t = head( s );
                         if ( root ) {
                                 root = ( T *)Next(root);
-                                if ( head( s ) == &t ) root = 0p;               // only one element ?
-                                Next( &t ) = 0p;
+                                if ( Root( s ) == t ) root = 0p;                // only one element ?
+                                Next( t ) = 0p;
                         } // if
                         return t;
                 }
 
-                T & pop( Stack(T) & s ) with( s ) {
+                T * pop( Stack(T) & s ) with( s ) {
                         return drop( s );
                 }
@@ -64 +76 @@
 
         inline {
+                // wrappers to make ColIter have T
+                T * Curr( StackIter(T) & si ) with( si ) {
+                        return (T *)curr;
+                }
+
                 void ?{}( StackIter(T) & si ) with( si ) {
                         ((ColIter &)si){};
@@ -73 +90 @@
                 } // post: curr = {e in s}
 
-                void ?{}( StackIter(T) & si, T & start ) with( si ) {
-                        curr = &start;
+                void ?{}( StackIter(T) & si, T * start ) with( si ) {
+                        curr = start;
                 } // post: curr = {e in s}
 
@@ -82 +99 @@
                 } // 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 );
+                                tp = Curr( si );
                                 T * n = Next( Curr( si ) );
-                                curr = n == Curr( si ) ? 0p : n;
-                        } else &tp = 0p;
-                        return &tp != 0p;
+                                curr = (n == Curr( si ) ) ? 0p : n;
+                        } else tp = 0p;
+                        return tp != 0p;
                 }
         } // distribution