source: libcfa/src/bits/collection.hfa@ 234ede4

#pragma once

struct Colable {
        Colable * next;                                                                         // next node in the list
        // invariant: (next != 0) <=> listed()
};

inline {
        void ?{}( Colable & co ) with( co ) {
                next = 0p;
        } // post: ! listed()

        // return true iff *this is an element of a collection
        bool listed( Colable & co ) with( co ) {                        // pre: this != 0
                return next != 0p;
        }

        Colable * getNext( Colable & co ) with( co ) {
                return next;
        }

        Colable *& Next( Colable * cp ) {
                return cp->next;
        }

        forall( dtype T ) {
                T *& Next( T * n ) {
                        return (T *)Next( (Colable *)n );
                }

                bool listed( T * n ) {
                        return Next( (Colable *)n ) != 0p;
                }
        } // distribution
} // distribution


struct Collection {
        void * root;                                                                            // pointer to root element of list
};

inline {
        // class invariant: root == 0 & empty() | *root in *this
        void ?{}( Collection &, const Collection & ) = void; // no copy
        Collection & ?=?( const Collection & ) = void;          // no assignment

        void ?{}( Collection & collection ) with( collection ) {        
                root = 0p;
        } // post: empty()

        bool empty( Collection & collection ) with( collection ) { // 0 <=> *this contains no elements
                return root == 0p;
        }

        void * head( Collection & collection ) with( collection ) {
                return root;
        } // post: empty() & head() == 0 | !empty() & head() in *this
} // distribution


struct ColIter {
        void * curr;                                                                            // element to be returned by >>
};

inline {
        void ?{}( ColIter & colIter ) with( colIter ) {
                curr = 0p;
        } // post: elts = null

        forall( dtype T ) {
                T * Curr( ColIter & ci ) with( ci ) {
                        return (T *)curr;
                }
        } // distribution
} // distribution