Changes in libcfa/src/bits/sequence.hfa [636d3715:b37515b]

File:

• libcfa/src/bits/sequence.hfa (modified) (13 diffs)

libcfa/src/bits/sequence.hfa

@@ -10 +10 @@
 inline {
         void ?{}( Seqable & sq ) with( sq ) {
-                ((Colable &) sq){};
+                ((Colable & ) sq){};
                 back = 0p;
         } // post: ! listed()
@@ -34 +34 @@
                 } // post: empty() & head() == 0 | !empty() & head() in *s
 
+                bool empty( Sequence(T) & s ) with( s ) {               // 0 <=> *s contains no elements
+                        return empty( (Collection &)s );
+                }
+
+                bool listed( T * n ) {
+                        return Next( (Colable *)n ) != 0;
+                }
+
+                T *& Next( T * n ) {
+                        return (T *)Next( (Colable *)n );
+                }
+
                 T *& Back( T * n ) {
                         return (T *)Back( (Seqable *)n );
+                }
+
+                T * Root( Sequence(T) & s ) with( s ) {
+                        return (T *)root;
                 }
 
@@ -47 +63 @@
                 // Return a pointer to the last sequence element, without removing it.  
                 T & tail( Sequence(T) & s ) with( s ) {
-                        return root ? (T &)Back( head( s ) ) : *0p;     // needs cast?
+                        return root ? (T &)Back( Root( s ) ) : *0p;     // needs cast?
                 }       // post: empty() & tail() == 0 | !empty() & tail() in *s
 
@@ -55 +71 @@
                         if ( ! listed( n ) ) abort( "(Sequence &)%p.succ( %p ) : Node is not on a list.", &s, n );
 #endif // __CFA_DEBUG__
-                        return Next( n ) == head( s ) ? 0p : Next( n );
+                        return Next( n ) == Root( s ) ? 0p : Next( n );
                 }       // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *s
 
@@ -63 +79 @@
                         if ( ! listed( n ) ) abort( "(Sequence &)%p.pred( %p ) : Node is not on a list.", &s, n );
 #endif // __CFA_DEBUG__
-                        return n == head( s ) ? 0p : Back( n );
+                        return n == Root( s ) ? 0p : Back( n );
                 }       // post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
 
@@ -72 +88 @@
                         if ( listed( &n ) ) abort( "(Sequence &)%p.insertBef( %p, %p ) : Node is already on another list.", &s, n, &bef );
 #endif // __CFA_DEBUG__
-                        if ( &bef == head( s ) ) {                                      // must change root
+                        if ( &bef == Root( s ) ) {                                      // must change root
                                 if ( root ) {
-                                        Next( &n ) = head( s );
-                                        Back( &n ) = Back( head( s ) );
+                                        Next( &n ) = Root( s );
+                                        Back( &n ) = Back( Root( s ) );
                                         // inserted node must be consistent before it is seen
                                         asm( "" : : : "memory" );                       // prevent code movement across barrier
-                                        Back( head( s ) ) = &n;
+                                        Back( Root( s ) ) = &n;
                                         Next( Back( &n ) ) = &n;
                                 } else {
@@ -88 +104 @@
                                 root = &n;
                         } else {
-                                if ( ! &bef ) &bef = head( s );
+                                if ( ! &bef ) &bef = Root( s );
                                 Next( &n ) = &bef;
                                 Back( &n ) = Back( &bef );
@@ -106 +122 @@
                         if ( ! &aft ) {                                                         // must change root
                                 if ( root ) {
-                                        Next( &n ) = head( s );
-                                        Back( &n ) = Back( head( s ) );
+                                        Next( &n ) = Root( s );
+                                        Back( &n ) = Back( Root( s ) );
                                         // inserted node must be consistent before it is seen
                                         asm( "" : : : "memory" );                       // prevent code movement across barrier
-                                        Back( head( s ) ) = &n;
+                                        Back( Root( s ) ) = &n;
                                         Next( Back( &n ) ) = &n;
                                 } else {
@@ -133 +149 @@
                         if ( ! listed( &n ) ) abort( "(Sequence &)%p.remove( %p ) : Node is not on a list.", &s, &n );
 #endif // __CFA_DEBUG__
-                        if ( &n == head( s ) ) {
-                                if ( Next( head( s ) ) == head( s ) ) root = 0p;
-                                else root = Next( head(s ) );
+                        if ( &n == Root( s ) ) {
+                                if ( Next( Root( s ) ) == Root( s ) ) root = 0p;
+                                else root = Next( Root(s ) );
                         } // if
                         Back( Next( &n ) ) = Back( &n );
@@ -175 +191 @@
                                 root = from.root;
                         } else {                                                                        // "to" list not empty
-                                T * toEnd = Back( head( s ) );
-                                T * fromEnd = Back( head( from ) );
+                                T * toEnd = Back( Root( s ) );
+                                T * fromEnd = Back( Root( from ) );
                                 Back( root ) = fromEnd;
-                                Next( fromEnd ) = head( s );
+                                Next( fromEnd ) = Root( s );
                                 Back( from.root ) = toEnd;
-                                Next( toEnd ) = head( from );
+                                Next( toEnd ) = Root( from );
                         } // if
                         from.root = 0p;                                                         // mark "from" list empty
@@ -197 +213 @@
                                 from.root = 0p;                                                 // mark "from" list empty
                         } else {
-                                Back( head( from ) ) = Back( head( to ) ); // fix "from" list
-                                Next( Back( head( to ) ) ) = head( from );
-                                Next( n ) = head( to );                                 // fix "to" list
-                                Back( head( to ) ) = n;
+                                Back( Root( from ) ) = Back( Root( to ) ); // fix "from" list
+                                Next( Back( Root( to ) ) ) = Root( from );
+                                Next( n ) = Root( to );                                 // fix "to" list
+                                Back( Root( to ) ) = n;
                         } // if
                         transfer( s, to );
@@ -215 +231 @@
 
         inline {
-                void ?{}( SeqIter(T) & si ) with( si ) {
-                        ((ColIter &)si){};
+                // wrappers to make ColIter have T
+                T * Curr( SeqIter(T) & si ) with( si ) {
+                        return (T *)curr;
+                }
+
+                void ?{}( SeqIter(T) & si ) with( si ) {        
+                        ((ColIter &) si){};
                         seq = 0p;
                 } // post: elts = null.
@@ -249 +270 @@
 
         inline {
+                // wrappers to make ColIter have T
+                T * Curr( SeqIterRev(T) & si ) with( si ) {
+                        return (T *)curr;
+                }
+
                 void ?{}( SeqIterRev(T) & si ) with( si ) {     
                         ((ColIter &) si){};