Changes in / [b6460bf:3e36f22]


Ignore:
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/bits/collection.hfa

    rb6460bf r3e36f22  
    6868
    6969struct ColIter {
    70         void * curr;                                                                            // element to be returned by >>
     70        void * curr;                                                                            // element returned by |
    7171};
    7272
  • libcfa/src/bits/queue.hfa

    rb6460bf r3e36f22  
    22
    33#include "bits/collection.hfa"
     4
     5// A Queue(T) is a Collection(T) defining the ordering that nodes are returned by drop() in the same order from those
     6// added by add(). T must be a public descendant of uColable.
     7
     8// The implementation is a typical singly-linked list, except the next field of the last element points to itself
     9// instead of being null.
    410
    511forall( dtype T | { T *& Next ( T * ); } ) {
     
    108114                } // post: ! listed( n )
    109115
    110                 T & dropTail( Queue(T) & q ) with( q ) { // O(n)
     116                T & dropTail( Queue(T) & q ) with( q ) {                // O(n)
    111117                        T & n = tail( q );
    112118                        return &n ? remove( q, n ), n : *0p;
     
    155161                } // post: curr == 0p
    156162
    157                 // create an iterator active in Queue q
     163                // create an iterator active in queue q
    158164                void ?{}( QueueIter(T) & qi, Queue(T) & q ) with( qi ) {
    159165                        curr = &head( q );
     
    164170                } // post: curr = {e in q}
    165171
    166                 // make existing iterator active in Queue q
     172                // make existing iterator active in queue q
    167173                void over( QueueIter(T) & qi, Queue(T) & q ) with( qi ) {
    168174                        curr = &head( q );
    169175                } // post: curr = {e in q}
    170176
    171                 bool ?>>?( QueueIter(T) & qi, T && tp ) with( qi ) {
     177                bool ?|?( QueueIter(T) & qi, T && tp ) with( qi ) {
    172178                        if ( curr ) {
    173179                                &tp = Curr( qi );
     
    177183                        return &tp != 0p;
    178184                }
    179                 // post: elts == null & !operator>>(tp) | elts != null & *tp' in elts & elts' == elts - *tp & operator>>(tp)
     185                // post: elts == null & !operator|(tp) | elts != null & *tp' in elts & elts' == elts - *tp & operator|(tp)
    180186        } // distribution
    181187} // distribution
  • libcfa/src/bits/sequence.hfa

    rb6460bf r3e36f22  
    3636} // distribution
    3737
     38
     39// A Sequence(T) is a Collection(T) defining the ordering of a uStack and uQueue, and to insert and remove elements
     40// anywhere in the sequence. T must be a public descendant of uSeqable.
     41
     42// The implementation is a typical doubly-linked list, except the next field of the last node points at the first node
     43// and the back field of the last node points at the first node (circular).
     44
    3845forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); } ) {
    3946        struct Sequence {
     
    5259                void ?{}( Sequence(T) & s ) with( s ) {
    5360                        ((Collection &)s){};
    54                 }       // post: isEmpty().
    55 
    56                 // Return a pointer to the last sequence element, without removing it. 
     61                }       // post: isEmpty()
     62
     63                // Return a pointer to the last sequence element, without removing it.
    5764                T & tail( Sequence(T) & s ) with( s ) {
    5865                        return root ? (T &)*Back( &head( s ) ) : *0p;
     
    6774                } // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *s
    6875
    69                 // Return a pointer to the element before *n, or 0p if there isn't one.
     76                // Return a pointer to the element before *n, or 0p if list empty.
    7077                T * pred( Sequence(T) & s, T * n ) with( s ) {  // pre: *n in *s
    7178                        #ifdef __CFA_DEBUG__
     
    7380                        #endif // __CFA_DEBUG__
    7481                        return n == &head( s ) ? 0p : Back( n );
    75                 }       // post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
    76 
    77 
    78                 // Insert *n into the sequence before *bef, or at the end if bef == 0.
     82                } // post: n == head() & head(n) == 0 | n != head() & *pred(n) in *s
     83
     84
     85                // Insert *n into the sequence before *bef, or at the end if bef == 0p.
    7986                T & insertBef( Sequence(T) & s, T & n, T & bef ) with( s ) { // pre: !n->listed() & *bef in *s
    8087                        #ifdef __CFA_DEBUG__
     
    137144                        } // if
    138145                        return n;
    139                 }        // post: n->listed() & *n in *s & succ(n) == bef
     146                } // post: n->listed() & *n in *s & succ(n) == bef
    140147               
    141148                // pre: n->listed() & *n in *s
     
    152159                        Next( &n ) = Back( &n ) = 0p;
    153160                        return n;
    154                 }                                                       // post: !n->listed().
     161                } // post: !n->listed()
    155162
    156163                // Add an element to the head of the sequence.
     
    158165                        return insertAft( s, *0p, n );
    159166                }
     167
    160168                // Add an element to the tail of the sequence.
    161169                T & addTail( Sequence(T) & s, T & n ) {                 // pre: !n->listed(); post: n->listed() & head() == n
    162170                        return insertBef( s, n, *0p );
    163171                }
     172
    164173                // Add an element to the tail of the sequence.
    165174                T & add( Sequence(T) & s, T & n ) {                             // pre: !n->listed(); post: n->listed() & head() == n
    166175                        return addTail( s, n );
    167176                }
     177
    168178                // Remove and return the head element in the sequence.
    169179                T & dropHead( Sequence(T) & s ) {
     
    171181                        return &n ? remove( s, n ), n : *0p;
    172182                }
     183
    173184                // Remove and return the head element in the sequence.
    174185                T & drop( Sequence(T) & s ) {
    175186                        return dropHead( s );
    176187                }
     188
    177189                // Remove and return the tail element in the sequence.
    178190                T & dropTail( Sequence(T) & s ) {
     
    233245                        ((ColIter &)si){};
    234246                        seq = 0p;
    235                 } // post: elts = null.
    236 
     247                } // post: elts = null
     248
     249                // Create a iterator active in sequence s.
    237250                void ?{}( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
    238251                        ((ColIter &)si){};
    239252                        seq = &s;
    240253                        curr = &head( s );
    241                 } // post: elts = null.
     254                } // post: elts = null
    242255
    243256                void ?{}( SeqIter(T) & si, Sequence(T) & s, T & start ) with( si ) {
     
    245258                        seq = &s;
    246259                        curr = &start;
    247                 } // post: elts = null.
    248 
     260                } // post: elts = null
     261
     262                // Make the iterator active in sequence s.
    249263                void over( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
    250264                        seq = &s;
    251265                        curr = &head( s );
    252                 } // post: elts = {e in s}.
    253 
    254                 bool ?>>?( SeqIter(T) & si, T && tp ) with( si ) {
     266                } // post: elts = {e in s}
     267
     268                bool ?|?( SeqIter(T) & si, T && tp ) with( si ) {
    255269                        if ( curr ) {
    256270                                &tp = Curr( si );
     
    274288                        ((ColIter &)si){};
    275289                        seq = 0p;
    276                 } // post: elts = null.
    277 
     290                } // post: elts = null
     291
     292                // Create a iterator active in sequence s.
    278293                void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {   
    279294                        ((ColIter &)si){};
    280295                        seq = &s;
    281296                        curr = &tail( s );
    282                 } // post: elts = null.
     297                } // post: elts = null
    283298
    284299                void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) {
     
    286301                        seq = &s;
    287302                        curr = &start;
    288                 } // post: elts = null.
    289 
     303                } // post: elts = null
     304
     305                // Make the iterator active in sequence s.
    290306                void over( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
    291307                        seq = &s;
    292308                        curr = &tail( s );
    293                 } // post: elts = {e in s}.
    294 
    295                 bool ?>>?( SeqIterRev(T) & si, T && tp ) with( si ) {
     309                } // post: elts = {e in s}
     310
     311                bool ?|?( SeqIterRev(T) & si, T && tp ) with( si ) {
    296312                        if ( curr ) {
    297313                                &tp = Curr( si );
  • libcfa/src/bits/stack.hfa

    rb6460bf r3e36f22  
    22
    33#include "bits/collection.hfa"
     4
     5// A Stack(T) is a Collection(T) defining the ordering that nodes are returned by drop() in the reverse order from those
     6// added by add(). T must be a public descendant of uColable.
     7
     8// The implementation is a typical singly-linked list, except the next field of the last element points to itself
     9// instead of being null.
    410
    511forall( dtype T | { T *& Next ( T * ); } ) {
     
    5864} // distribution
    5965
     66// A StackIter(T) is a subclass of ColIter(T) that generates the elements of a Stack(T).  It returns the elements in the
     67// order returned by drop().
    6068
    6169forall( dtype T | { T *& Next ( T * ); } ) {
     
    6977                } // post: curr == 0p
    7078
    71                 // create an iterator active in Stack s
     79                // create an iterator active in stack s
    7280                void ?{}( StackIter(T) & si, Stack(T) & s ) with( si ) {
    7381                        curr = &head( s );
     
    7886                } // post: curr = {e in s}
    7987
    80                 // make existing iterator active in Stack q
     88                // make existing iterator active in stack s
    8189                void over( StackIter(T) & si, Stack(T) & s ) with( si ) {
    8290                        curr = &head( s );
    8391                } // post: curr = {e in s}
    8492
    85                 bool ?>>?( StackIter(T) & si, T && tp ) with( si ) {
     93                bool ?|?( StackIter(T) & si, T && tp ) with( si ) {
    8694                        if ( curr ) {
    8795                                &tp = Curr( si );
  • tests/collections/.expect/queue.txt

    rb6460bf r3e36f22  
    16160 0 2 2 4 4 6 6 8 8 10 10 12 12 14 14 16 16 18 18
    171718 18
    18 -1 18 -1
     18-1 18 -2
     19-1 -1 18 18 1 1 3 3 5 5 7 7 9 9 11 11 13 13 15 15 17 17 19 19 -2 -2
    192018 18 1 1 3 3 5 5 7 7 9 9 11 11 13 13 15 15 17 17
     2118 18 1 1 3 3 5 5 7 7
     22empty
    20230 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
    21245 5 6 6 7 7 8 8 9 9
  • tests/collections/.expect/sequence.txt

    rb6460bf r3e36f22  
    19190 0 2 2 4 4 6 6 8 8 10 10 12 12 14 14 16 16 18 18
    202018 18
    21 -1 18 -1
     21-1 18 -2
     22-1 -1 18 18 1 1 3 3 5 5 7 7 9 9 11 11 13 13 15 15 17 17 19 19 -2 -2
    222318 18 1 1 3 3 5 5 7 7 9 9 11 11 13 13 15 15 17 17
     2418 18 1 1 3 3 5 5 7 7
     25empty
    23260 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
    24275 5 6 6 7 7 8 8 9 9
  • tests/collections/multi_list.cfa

    rb6460bf r3e36f22  
    7373
    7474        sout | nlOff;
    75         for ( over( sqiter, clustList ); sqiter >> dl; ) {      // print lists
     75        for ( over( sqiter, clustList ); sqiter | dl; ) {       // print lists
    7676                Task & tmp = task( dl ); sout | tmp.id;
    7777                // sout | task( dl ).id;
    7878        }
    7979        sout | nl;
    80         for ( over( sqiter, readyList ); sqiter >> dl; ) {
     80        for ( over( sqiter, readyList ); sqiter | dl; ) {
    8181                Task & tmp = task( dl ); sout | tmp.id;
    8282                // sout | task( dl ).id;
    8383        }
    8484        sout | nl;
    85         for ( QueueIter(TaskSL) qiter = { mutexList }; qiter >> sl; ) { // print lists
     85        for ( QueueIter(TaskSL) qiter = { mutexList }; qiter | sl; ) {  // print lists
    8686                Task & tmp = task( sl ); sout | tmp.id;
    8787                // sout | task( sl ).id;
     
    103103                push( mutexStack, task.clusterRef );                    // insert on lists in opposite directions
    104104        }
    105         for ( StackIter(TaskDL) stiter = { mutexStack }; stiter >> dl; ) {
     105        for ( StackIter(TaskDL) stiter = { mutexStack }; stiter | dl; ) {
    106106                Task & tmp = task( dl ); sout | tmp.id;
    107107                // sout | task( dl ).id;
  • tests/collections/queue.cfa

    rb6460bf r3e36f22  
    1919
    2020        Queue(Fred) fred;
    21         QueueIter(Fred) fredIter = { fred };
     21        QueueIter(Fred) iter = { fred };
    2222        Fred & f;
    2323
    2424        sout | nlOff;                                                                           // turn off auto newline
    2525
    26         for ( ; fredIter >> f; ) {                                                      // empty list
     26        for ( ; iter | f; ) {                                                   // empty list
    2727                sout | f.i | ' ';
    2828        }
     
    3535        sout | head( fred ).i | tail( fred ).i | nl;
    3636
    37         for ( QueueIter(Fred) iter = { fred }; iter >> f; ) {
     37        for ( QueueIter(Fred) iter = { fred }; iter | f; ) {
    3838                sout | f.i | ' ';
    3939        }
     
    4444        }
    4545
    46         for ( over( fredIter, fred ); fredIter >> f; ) {
     46        for ( over( iter, fred ); iter | f; ) {
    4747                sout | f.i | ' ';
    4848        }
     
    5858
    5959        sout | head( fred ).i | succ( fred, head )->i | tail( fred ).i | nl;
    60         for ( over( fredIter, fred ); fredIter >> f; ) {
     60
     61        for ( over( iter, fred ); iter | f; ) {
    6162                sout | f.i | ' ';
    6263        }
     
    6869        delete( &dropTail( fred ) );
    6970
    70         for ( over( fredIter, fred ); fredIter >> f; ) {
     71        for ( over( iter, fred ); iter | f; ) {
    7172                sout | f.i | ' ';
    7273        }
     
    7677                delete( &dropTail( fred ) );
    7778        }
    78         for ( over( fredIter, fred ); fredIter >> f; ) {
    79                 sout | f.i | ' ';
    80         }
    81         sout | nl;
    82 
    83         for ( over( fredIter, fred ); fredIter >> f; ) {
     79        for ( over( iter, fred ); iter | f; ) {
     80                sout | f.i | ' ';
     81        }
     82        sout | nl;
     83
     84        for ( over( iter, fred ); iter | f; ) {
    8485                delete( &remove( fred, f ) );
    8586        }
    86         for ( over( fredIter, fred ); fredIter >> f; ) {
     87        for ( over( iter, fred ); iter | f; ) {
    8788                sout | f.i | ' ';
    8889        }
     
    9697                }
    9798        }
    98         for ( QueueIter(Fred) iter = { fred }; iter >> f; ) {
     99        for ( QueueIter(Fred) iter = { fred }; iter | f; ) {
    99100                sout | f.i | ' ';
    100101        }
     
    105106        split( fred2, fred, middle );
    106107
    107         for ( over( fredIter, fred ); fredIter >> f; ) {
    108                 sout | f.i | ' ';
    109         }
    110         sout | nl;
    111 
    112         for ( over( fredIter, fred2 ); fredIter >> f; ) {
     108        for ( over( iter, fred ); iter | f; ) {
     109                sout | f.i | ' ';
     110        }
     111        sout | nl;
     112
     113        for ( over( iter, fred2 ); iter | f; ) {
    113114                sout | f.i | ' ';
    114115        }
     
    117118        transfer( fred, fred2 );
    118119
    119         for ( over( fredIter, fred ); fredIter >> f; ) {
    120                 sout | f.i | ' ';
    121         }
    122         sout | nl;
    123 
    124         for ( over( fredIter, fred ); fredIter >> f; ) {
     120        for ( over( iter, fred ); iter | f; ) {
     121                sout | f.i | ' ';
     122        }
     123        sout | nl;
     124
     125        for ( over( iter, fred ); iter | f; ) {
    125126                delete( &f );
    126127        }
     
    142143
    143144        Queue(Mary) mary;
    144         QueueIter(Mary) maryIter = { mary };
     145        QueueIter(Mary) iter = { mary };
    145146        Mary & m;
    146147
    147         for ( ; maryIter >> m; ) {                                                      // empty list
     148        for ( ; iter | m; ) {                                                   // empty list
    148149                sout | m.i | m.j | ' ';
    149150        }
     
    156157        sout | head( mary ).i | tail( mary ).i | nl;
    157158
    158         for ( QueueIter(Mary) iter = { mary }; iter >> m; ) {
     159        for ( QueueIter(Mary) iter = { mary }; iter | m; ) {
    159160                sout | m.i | m.j | ' ';
    160161        }
     
    165166        }
    166167
    167         for ( over( maryIter, mary ); maryIter >> m; ) {
     168        for ( over( iter, mary ); iter | m; ) {
    168169                sout | m.i | m.j | ' ';
    169170        }
     
    174175        }
    175176
    176         Mary * head = new( -1 ), tail = { -1 };
     177        Mary * head = new( -1 ), tail = { -2 };
    177178        addHead( mary, *head );
    178179        addTail( mary, tail );
     180
    179181        sout | head( mary ).i | succ( mary, head )->i | tail( mary ).i | nl;
     182
     183        for ( over( iter, mary ); iter | m; ) {
     184                sout | m.i | m.j | ' ';
     185        }
     186        sout | nl;
     187
    180188        remove( mary, *head );
    181189        remove( mary, tail );
     
    183191        delete( &dropTail( mary ) );
    184192
    185         for ( over( maryIter, mary ); maryIter >> m; ) {
    186                 sout | m.i | m.j | ' ';
    187         }
    188         sout | nl;
    189 
    190         for ( over( maryIter, mary ); maryIter >> m; ) {
     193        for ( over( iter, mary ); iter | m; ) {
     194                sout | m.i | m.j | ' ';
     195        }
     196        sout | nl;
     197
     198        for ( i; 5 ) {
     199                delete( &dropTail( mary ) );
     200        }
     201        for ( over( iter, mary ); iter | m; ) {
     202                sout | m.i | m.j | ' ';
     203        }
     204        sout | nl;
     205
     206        for ( over( iter, mary ); iter | m; ) {
    191207                delete( &remove( mary, m ) );
    192208        }
     209        for ( over( iter, mary ); iter | m; ) {
     210                sout | m.i | m.j | ' ';
     211        }
     212        sout | "empty" | nl;
    193213
    194214        Mary & middle;
     
    199219                }
    200220        }
    201         for ( QueueIter(Mary) iter = { mary }; iter >> m; ) {
     221        for ( QueueIter(Mary) iter = { mary }; iter | m; ) {
    202222                sout | m.i | m.j | ' ';
    203223        }
     
    208228        split( mary2, mary, middle );
    209229
    210         for ( over( maryIter, mary ); maryIter >> m; ) {
    211                 sout | m.i | m.j | ' ';
    212         }
    213         sout | nl;
    214         for ( over( maryIter, mary2 ); maryIter >> m; ) {
     230        for ( over( iter, mary ); iter | m; ) {
     231                sout | m.i | m.j | ' ';
     232        }
     233        sout | nl;
     234        for ( over( iter, mary2 ); iter | m; ) {
    215235                sout | m.i | m.j | ' ';
    216236        }
     
    219239        transfer( mary, mary2 );
    220240
    221         for ( over( maryIter, mary ); maryIter >> m; ) {
    222                 sout | m.i | m.j | ' ';
    223         }
    224         sout | nl;
    225         for ( over( maryIter, mary ); maryIter >> m; ) {
     241        for ( over( iter, mary ); iter | m; ) {
     242                sout | m.i | m.j | ' ';
     243        }
     244        sout | nl;
     245
     246        for ( over( iter, mary ); iter | m; ) {
    226247                delete( &m );
    227248        }
  • tests/collections/sequence.cfa

    rb6460bf r3e36f22  
    2222
    2323        Sequence(Fred) fred;
    24         SeqIter(Fred) fredIter = { fred };
     24        SeqIter(Fred) iter = { fred };
    2525        Fred & f;
    2626
    2727        sout | nlOff;                                                                           // turn off auto newline
    2828
    29         for ( ; fredIter >> f; ) {                                                      // empty list
     29        for ( ; iter | f; ) {                                                   // empty list
    3030                sout | f.i | ' ';
    3131        }
     
    3838        sout | head( fred ).i | tail( fred ).i | nl;
    3939
    40         for ( SeqIter(Fred) iter = { fred }; iter >> f; ) {
     40        for ( SeqIter(Fred) iter = { fred }; iter | f; ) {
    4141                sout | f.i | ' ';
    4242        }
     
    4747        }
    4848
    49         for ( over( fredIter, fred ); fredIter >> f; ) {
     49        for ( over( iter, fred ); iter | f; ) {
    5050                sout | f.i | ' ';
    5151        }
     
    6161
    6262        sout | head( fred ).i | succ( fred, head )->i | tail( fred ).i | nl;
    63         for ( over( fredIter, fred ); fredIter >> f; ) {
     63
     64        for ( over( iter, fred ); iter | f; ) {
    6465                sout | f.i | ' ';
    6566        }
     
    7172        delete( &dropTail( fred ) );
    7273
    73         for ( over( fredIter, fred ); fredIter >> f; ) {
     74        for ( over( iter, fred ); iter | f; ) {
    7475                sout | f.i | ' ';
    7576        }
     
    7980                delete( &dropTail( fred ) );
    8081        }
    81         for ( over( fredIter, fred ); fredIter >> f; ) {
    82                 sout | f.i | ' ';
    83         }
    84         sout | nl;
    85 
    86         for ( over( fredIter, fred ); fredIter >> f; ) {
     82        for ( over( iter, fred ); iter | f; ) {
     83                sout | f.i | ' ';
     84        }
     85        sout | nl;
     86
     87        for ( over( iter, fred ); iter | f; ) {
    8788                delete( &remove( fred, f ) );
    8889        }
    89         for ( over( fredIter, fred ); fredIter >> f; ) {
     90        for ( over( iter, fred ); iter | f; ) {
    9091                sout | f.i | ' ';
    9192        }
     
    9495        Fred & middle;
    9596        for ( i; 10 ) {
    96                 addHead( fred, *new( i ) );                                             // reverse oder
     97                addHead( fred, *new( i ) );                                             // reverse order
    9798                if ( i == 5 ) {
    9899                        &middle = &head( fred );
    99100                }
    100101        }
    101         for ( SeqIterRev(Fred) iter = { fred }; iter >> f; ) {
     102        for ( SeqIterRev(Fred) riter = { fred }; riter | f; ) {
    102103                sout | f.i | ' ';
    103104        }
     
    109110
    110111        sout | head( fred ).i | succ( fred, head )->i | tail( fred ).i | nl;
    111         for ( over( fredIter, fred ); fredIter >> f; ) {
     112        for ( over( iter, fred ); iter | f; ) {
    112113                sout | f.i | ' ';
    113114        }
     
    119120        delete( &dropTail( fred ) );
    120121
    121         for ( over( fredIter, fred ); fredIter >> f; ) {
     122        for ( over( iter, fred ); iter | f; ) {
    122123                sout | f.i | ' ';
    123124        }
     
    128129        split( fred2, fred, middle );
    129130
    130         for ( over( fredIter, fred ); fredIter >> f; ) {
    131                 sout | f.i | ' ';
    132         }
    133         sout | nl;
    134 
    135         for ( over( fredIter, fred2 ); fredIter >> f; ) {
     131        for ( over( iter, fred ); iter | f; ) {
     132                sout | f.i | ' ';
     133        }
     134        sout | nl;
     135
     136        for ( over( iter, fred2 ); iter | f; ) {
    136137                sout | f.i | ' ';
    137138        }
     
    140141        transfer( fred, fred2 );
    141142
    142         for ( over( fredIter, fred ); fredIter >> f; ) {
    143                 sout | f.i | ' ';
    144         }
    145         sout | nl;
    146 
    147         for ( over( fredIter, fred ); fredIter >> f; ) {
     143        for ( over( iter, fred ); iter | f; ) {
     144                sout | f.i | ' ';
     145        }
     146        sout | nl;
     147
     148        for ( over( iter, fred ); iter | f; ) {
    148149                delete( &f );
    149150        }
     
    168169
    169170        Sequence(Mary) mary;
    170         SeqIter(Mary) maryIter = { mary };
     171        SeqIter(Mary) iter = { mary };
    171172        Mary & m;
    172173
    173         for ( ; maryIter >> m; ) {                                                      // empty list
     174        for ( ; iter | m; ) {                                                   // empty list
    174175                sout | m.i | m.j | ' ';
    175176        }
     
    182183        sout | head( mary ).i | tail( mary ).i | nl;
    183184
    184         for ( SeqIter(Mary) iter = { mary }; iter >> m; ) {
     185        for ( SeqIter(Mary) iter = { mary }; iter | m; ) {
    185186                sout | m.i | m.j | ' ';
    186187        }
     
    191192        }
    192193
    193         for ( over( maryIter, mary ); maryIter >> m; ) {
     194        for ( over( iter, mary ); iter | m; ) {
    194195                sout | m.i | m.j | ' ';
    195196        }
     
    200201        }
    201202
    202         Mary * head = new( -1 ), tail = { -1 };
     203        Mary * head = new( -1 ), tail = { -2 };
    203204        addHead( mary, *head );
    204205        addTail( mary, tail );
     206
    205207        sout | head( mary ).i | succ( mary, head )->i | tail( mary ).i | nl;
     208
     209        for ( over( iter, mary ); iter | m; ) {
     210                sout | m.i | m.j | ' ';
     211        }
     212        sout | nl;
     213
    206214        remove( mary, *head );
    207215        remove( mary, tail );
     
    209217        delete( &dropTail( mary ) );
    210218
    211         for ( over( maryIter, mary ); maryIter >> m; ) {
    212                 sout | m.i | m.j | ' ';
    213         }
    214         sout | nl;
    215 
    216         for ( over( maryIter, mary ); maryIter >> m; ) {
     219        for ( over( iter, mary ); iter | m; ) {
     220                sout | m.i | m.j | ' ';
     221        }
     222        sout | nl;
     223
     224        for ( i; 5 ) {
     225                delete( &dropTail( mary ) );
     226        }
     227        for ( over( iter, mary ); iter | m; ) {
     228                sout | m.i | m.j | ' ';
     229        }
     230        sout | nl;
     231
     232        for ( over( iter, mary ); iter | m; ) {
    217233                delete( &remove( mary, m ) );
    218234        }
     235        for ( over( iter, mary ); iter | m; ) {
     236                sout | m.i | m.j | ' ';
     237        }
     238        sout | "empty" | nl;
    219239
    220240        Mary & middle;
     
    225245                }
    226246        }
    227         for ( SeqIter(Mary) iter = { mary }; iter >> m; ) {
     247        for ( SeqIter(Mary) iter = { mary }; iter | m; ) {
    228248                sout | m.i | m.j | ' ';
    229249        }
     
    234254        split( mary2, mary, middle );
    235255
    236         for ( over( maryIter, mary ); maryIter >> m; ) {
    237                 sout | m.i | m.j | ' ';
    238         }
    239         sout | nl;
    240         for ( over( maryIter, mary2 ); maryIter >> m; ) {
     256        for ( over( iter, mary ); iter | m; ) {
     257                sout | m.i | m.j | ' ';
     258        }
     259        sout | nl;
     260        for ( over( iter, mary2 ); iter | m; ) {
    241261                sout | m.i | m.j | ' ';
    242262        }
     
    245265        transfer( mary, mary2 );
    246266
    247         for ( over( maryIter, mary ); maryIter >> m; ) {
    248                 sout | m.i | m.j | ' ';
    249         }
    250         sout | nl;
    251         for ( over( maryIter, mary ); maryIter >> m; ) {
     267        for ( over( iter, mary ); iter | m; ) {
     268                sout | m.i | m.j | ' ';
     269        }
     270        sout | nl;
     271
     272        for ( over( iter, mary ); iter | m; ) {
    252273                delete( &m );
    253274        }
  • tests/collections/stack.cfa

    rb6460bf r3e36f22  
    1919
    2020        Stack(Fred) fred;
    21         StackIter(Fred) fredIter = { fred };
     21        StackIter(Fred) inter = { fred };
    2222        Fred & f;
    2323
    2424        sout | nlOff;                                                                           // turn off auto newline
    2525
    26         for ( ; fredIter >> f; ) {                                                      // empty list
     26        for ( ; inter | f; ) {                                                  // empty list
    2727                sout | f.i | ' ';
    2828        }
     
    3333        }
    3434
    35         for ( StackIter(Fred) iter = { fred }; iter >> f; ) {
     35        for ( StackIter(Fred) iter = { fred }; iter | f; ) {
    3636                sout | f.i | ' ';
    3737        }
     
    4444        }
    4545
    46         for ( over( fredIter, fred ); fredIter >> f; ) {
     46        for ( over( inter, fred ); inter | f; ) {
    4747                sout | f.i | ' ';
    4848        }
     
    5252                push( fred, *new( 2 * i + 1 ) );
    5353        }
    54         for ( over( fredIter, fred ); fredIter >> f; ) {
     54        for ( over( inter, fred ); inter | f; ) {
    5555                sout | f.i | ' ';
    5656        }
    5757        sout | nl;
    5858
    59         for ( over( fredIter, fred ); fredIter >> f; ) {
     59        for ( over( inter, fred ); inter | f; ) {
    6060                delete( &f );
    6161        }
     
    8181        Mary & m;
    8282
    83         for ( ; maryIter >> m; ) {                                                      // empty list
     83        for ( ; maryIter | m; ) {                                                       // empty list
    8484                sout | m.i | m.j | ' ';
    8585        }
     
    9090        }
    9191
    92         for ( StackIter(Mary) iter = { mary }; iter >> m; ) {
     92        for ( StackIter(Mary) iter = { mary }; iter | m; ) {
    9393                sout | m.i | m.j | ' ';
    9494        }
     
    9999        }
    100100
    101         for ( over( maryIter, mary ); maryIter >> m; ) {
     101        for ( over( maryIter, mary ); maryIter | m; ) {
    102102                sout | m.i | m.j | ' ';
    103103        }
     
    107107                push( mary, *new( 2 * i + 1 ) );
    108108        }
    109         for ( over( maryIter, mary ); maryIter >> m; ) {
     109        for ( over( maryIter, mary ); maryIter | m; ) {
    110110                sout | m.i | m.j | ' ';
    111111        }
    112112        sout | nl;
    113113
    114         for ( over( maryIter, mary ); maryIter >> m; ) {
     114        for ( over( maryIter, mary ); maryIter | m; ) {
    115115                delete( &m );
    116116        }
Note: See TracChangeset for help on using the changeset viewer.