#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 );
	}
}