/Users/dbr/ma/src/bas/lml/bitSequence.c

Go to the documentation of this file.

#include "base.h"

#define mBitsTo64( n ) ( ((n) % 64 == 0) ? ((n)/64) : ((n)/64 + 1) )

BitSequence * BitSequenceInit(){
    return BitSequenceInit2( 64, -1 );
}

BitSequence * BitSequenceInit2( UINT seqAlloced, SINT growth ){
    BitSequence * seq;

    seq = (BitSequence *)Malloc( 1, sizeof(BitSequence) );
    seq->seqStored = 0;
    seq->seqAlloced = seqAlloced;
    seq->seq = (U64 *)Malloc( mBitsTo64( seq->seqAlloced ), sizeof(U64) );
    seq->growth = growth;
    return seq;
}

void BitSequenceFree( BitSequence * seq ){
    Free( seq->seq );
    Free( seq );
}

void BitSequenceAdd( BitSequence * seq, UINT 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 = (U64 *)Realloc( seq->seq, mBitsTo64(mem), sizeof(U64) );
        seq->seqAlloced = mem;
    }
    BitSequenceSet(seq, seq->seqStored, elementToAdd);
    seq->seqStored++;
}

void BitSequenceWrite( BitSequence * seq, FILE * fp ){
    UINT i, n;
    U8 * element;

    n = mBitsTo64( seq->seqStored );
    if( endiannessOfThisMachine != endiannessOnWrite ){
        for( i = 0; i < n; i++ ){
            element = (U8 *)( seq->seq + i ); mReverseBytes( element, sizeof(U64) )
        }
        element = (U8 *)(&(seq->seqStored)); mReverseBytes( element, sizeof(UINT) )
    }
    mWriteEndianness( fp, endiannessOnWrite )
    Fwrite( &(seq->seqStored), sizeof(UINT), 1, fp );
    Fwrite( seq->seq, sizeof(U64), n, fp );
    if( endiannessOfThisMachine != endiannessOnWrite ){
        element = (U8 *)(&(seq->seqStored)); mReverseBytes( element, sizeof(UINT) )
        for( i = 0; i < n; i++ ){
            element = (U8 *)( seq->seq + i ); mReverseBytes( element, sizeof(U64) )
        }
    }
}

BitSequence * BitSequenceRead( FILE * fp ){
    BitSequence * seq;
    U8 * element;
    UINT i, n, seqStored, endianness;

    mReadEndianness( fp, endianness )
    Fread( &seqStored, sizeof(UINT), 1, fp );
    if( endiannessOfThisMachine != endiannessOnWrite ){
        element = (U8 *)(&seqStored); mReverseBytes( element, sizeof(UINT) )
    }
    seq = BitSequenceInit2( seqStored, 1 );
    Fread( seq->seq, sizeof(U64), mBitsTo64( seqStored ), fp );
    seq->seqStored = seqStored;
    if( endiannessOfThisMachine != endiannessOnWrite ){
        n = mBitsTo64( seq->seqStored );
        for( i = 0; i < n; i++ ){
            element = (U8 *)( seq->seq + i ); mReverseBytes( element, sizeof(U64) )
        }
    }
    return seq;
}

void BitSequenceShrink( BitSequence * seq ){
    seq->seq = Realloc( seq->seq, mBitsTo64( seq->seqStored ), sizeof(U64) );
    seq->seqAlloced = seq->seqStored;
}

UINT BitSequenceGet( const BitSequence * seq, UINT position ){
    U64 n;

    n = 1;
    n <<= (position % 64);
    if( (seq->seq[position/64] & n) == 0 ){
        return 0;
    }
    return 1;
}

void BitSequenceSet( BitSequence * seq, UINT position, UINT value ){
    U64 n;

    n = 1;
    n <<= (position % 64);
    if( value == 0 ){
        seq->seq[position/64] &= (~n);
    }
    else{
        seq->seq[position/64] |= n;
    }
}

void BitSequenceAppend( BitSequence * seq, const BitSequence * s ){
    UINT i;

    for( i = 0; i < s->seqStored; i++ ){
        BitSequenceAdd( seq, BitSequenceGet(s, i) );
    }
}

void BitSequenceCpy( BitSequence * dest, const BitSequence * src ){
    dest->seqStored = 0;
    BitSequenceAppend( dest, src );
}