/Users/dbr/ma/src/bas/lml/sequence.h

Go to the documentation of this file.

#ifndef _HEADER_FILE_SEQUENCE_
#define _HEADER_FILE_SEQUENCE_

#define mSequenceDeclare(Type)\
typedef struct t##Type##Sequence{\
    Type * seq;\
    UINT seqStored;\
    UINT seqAlloced;\
    SINT growth;\
} Type##Sequence;\
Type##Sequence * Type##SequenceInit();\
Type##Sequence * Type##SequenceInit2( UINT seqAlloced, SINT growth );\
void Type##SequenceFree( Type##Sequence * seq );\
void Type##SequenceAdd( Type##Sequence * seq, Type elementToAdd );\
void Type##SequenceWrite( const Type##Sequence * seq, FILE * fp );\
Type##Sequence * Type##SequenceRead( FILE * fp );\
void Type##SequenceAlloc( Type##Sequence * seq, UINT seqAlloced );\
void Type##SequenceShrink( Type##Sequence * seq );\
void Type##SequenceAppend( Type##Sequence * seq, const Type##Sequence * s );\
void Type##SequenceCpy( Type##Sequence * dest, const Type##Sequence * src );

    #define mSequenceDefine(Type)\
    Type##Sequence * Type##SequenceInit(){\
        return Type##SequenceInit2( 64, -1 );\
    }\
    Type##Sequence * Type##SequenceInit2( UINT seqAlloced, SINT growth ){\
        Type##Sequence * seq;\
        seq = (Type##Sequence *)Malloc( 1, sizeof(Type##Sequence) );\
        seq->seqStored = 0;\
        seq->seqAlloced = seqAlloced;\
        seq->growth = growth;\
        seq->seq = (Type *)Malloc( seqAlloced, sizeof(Type) );\
        return seq;\
    }\
    void Type##SequenceFree( Type##Sequence * seq ){\
        if( seq->seq != NULL ){\
            Free( seq->seq );\
        }\
        Free( seq );\
    }\
    void Type##SequenceAdd( Type##Sequence * seq, Type elementToAdd ){\
        if( seq->seqStored == seq->seqAlloced ){\
            UINT mem;\
            if( seq->growth < 0 ){\
                mem = seq->seqAlloced + seq->seqAlloced / ((UINT)(-seq->growth));\
            }\
            else{\
                mem = seq->seqAlloced + seq->growth;\
            }\
            if( mem <= seq->seqAlloced ){\
                mem++;\
            }\
            seq->seq = (Type *)Realloc( seq->seq, mem, sizeof(Type) );\
            seq->seqAlloced = mem;\
        }\
        seq->seq[seq->seqStored] = elementToAdd;\
        seq->seqStored++;\
    }\
    void Type##SequenceWrite( const Type##Sequence * seq, FILE * fp ){\
        UINT i;\
        U8 * element;\
        if( endiannessOfThisMachine != endiannessOnWrite ){\
            if( sizeof(Type) != 1 ){\
                for( i = 0; i < seq->seqStored; i++ ){\
                    element = (U8 *)( seq->seq + i ); mReverseBytes( element, sizeof(Type) )\
                }\
            }\
            element = (U8 *)(&(seq->seqStored)); mReverseBytes( element, sizeof(UINT) )\
        }\
        mWriteEndianness( fp, endiannessOnWrite )\
        Fwrite( &(seq->seqStored), sizeof(UINT), 1, fp );\
        if( endiannessOfThisMachine != endiannessOnWrite ){\
            element = (U8 *)(&(seq->seqStored)); mReverseBytes( element, sizeof(UINT) )\
        }\
        Fwrite( seq->seq, sizeof(Type), seq->seqStored, fp );\
        if( sizeof(Type) != 1 && endiannessOfThisMachine != endiannessOnWrite ){\
            for( i = 0; i < seq->seqStored; i++ ){\
                element = (U8 *)( seq->seq + i ); mReverseBytes( element, sizeof(Type) )\
            }\
        }\
    }\
    Type##Sequence * Type##SequenceRead( FILE * fp ){\
        UINT endianness, seqStored;\
        Type##Sequence * seq;\
        U8 * element;\
        UINT i;\
        mReadEndianness( fp, endianness )\
        Fread( &seqStored, sizeof(UINT), 1, fp );\
        if( endiannessOfThisMachine != endianness ){\
            element = (U8 *)(&seqStored); mReverseBytes( element, sizeof(UINT) )\
        }\
        seq = Type##SequenceInit2( seqStored, 1 );\
        Fread( seq->seq, sizeof(Type), seqStored, fp );\
        seq->seqStored = seqStored;\
        if( sizeof(Type) != 1 && endiannessOfThisMachine != endianness ){\
            for( i = 0; i < seq->seqStored; i++ ){\
                element = (U8 *)( seq->seq + i ); mReverseBytes( element, sizeof(Type) )\
            }\
        }\
        return seq;\
    }\
    void Type##SequenceAlloc( Type##Sequence * seq, UINT seqAlloced ){\
        seq->seq = Realloc( seq->seq, seqAlloced, sizeof(Type) );\
        seq->seqAlloced = seqAlloced;\
    }\
    void Type##SequenceShrink( Type##Sequence * seq ){\
        Type##SequenceAlloc( seq, seq->seqStored );\
    }\
    void Type##SequenceAppend( Type##Sequence * seq, const Type##Sequence * s ){\
        UINT i;\
        for( i = 0; i < s->seqStored; i++ ){\
            Type##SequenceAdd( seq, s->seq[i] );\
        }\
    }\
    void Type##SequenceCpy( Type##Sequence * dest, const Type##Sequence * src ){\
        dest->seqStored = 0;\
        Type##SequenceAppend( dest, src );\
    }
#endif