/Users/dbr/ma/src/lmu/cis/sis/adapter/ScdawgAdapter.cpp

Go to the documentation of this file.

#ifndef SCDAWGADAPTERADAPTER_CPP
#define SCDAWGADAPTERADAPTER_CPP

#include "ScdawgAdapter.hpp"

namespace lmu { namespace cis { namespace sis {

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
UINT SCDAWGAdapter::Add( const VoidSequence * sharpDocumentDollar ) {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual inline void SCDAWGAdapter::Add( VoidSequence * sharpDocumentDollar )" << std::endl;

    assert (ManagedAutomatonStage_ < CLOSED);

    /* We exceptionally need to cast the const away */
    VoidSequence * nc_sharpDocumentDollar = const_cast<VoidSequence*>(sharpDocumentDollar);

    /* Shamelessly stolen from scdawg.c because we need the last
       created sinkstate per document in the right automaton
       but the original method doesn't provide it.
    */
    UINT i, numberOfStates, numberOfNewStates, sinkstate;

    numberOfStates = help()->left->aut->statesTransitions->seqStored;
    sinkstate = CDAWGAdd( help()->right, nc_sharpDocumentDollar );

    assert(sinkstate != NO);

    VoidSequenceReverse( nc_sharpDocumentDollar );
    CDAWGAdd( help()->left, nc_sharpDocumentDollar );

    numberOfNewStates = help()->left->aut->statesTransitions->seqStored;
    for( i = numberOfStates; i < numberOfNewStates; i++ ){
        UINTSequenceAdd( help()->leftToRight, NO );
    }
    help()->leftToRight->seq[help()->left->aut->initialState] = help()->right->aut->initialState;
    for( i = numberOfStates; i < numberOfNewStates; i++ ){
        if( help()->leftToRight->seq[i] == NO ){
            help()->leftToRight->seq[i] = FindRightState( i );
        }
    }
    return sinkstate;
}


UINT SCDAWGAdapter::FindRightState( UINT l ) {
    /* verbatim from scdawg.c (function is static there) */
    TransitionFromStartTo tfst;
    UINT q, tr;

    q = help()->left->statesSuffixLink->seq[l];
    if( help()->leftToRight->seq[q] == NO ){
        help()->leftToRight->seq[q] = FindRightState( q );
    }
    tfst.from = help()->leftToRight->seq[q];
    tfst.symbol = mVoidSequenceElement( mLeft()->data, mLeft()->statesEnd->seq[l] - help()->left->statesLength->seq[q] );
    tr = HashGetIndex( help()->right->hash, &tfst );

    return mRight()->transitionsTo->seq[tr];
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SCDAWG * SCDAWGAdapter::Read( FILE * fp ) {
    if (DEBUG_LEVEL >= 5) std::cerr << "SCDAWG * SCDAWGAdapter::Read( FILE * fp )" << std::endl;

    C_SCDAWG = SCDAWGRead( fp );

    ManagedAutomatonStage_ = CLOSED;

    return C_SCDAWG;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SCDAWG * SCDAWGAdapter::Read( const S8* fn ) {
    if (DEBUG_LEVEL >= 5) std::cerr << "T * TAdapter::Read( FILE * fp )" << std::endl;

    FILE* fpIn = Fopen(fn, "rb");
    Read( fpIn );   //< will write into member SCDAWG* C_SCDAWG
    Fclose(fpIn);

    ManagedAutomatonStage_ = CLOSED;

    return C_SCDAWG;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::Close() {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual inline void SCDAWGAdapter::Close()" << std::endl;

    if ( ManagedAutomatonStage_ >= SORTED) {
        VoidSequenceFree( mLeft()->data );
        mLeft()->data = NULL;
        ManagedAutomatonStage_ = CLOSED;
        return;
    }
    if ( ManagedAutomatonStage_ < CLOSED ) {
        SCDAWGClose( C_SCDAWGBuildHelp );
        // C_SCDAWGBuildHelp = nullptr;
        ManagedAutomatonStage_ = CLOSED;
        return;
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::Shrink() {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual inline void SCDAWGAdapter::Shrink()" << std::endl;

    assert (ManagedAutomatonStage_ < CLOSED);

    SCDAWGShrink( C_SCDAWG );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::Write( FILE * fp ) {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual inline void SCDAWGAdapter::Write( FILE * fp )" << std::endl;

    assert (ManagedAutomatonStage_ == CLOSED);

    SCDAWGWrite( C_SCDAWG, fp );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::Write( const S8* fn ) {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual inline void SCDAWGAdapter::Write(  const S8* fn )" << std::endl;

    assert (ManagedAutomatonStage_ == CLOSED);

    FILE * fpOut = Fopen(fn, "wb");
    SCDAWGWrite( C_SCDAWG, fpOut );
    Fclose(fpOut);
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::DumpStat( FILE * fp ) const {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual void SCDAWGAdapter::DumpStat( FILE * fp ) const" << std::endl;

    assert (ManagedAutomatonStage_ >= SORTED);

    SCDAWGDumpStat( C_SCDAWG, fp );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::DumpStat( const S8* fn ) const {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual void SCDAWGAdapter::DumpStat( const S8* fn ) const" << std::endl;

    assert (ManagedAutomatonStage_ >= SORTED);

    FILE * fpOut;
    try {
        fpOut = Fopen(fn, "wb");
    } catch (...) {
        std::cerr << "Could not open file " << fn << std::endl;
    }
    SCDAWGDumpStat( C_SCDAWG, fpOut );
    Fclose(fpOut);
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::DumpGV( const S8 * fn, UINT encoding ) const {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual inline void SCDAWGAdapter::DumpGV( FILE * fp, void (*DumpLabel)(const SCDAWG *, FILE *, UINT, boolean, UINT), UINT encoding ) const" << std::endl;

    assert (ManagedAutomatonStage_ >= SORTED);

    FILE * fpOut;
    try {
        fpOut = Fopen(fn, "wb");
    } catch (...) {
        std::cerr << "Could not open file " << fn << std::endl;
    }
    SCDAWGDumpGV( C_SCDAWG, fpOut, DumpSCDAWGLabel, encoding );
    Fclose(fpOut);
}

void SCDAWGAdapter::DumpGVRight( const S8 * fn, UINT encoding) const {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual inline void SCDAWGAdapter::DumpGV( FILE * fp, void (*DumpLabel)(const SCDAWG *, FILE *, UINT, boolean, UINT), UINT encoding ) const" << std::endl;

    assert (ManagedAutomatonStage_ >= SORTED);

    FILE * fpOut;
    try {
        fpOut = Fopen(fn, "wb");
    } catch (...) {
        std::cerr << "Could not open file " << fn << std::endl;
    }
    CompressedAutomatonDumpGV( C_SCDAWG->right, fpOut, DumpLabel, encoding );
    Fclose(fpOut);
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::AddTarjanTable() {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual void SCDAWGAdapter::AddTarjanTable()" << std::endl;

    assert (ManagedAutomatonStage_ < TARJANTABLE);

    SCDAWGAddTarjanTable( C_SCDAWG );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::GenerateLanguage( const S8* fnOut, UINT encoding ) const {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual inline void SCDAWGAdapter::GenerateLanguage( const S8* fn, UINT encoding = ENCODING_PLAIN ) const" << std::endl;

    assert (ManagedAutomatonStage_ >= SORTED);

    SCDAWG* aut = C_SCDAWG;

    // ->GenerateLanguage( fnOut, encoding );
    FILE * fpOutput = Fopen( fnOut, "wb" );
    CompressedAutomatonGenerateLanguage( C_SCDAWG->right, fpOutput, DumpSequenceOfLabels, encoding );
    Fclose( fpOutput );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::SortTransitions() {
    if (DEBUG_LEVEL >= 5) std::cerr << "SCDAWGAdapter::SortTransitions()" << std::endl;

    assert( ManagedAutomatonStage_ > EMPTY && ManagedAutomatonStage_ < CLOSED );
    assert( C_SCDAWGBuildHelp != nullptr );

    if (ManagedAutomatonStage_ < SORTED) {
        if (DEBUG_LEVEL >= 3) std::cerr << "Sorting." << std::endl;
        UINT i, j, s;
        CompressedAutomatonSortTransitions( mRight(), help()->right->transitionsFrom );

        for( i = 0; i < mCompressedAutomatonGetTransitionsStored(mLeft()); i++ ){
            s = mLeft()->transitionsTo->seq[i];
            j = mLeft()->statesEnd->seq[s] - mLeft()->transitionsStart->seq[i];
            s = help()->leftToRight->seq[s];
            mLeft()->transitionsStart->seq[i] = (mRight()->statesEnd->seq[s] + 1) - help()->right->statesLength->seq[s] + j;
        }
        for( i = 0; i < mCompressedAutomatonGetTransitionsStored(mLeft()); i++ ){
            help()->left->transitionsFrom->seq[i] = help()->leftToRight->seq[help()->left->transitionsFrom->seq[i]];
            mLeft()->transitionsTo->seq[i] = help()->leftToRight->seq[mLeft()->transitionsTo->seq[i]];
        }
        for( i = 0; i < mCompressedAutomatonGetStatesStored( mLeft() ); i++ ){
            if( help()->right->statesLength->seq[i] != 0 ){
                mLeft()->statesEnd->seq[i] = (mRight()->statesEnd->seq[i] + 1) - help()->right->statesLength->seq[i];
            }
        }
        // VoidSequenceFree( mLeft()->data ); mLeft()->data = mRight()->data;
        // CompressedAutomatonSortTransitions( mLeft(), help()->left->transitionsFrom );
        // mLeft()->data = NULL;
    } else {
        if (DEBUG_LEVEL >= 3) std::cerr << "Automaton sorted already." << std::endl;
    }
    ManagedAutomatonStage_ = SORTED;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
UINT SCDAWGAdapter::suffixLink( const UINT& state ) const {
    if (DEBUG_LEVEL >= 5) std::cerr << "UINT SCDAWGAdapter::suffixLink( const UINT& state ) const" << std::endl;
    return buildhelp()->right->statesSuffixLink->seq[state];
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
CompressedAutomaton* SCDAWGAdapter::automaton() const {
    if (DEBUG_LEVEL >= 5) std::cerr << "CompressedAutomaton* SCDAWGAdapter::automaton() const" << std::endl;
    return C_SCDAWG->right;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
CompressedAutomaton* SCDAWGAdapter::left_automaton() const {
    if (DEBUG_LEVEL >= 5) std::cerr << "SCDAWGAdapter::left_automaton() const" << std::endl;
    return C_SCDAWG->left;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
PairState SCDAWGAdapter::GetInitialPairState( ) const {
    if (DEBUG_LEVEL >= 5) std::cerr << "virtual inline PairState SCDAWGAdapter::GetInitialPairState( ) const" << std::endl;

    assert (ManagedAutomatonStage_ > EMPTY);

    return CompressedAutomatonGetInitialPairState( automaton() );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SCDAWGBuildHelp* SCDAWGAdapter::buildhelp() const {
    assert (ManagedAutomatonStage_ < CLOSED);

    return C_SCDAWGBuildHelp;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
PairState SCDAWGAdapter::Delta( const PairState * state, const void * symbol ) const {
    assert (ManagedAutomatonStage_ >= SORTED);

    return CompressedAutomatonDelta( automaton(), state, symbol );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void SCDAWGAdapter::BuildSCDAWG( const S8 * fileNameInput,
                                 const S8 * fileNameOutput,
                                 UINT bitsPerSymbol,
                                 UINT encoding,
                                 boolean tarjanTable )
{   //TODO?
    FILE * fpInput;
    FILE * fpOutput;
    VoidSequence * line = NULL;
    VoidSequence * sharpDocumentDollar = NULL;

    // #ifndef __cplusplus
    SCDAWG * aut;
    SCDAWGBuildHelp * help;
    // #endif

    UINT i, n, nLine, symbolSize;
    mSymbolAndVariables( zero )
    mSymbolAndVariables( one )

    mValidateBitsPerSymbol( bitsPerSymbol )
    symbolSize = bitsPerSymbol/8;
    mSymbolAssignValue( zero, 0, symbolSize )
    mSymbolAssignValue( one, 1, symbolSize )

    #ifndef __cplusplus
    aut = SCDAWGInit( symbolSize );
    help = SCDAWGBuildHelpInit( aut );
    #else
    aut = C_SCDAWG;
    help = C_SCDAWGBuildHelp;
    #endif

    fpInput = Fopen( fileNameInput, "rb" );
    nLine = 0;
    while( bTRUE ){
        if( line != NULL ){
            VoidSequenceFree( line );
        }
        line = VoidSequenceReadLine( fpInput, symbolSize, encoding );
        if( line == NULL ){
            break;
        }
        nLine++;
        for( i = 0; i < line->seqStored; i++ ){
            n = SymbolToUINT( mVoidSequenceElement(line, i), symbolSize );
            if( n == 0 || n == 1 ){
                S8 msg[MAX_INPUT_STRING_SIZE];

                sprintf( msg, "Cannot process line %llu - 0 and 1 are reserved as new symbols. (pos is %d, sign is %d)", (U64)(nLine), i, n );
                Throw( msg );
            }
        }
        sharpDocumentDollar = VoidSequenceInit2( symbolSize, line->seqStored + 2, 1 );
        VoidSequenceAdd( sharpDocumentDollar, one );
        VoidSequenceAppend( sharpDocumentDollar, line );
        VoidSequenceAdd( sharpDocumentDollar, zero );
        SCDAWGAdd( help, sharpDocumentDollar );
        VoidSequenceFree( sharpDocumentDollar );
    }
    Fclose( fpInput );
    SCDAWGClose( help );
    SCDAWGShrink( aut );
    SCDAWGBuildHelpFree( help );
    if( tarjanTable ){
        SCDAWGAddTarjanTable( aut );
    }
    fpOutput = Fopen( fileNameOutput, "wb" );
    SCDAWGWrite( aut, fpOutput );
    Fclose( fpOutput );
    SCDAWGFree( aut );
}

}}} /* End of namespace lmu::cis::sis */

#endif /* end of include guard: SCDAWGADAPTERADAPTER_CPP */