Changes in libcfa/src/collections/list.hfa [6b33e89:65b0402]

File:

• libcfa/src/collections/list.hfa (modified) (8 diffs)

libcfa/src/collections/list.hfa

@@ -10 +10 @@
 // Created On       : Wed Apr 22 18:00:00 2020
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Apr 24 18:12:59 2025
-// Update Count     : 72
+// Last Modified On : Sun Apr 20 19:04:50 2025
+// Update Count     : 51
 //
 
@@ -72 +72 @@
 
 // The origin is the position encountered at the start of iteration, signifying, "need to advance to the first element,"
-// and at the end of iteration, signifying, "no more elements."  Normal comsumption of an iterator runs "advance" as
-// the first step, and uses the return of "advance" as a guard, before dereferencing the iterator.  So normal
+// and at the end of iteration, signifying, "no more elements."  Normal comsumption of an iterator runs ?`moveNext as
+// the first step, and uses the return of ?`moveNext as a guard, before dereferencing the iterator.  So normal
 // consumption of an iterator does not dereference an iterator in origin position.  The value of a pointer (underlying a
 // refence) that is exposed publicly as an iteraor, and also a pointer stored internally in a link field, is tagged, to
@@ -128 +128 @@
 
 static inline forall( tE &, tLinks & | embedded( tE, tLinks, dlink( tE ) ) ) {
-        bool isListed( tE & node ) {
-                verify( &node != 0p );
-                dlink( tE ) & node_links = node`inner;
-                return (node_links.prev != 0p) || (node_links.next != 0p);
-        }
-
-        bool isEmpty( dlist( tE, tLinks ) & list ) {
-                tE * firstPtr = list.next;
-                if ( ORIGIN_TAG_QUERY(( size_t)firstPtr) ) firstPtr = 0p;
-                return firstPtr == 0p;
-        }
-
-        tE & first( dlist( tE, tLinks ) & list ) {
-                tE * firstPtr = list.next;
-                if ( ORIGIN_TAG_QUERY( (size_t)firstPtr ) ) firstPtr = 0p;
-                return *firstPtr;
-        }
-
-        tE & last( dlist( tE, tLinks ) & list ) {
-                tE * lastPtr = list.prev;
-                if ( ORIGIN_TAG_QUERY( (size_t)lastPtr) ) lastPtr = 0p;
-                return *lastPtr;
-        }
-
         tE & insert_before( tE & before, tE & node ) {
                 verify( &before != 0p );
@@ -218 +194 @@
         }
 
-        tE & iter( dlist( tE, tLinks ) & list ) {
+        tE & ?`first( dlist( tE, tLinks ) & list ) {
+                tE * firstPtr = list.next;
+                if ( ORIGIN_TAG_QUERY( (size_t)firstPtr ) ) firstPtr = 0p;
+                return *firstPtr;
+        }
+
+        tE & ?`last( dlist( tE, tLinks ) & list ) {
+                tE * lastPtr = list.prev;
+                if ( ORIGIN_TAG_QUERY( (size_t)lastPtr) ) lastPtr = 0p;
+                return *lastPtr;
+        }
+
+        bool ?`isEmpty( dlist( tE, tLinks ) & list ) {
+                tE * firstPtr = list.next;
+                if ( ORIGIN_TAG_QUERY(( size_t)firstPtr) ) firstPtr = 0p;
+                return firstPtr == 0p;
+        }
+
+        bool ?`isListed( tE & node ) {
+                verify( &node != 0p );
+                dlink( tE ) & node_links = node`inner;
+                return (node_links.prev != 0p) || (node_links.next != 0p);
+        }
+
+        tE & ?`elems( dlist( tE, tLinks ) & list ) {
                 tE * origin = $get_list_origin_addr( list );
                 return *origin;
         }
-
-        bool recede( tE && refx ) {
+        tE & ?`head( dlist( tE, tLinks ) & list ) {
+                return list`elems;
+        }
+
+        bool ?`moveNext( tE && refx ) {
+                tE && ref_inner = refx;
+                tE & oldReferent = *(tE*)ORIGIN_TAG_CLEAR( (size_t)&ref_inner );
+                &ref_inner = oldReferent`inner.next;
+                return &ref_inner != 0p && ! ORIGIN_TAG_QUERY( (size_t)&ref_inner );
+        }
+        bool ?`next( tE && refx ) {                                                     // alternate name
+                return refx`moveNext;
+        }
+
+        bool ?`movePrev( tE && refx ) {
                 tE && ref_inner = refx;
                 tE & oldReferent = *(tE*)ORIGIN_TAG_CLEAR( (size_t)&ref_inner );
@@ -229 +242 @@
                 return &ref_inner != 0p && ! ORIGIN_TAG_QUERY( (size_t)&ref_inner );
         }
-
-        bool advance( tE && refx ) {
-                tE && ref_inner = refx;
-                tE & oldReferent = *(tE*)ORIGIN_TAG_CLEAR( (size_t)&ref_inner );
-                &ref_inner = oldReferent`inner.next;
-                return &ref_inner != 0p && ! ORIGIN_TAG_QUERY( (size_t)&ref_inner );
-        }
-
-    bool isFirst( tE & node ) {
-        return recede( node );
-    }
-
-    bool isLast( tE & node ) {
-        return advance( node );
-    }
-
-        tE & prev( tE & node ) {
-                if ( recede( node ) ) return node;
+        bool ?`prev( tE && refx ) {                                                     // alternate name
+                return refx`movePrev;
+        }
+
+        bool ?`hasNext( tE & node ) {
+                return node`moveNext;
+        }
+
+        bool ?`hasPrev( tE & node ) {
+                return node`movePrev;
+        }
+
+        tE & ?`next( tE & node ) {
+                if ( node`moveNext ) return node;
                 return *0p;
         }
 
-        tE & next( tE & node ) {
-                if ( advance( node ) ) return node;
+        tE & ?`prev( tE & node ) {
+                if ( node`movePrev ) return node;
                 return *0p;
         }
 
         tE & insert_first( dlist( tE, tLinks ) & list, tE & node ) {
-                insert_after( iter( list ), node );
+                insert_after( list`elems, node );
                 return node;
         }
 
         tE & insert_last( dlist( tE, tLinks ) & list, tE & node ) {
-                insert_before( iter( list ), node );
-                return node;
-        }
-        tE & insert( dlist( tE, tLinks ) & list, tE & node ) { // synonym for insert_last
+                insert_before( list`elems, node );
+                return node;
+        }
+        tE &  insert( dlist( tE, tLinks ) & list, tE & node ) { // alternate name
                 insert_last( list, node );
                 return node;
@@ -270 +279 @@
 
         tE & remove_first( dlist( tE, tLinks ) & list ) {
-                tE & first_node = first( list );
-                if ( &first_node ) return remove( first_node );
-                return first_node;
+                return remove( list`first );
         }
 
         tE & remove_last( dlist( tE, tLinks ) & list ) {
-                tE & last_node = last( list );
-                if ( &last_node ) return remove( last_node );
-                return last_node;
+                return remove( list`last );
         }
 
@@ -317 +322 @@
 //      }
 
+        tE & try_pop_front( dlist( tE, tLinks ) & list ) {
+                tE & first_inlist = list`first;
+                tE & first_item = first_inlist;
+                if ( &first_item ) remove( first_inlist );
+                return first_item;
+        }
+
+        tE & try_pop_back( dlist( tE, tLinks ) & list ) {
+                tE & last_inlist = list`last;
+                tE & last_item = last_inlist;
+                if ( &last_item ) remove( last_inlist );
+                return last_item;
+        }
+
+
         #if ! defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
         bool $validate_fwd( dlist( tE, tLinks ) & this ) {
-                if ( ! & first( this ) ) return &last( this ) == 0p;
+                if ( ! & this`first ) return &this`last == 0p;
 
                 tE & lagElem = *0p;
-                while ( tE & it = iter( this ); advance( it ) ) {
-                        if ( & lagElem == 0p &&  &it != & first( this ) ) return false;
+                while ( tE & it = this`elems; it`moveNext ) {
+                        if ( & lagElem == 0p &&  &it != & this`first ) return false;
                         &lagElem = ⁢
                 }
 
-                if ( &lagElem != &last( this ) ) return false;
-
-                // TODO: verify that it is back at iter( this );
+                if ( &lagElem != &this`last ) return false;
+
+                // TODO: verify that it is back at this`elems;
                 return true;
         }
 
         bool $validate_rev( dlist( tE, tLinks ) & this ) {
-                if ( ! & last( this ) ) return &first( this ) == 0p;
+                if ( ! & this`last ) return &this`first == 0p;
 
                 tE & lagElem = *0p;
-                while ( tE & it = iter( this ); recede( it ) ) {
-                        if ( &lagElem == 0p && &it != & last( this ) ) return false;
+                while ( tE & it = this`elems; it`movePrev ) {
+                        if ( &lagElem == 0p && &it != & this`last ) return false;
                         &lagElem = ⁢
                 }
 
-                if ( &lagElem != &first( this ) ) return false;
-
-                // TODO: verify that it is back at iter( this );
+                if ( &lagElem != &this`first ) return false;
+
+                // TODO: verify that it is back at this`elems;
                 return true;
         }
@@ -355 +375 @@
 
 // TEMPORARY, until foreach statement created.
-#define FOREACH( list, index ) for ( typeof(iter( list )) & (index) = iter( list ); advance( index ); )
-#define FOREACH_REV( list, index ) for ( typeof(iter( list )) & (index) = iter( list ); recede( index ); )
-#define FOREACH_COND( list, index, expr ) for ( typeof(iter( list )) & (index) = iter( list ); advance( index ) && !(expr); )
-#define FOREACH_REV_COND( list, index, expr ) for ( typeof(iter( list )) & (index) = iter( list ); recede( index ) && !(expr); )
+#define FOREACH( list, index ) for ( typeof((list)`head) & (index) = (list)`head; (index)`next; )
+#define FOREACH_REV( list, index ) for ( typeof((list)`head) & (index) = (list)`head; (index)`prev; )
+#define FOREACH_COND( list, index, expr ) for ( typeof((list)`head) & (index) = (list)`head; (index)`next && !(expr); )
+#define FOREACH_REV_COND( list, index, expr ) for ( typeof((list)`head) & (index) = (list)`head; (index)`prev && !(expr); )