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

Go to the documentation of this file.

#ifndef COMPRESSEDAUTOMATONADAPTER_CPP
#define COMPRESSEDAUTOMATONADAPTER_CPP

#include "CompressedAutomatonAdapter.hpp"

namespace lmu { namespace cis { namespace sis {


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CompressedAutomatonAdapter::Free() {
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline void CompressedAutomatonAdapter::Free( )" << std::endl;

    CompressedAutomatonFree( C_CompressedAutomaton );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
PairState CompressedAutomatonAdapter::GetInitialPairState( ) const {
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline PairState CompressedAutomatonAdapter::GetInitialPairState( ) const" << std::endl;
    assert( ManagedAutomatonStage_ > EMPTY );
    return CompressedAutomatonGetInitialPairState( C_CompressedAutomaton );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CompressedAutomatonAdapter::AddState( UINT state ) {
    if (DEBUG_LEVEL > 5) std::cerr << "inline void CompressedAutomatonAdapter::AddState( UINT state )" << std::endl;

    CompressedAutomatonAddState( C_CompressedAutomaton, state );
    ManagedAutomatonStage_ = UNSORTED;

}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CompressedAutomatonAdapter::AddTransition( UINT stateFrom, UINT start, UINT stateTo ) {
    if (DEBUG_LEVEL > 5) std::cerr << "inline void CompressedAutomatonAdapter::AddTransition( UINT stateFrom, UINT start, UINT stateTo )" << std::endl;

    CompressedAutomatonAddTransition( C_CompressedAutomaton, stateFrom, start, stateTo );
    ManagedAutomatonStage_ = UNSORTED;

}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
UINT CompressedAutomatonAdapter::Add( const VoidSequenceAdapter&
                                            sharpDocumentDollar )
{
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline void CompressedAutomatonAdapter::Add( const VoidSequenceAdapter& sharpDocumentDollar )" << std::endl;

    assert( ManagedAutomatonStage_ < CLOSED );

    ManagedAutomatonStage_ = UNSORTED;

    return Add( sharpDocumentDollar.get() );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
UINT CompressedAutomatonAdapter::Add( const char* documentDollar ) {
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline void CompressedAutomatonAdapter::Add( const S8* documentDollar )" << std::endl;

    assert( ManagedAutomatonStage_ < CLOSED );

    ManagedAutomatonStage_ = UNSORTED;

    VoidSequenceAdapter v(C_symbolsize);
    
    v.Add(documentDollar);
    
    return Add( v.get() );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
UINT CompressedAutomatonAdapter::Add( const std::string& word ) {
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline void CompressedAutomatonAdapter::Add( const std::string& word )" << std::endl;

    assert( ManagedAutomatonStage_ < CLOSED );

    ManagedAutomatonStage_ = UNSORTED;

    return Add( word.c_str() );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CompressedAutomatonAdapter::AddDictionary( std::istream& in) {
    assert( ManagedAutomatonStage_ < CLOSED );

    ManagedAutomatonStage_ = UNSORTED;

    while (in.good())
        ReadAll(in); // TODO Clean up: Isn't there an interface by now like in >> automaton?
}

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

    assert( ManagedAutomatonStage_ < CLOSED );

    CompressedAutomatonShrink( C_CompressedAutomaton );

    ManagedAutomatonStage_ = SHRUNK;

}

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

    assert( ManagedAutomatonStage_ == CLOSED );

    CompressedAutomatonWrite( C_CompressedAutomaton, fp );
}

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

    assert( ManagedAutomatonStage_ == CLOSED );

    FILE * fpOut = Fopen(fn, "wb");
    CompressedAutomatonWrite( C_CompressedAutomaton, fpOut );
    Fclose(fpOut);
}

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

    assert( ManagedAutomatonStage_ >= SORTED );

    CompressedAutomatonDumpStat( C_CompressedAutomaton, fp );
}

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

    assert( ManagedAutomatonStage_ >= SORTED );

    FILE * fpOut = Fopen(fn, "wb");
    CompressedAutomatonDumpStat( C_CompressedAutomaton, fpOut);
    Fclose(fpOut);
}

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

    assert( ManagedAutomatonStage_ >= SORTED );

    FILE * fpOut = Fopen(fn, "wb");
    CompressedAutomatonGenerateLanguage( C_CompressedAutomaton, fpOut, DumpSequenceOfLabels, encoding );
    Fclose( fpOut );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CompressedAutomatonAdapter::LeftAutomatonGenerateLanguage( FILE * fp,
                            void (*DumpSequenceOfLabels)(FILE *, const VoidSequence *, UINT),
                            UINT encoding ) const
{
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline void CompressedAutomatonAdapter::LeftAutomatonGenerateLanguage( FILE * fp, void (*DumpSequenceOfLabels)(FILE *, const VoidSequence *, UINT), UINT encoding ) const" << std::endl;

    assert( ManagedAutomatonStage_ >= SORTED );

    CompressedLeftAutomatonGenerateLanguage( C_CompressedAutomaton, fp,
                                             DumpSequenceOfLabels, encoding );
}

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

    assert( ManagedAutomatonStage_ >= SORTED );

    CompressedAutomatonAddTarjanTable( C_CompressedAutomaton );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
PairState CompressedAutomatonAdapter::Delta( const PairState* state, const void* symbol ) const {
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline PairState CompressedAutomatonAdapter::Delta( const PairState * state, const void * symbol ) const" << std::endl;

    assert( ManagedAutomatonStage_ >= SORTED );

    return CompressedAutomatonDelta( C_CompressedAutomaton, state, symbol );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
PairState CompressedAutomatonAdapter::Delta( const PairState * state, const char symbol ) const {
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline PairState CompressedAutomatonAdapter::Delta( const PairState * state, const void * symbol ) const" << std::endl;

    assert( ManagedAutomatonStage_ >= SORTED );

    VoidSequenceAdapter v;      //TODO Cleanup
    v.Add( &symbol );
    return Delta(state, v.get());
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
PairState CompressedAutomatonAdapter::Delta( const void * symbol ) const {
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline PairState CompressedAutomatonAdapter::Delta( const PairState * state, const void * symbol ) const" << std::endl;

    assert( ManagedAutomatonStage_ >= SORTED );

    PairState from = GetInitialPairState();
    if (DEBUG_LEVEL > 5) std::cerr << "States Stored: " << C_CompressedAutomaton->statesTransitions->seqStored << std::endl;
    return Delta( &from, symbol );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
PairState CompressedAutomatonAdapter::Delta( const S8* pattern ) const {
    if (DEBUG_LEVEL > 5) std::cerr << "PairState CompressedAutomatonAdapter::Delta( const S8* pattern ) const" << std::endl;

    assert( ManagedAutomatonStage_ >= SORTED );

    VoidSequenceAdapter v;
    v.Add( pattern );

    return Delta(v.get());
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CompressedAutomatonAdapter::DumpGV( FILE * fp,
                void (*DumpLabel)(const CompressedAutomaton *, FILE *, UINT, UINT),
                UINT encoding )
{
    if (DEBUG_LEVEL > 5) std::cerr << "virtual inline void CompressedAutomatonAdapter::DumpGV( FILE * fp, void (*DumpLabel)(const CompressedAutomaton *, FILE *, UINT, UINT), UINT encoding )" << std::endl;

    assert( ManagedAutomatonStage_ >= SORTED );

    CompressedAutomatonDumpGV( C_CompressedAutomaton, fp, DumpLabel, encoding );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
UINT CompressedAutomatonAdapter::number_of_states() const {
    assert( ManagedAutomatonStage_ > EMPTY );

    return automaton()->statesTransitions->seqStored;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
UINT CompressedAutomatonAdapter::number_of_transitions() const {
    assert( ManagedAutomatonStage_ > EMPTY );

    return automaton()->transitionsStart->seqStored;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
UINT CompressedAutomatonAdapter::number_of_transitions(State s) const {
    assert( ManagedAutomatonStage_ > EMPTY );

    return automaton()->statesNumberOfTransitions->seq[s];
}


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CompressedAutomatonAdapter::Print( std::ostream& os) const {
    os << number_of_transitions(); //TODO! For now, just give ouput. CompressedAutomatonGenerateLanguage() ?
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CompressedAutomatonAdapter::ReadAll( std::istream& in) {
    std::string tmp;
    while(in.good()) {
        in >> tmp;
        Add(tmp);
    }
    ManagedAutomatonStage_ = UNSORTED;

}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void CompressedAutomatonAdapter::ReadOne( std::istream& in) {
    std::string tmp;
    in >> tmp;
    Add(tmp);
    ManagedAutomatonStage_ = UNSORTED;

}

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

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