source: libcfa/src/enum.hfa @ ad47ec4

#pragma once

#include "iostream.hfa"

forall( E ) trait Bounded {
        E lowerBound(void);
        E upperBound(void);
};

forall( E | Bounded( E ) ) trait Serial {
        int fromInstance( E e );
        E fromInt_unsafe( int i );
        E succ_unsafe( E e );
        E pred_unsafe( E e );
};

forall( E | Serial( E ) ) {
        E fromInt( int i );
        E succ( E e );
        E pred( E e );
        int Countof( E );
}

// forall( E | Bounded(E) ) trait SafeSerial {
//       // unsigned fromInstance( E e );
//       E fromInt_unsafe( unsigned i );
//       // E succ_unsafe( E e );
//       //E pred_unsafe( E e );

//       unsigned fromInstance( E e );
//       E fromInt( unsigned i );
//       E succ( E e );
//       E pred( E e );
// };

forall( E ) trait CfaEnum {
        const char * label( E e );
        int posn( E e );
};

forall( E, V | CfaEnum( E ) ) trait TypedEnum {
        V value( E e );
};

// I/O

forall( istype & | istream( istype ), E | CfaEnum( E ) | Serial(E) )
istype & ?|?( istype &, E & );

forall( ostype & | ostream( ostype ), E | CfaEnum( E ) ) {
        ostype & ?|?( ostype &, E );
        OSTYPE_VOID( E );
}

static inline
forall( E | CfaEnum(E) | Serial(E) ) {
        int ?==?( E l, E r ) { return posn( l ) == posn( r ); } // relational operators
        int ?!=?( E l, E r ) { return posn( l ) != posn( r ); }
        int ?<?( E l, E r ) { return posn( l ) < posn( r ); }
        int ?<=?( E l, E r ) { return posn( l ) <= posn( r ); }
        int ?>?( E l, E r ) { return posn( l ) > posn( r ); }
        int ?>=?( E l, E r ) { return posn( l ) >= posn( r ); }

        E ++?( E & l ) {                                                                        // increment operators
                int pos = posn(l);
                l = fromInt_unsafe(pos+1);
                return l;
        }

        E --?( E & l ) {
                int pos = posn(l);
                l = fromInt_unsafe(pos-1);
                return l;
        }

        E ?+=? ( E & l, one_t ) {
                int pos = posn(l);
                l = fromInt_unsafe(pos+1);
                return l;
        }

        E ?-=? ( E & l, one_t ) {
                int pos = posn(l);
                l = fromInt_unsafe(pos-1);
                return l;
        }

        E ?+=? ( E & l, int i ) {
                int pos = posn(l);
                l = fromInt_unsafe(pos+i);
                return l;
        }

        E ?-=? ( E & l, int i ) {
                int pos = posn(l);
                l = fromInt_unsafe(pos-i);
                return l;
        }

        E ?++( E & l ) {
                int pos = posn(l);
                l = fromInt_unsafe(pos+1);
                return fromInt_unsafe(pos);
        }

        E ?--( E & l ) {
                int pos = posn(l);
                l = fromInt_unsafe(pos-1);
                return fromInt_unsafe(pos);
        }
}