Changes in libcfa/src/bits/sequence.hfa [ab1b971:9536761]

File:

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

libcfa/src/bits/sequence.hfa

@@ -1 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// bits/sequence.hfa -- PUBLIC
-// Intrusive doubly-linked list
-//
-// Author           : Colby Alexander Parsons & Peter A. Buhr
-// Created On       : Thu Jan 21 19:46:50 2021
-// Last Modified By :
-// Last Modified On :
-// Update Count     :
-//
-
 #pragma once
 
@@ -22 +6 @@
 struct Seqable {
         __cfa_anonymous_object(Colable);
-        // pointer to previous node in the list
-        struct Seqable * back;
+        struct Seqable * back;                                                                          // pointer to previous node in the list
 };
 
@@ -44 +27 @@
                 return sq->back;
         }
+
+        // // wrappers to make Collection have T
+        // forall( dtype T ) {
+        //      T *& Back( T * n ) {
+        //              return (T *)Back( (Seqable *)n );
+        //      }
+        // } // distribution
 } // distribution
 
@@ -53 +43 @@
 // and the back field of the last node points at the first node (circular).
 
-forall( T & ) {
+forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) {
         struct Sequence {
-                // Plan 9 inheritance
-                inline Collection;
+                inline Collection;                                                              // Plan 9 inheritance
         };
 
         static inline {
-                void ?{}( Sequence(T) &, const Sequence(T) & ) = void; // no copy
-                Sequence(T) & ?=?( const Sequence(T) & ) = void; // no assignment
-
-                void ?{}( Sequence(T) & s ) with( s ) {
-                        ((Collection &)s){};
-                }       // post: isEmpty()
-        }
-
-        static inline forall(| { T *& Back ( T * ); T *& Next ( T * ); }) {
                 // wrappers to make Collection have T
                 T & head( Sequence(T) & s ) with( s ) {
                         return *(T *)head( (Collection &)s );
                 } // post: empty() & head() == 0 | !empty() & head() in *s
+
+                void ?{}( Sequence(T) &, const Sequence(T) & ) = void; // no copy
+                Sequence(T) & ?=?( const Sequence(T) & ) = void; // no assignment
+
+                void ?{}( Sequence(T) & s ) with( s ) { 
+                        ((Collection &)s){};
+                }       // post: isEmpty()
 
                 // Return a pointer to the last sequence element, without removing it.
@@ -158 +145 @@
                         return n;
                 } // post: n->listed() & *n in *s & succ(n) == bef
-
+                
                 // pre: n->listed() & *n in *s
                 T & remove( Sequence(T) & s, T & n ) with( s ) { // O(1)
@@ -244 +231 @@
 } // distribution
 
-forall( T & | { T *& Back ( T * ); T *& Next ( T * ); } ) {
+forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) {
         // SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
         struct SeqIter {
@@ -298 +285 @@
 
         static inline {
-                void ?{}( SeqIterRev(T) & si ) with( si ) {
+                void ?{}( SeqIterRev(T) & si ) with( si ) {     
                         ((ColIter &)si){};
                         seq = 0p;
@@ -304 +291 @@
 
                 // Create a iterator active in sequence s.
-                void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
+                void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {    
                         ((ColIter &)si){};
                         seq = &s;
@@ -310 +297 @@
                 } // post: elts = null
 
-                void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) {
+                void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) { 
                         ((ColIter &)si){};
                         seq = &s;