source: tests/collections/queue.cfa @ 26a249c

#include <fstream.hfa>
#include <stdlib.hfa>                                                                   // new, delete
#include <bits/queue.hfa>

int main() {
        // Fred test

        struct Fred {
                inline Colable;                                                                 // Plan 9 inheritance
                int i;
        };
        void ?{}( Fred & fred ) { abort(); }
        void ?{}( Fred & fred, int p ) with( fred ) {
                i = p;
        }
        Fred *& Next( Fred * n ) {
                return (Fred *)Next( (Colable *)n );
        }

        Queue(Fred) fred;
        QueueIter(Fred) fredIter = { fred };
        Fred & f;

        sout | nlOff;                                                                           // turn off auto newline

        for ( ; fredIter >> f; ) {                                                      // empty list
                sout | f.i | ' ';
        }
        sout | "empty" | nl;
        
        for ( i; 10 ) {
                add( fred, *new( 2 * i ) );
        }

        sout | head(fred).i | nl;
        sout | tail(fred).i | nl;

        for ( QueueIter(Fred) iter = { fred }; iter >> f; ) {
                sout | f.i | ' ';
        }
        sout | nl;

        for ( i; 9 ) {
                delete( &drop( fred ) );
        }

        for ( over( fredIter, fred ); fredIter >> f; ) {
                sout | f.i | ' ';
        }
        sout | nl;
        
        for ( i; 10 ) {
                add( fred, *new( 2 * i + 1 ) );
        }

        Fred * front = new( -1 );
        addHead( fred, *front );
        sout | succ( fred, front )->i | nl;
        remove( fred, *front );
        delete( front );

        Fred & end = dropTail( fred );
        delete( &end );

        for ( over( fredIter, fred ); fredIter >> f; ) {
                sout | f.i | ' ';
        }
        sout | nl;

        for ( over( fredIter, fred ); fredIter >> f; ) {
                delete( &f );
        }

        Queue(Fred) fred0;
        Fred * middle;
        for ( i; 10 ) {
                if( i == 5) {
                        middle = new( i );
                        add( fred0, *middle );
                        continue;
                }
                add( fred0, *new( i ) );
        }

        for ( QueueIter(Fred) iter = { fred0 }; iter >> f; ) {
                sout | f.i | ' ';
        }
        sout | nl;

        Queue(Fred) fred2;

        split( fred2, fred0, *middle);

        for ( over( fredIter, fred0 ); fredIter >> f; ) {
                sout | f.i | ' ';
        }
        sout | nl;

        for ( over( fredIter, fred2 ); fredIter >> f; ) {
                sout | f.i | ' ';
        }
        sout | nl;

        transfer( fred0, fred2);

        for ( over( fredIter, fred0 ); fredIter >> f; ) {
                sout | f.i | ' ';
        }
        sout | nl;

        for ( over( fredIter, fred0 ); fredIter >> f; ) {
                delete( &f );
        }

        // Mary test

        struct Mary {
                inline Fred;                                                                    // Plan 9 inheritance
                int j;
        };
        void ?{}( Mary & mary ) { abort(); }
        void ?{}( Mary & mary, int p ) with( mary ) {
                ((Fred &)mary){ p };
                j = i = p;
        }

        Mary *& Next( Mary * n ) {
                return (Mary *)Next( (Fred *)n );
        }

        Queue(Mary) mary;
        QueueIter(Mary) maryIter = { mary };
        Mary & m;

        for ( ; maryIter >> m; ) {                                                      // empty list
                sout | m.i | m.j | ' ';
        }
        sout | "empty" | nl;
        
        for ( i; 10 ) {
                add( mary, *new( 2 * i ) );
        }

        for ( QueueIter(Mary) iter = { mary }; iter >> m; ) {
                sout | m.i | m.j | ' ';
        }
        sout | nl;
        
        for ( i; 9 ) {
                delete( &drop( mary ) );
        }

        for ( over( maryIter, mary ); maryIter >> m; ) {
                sout | m.i | m.j | ' ';
        }
        sout | nl;
        
        for ( i; 10 ) {
                add( mary, *new( 2 * i + 1 ) );
        }
        for ( over( maryIter, mary ); maryIter >> m; ) {
                sout | m.i | m.j | ' ';
        }
        sout | nl;

        for ( over( maryIter, mary ); maryIter >> m; ) {
                delete( &m );
        }
}