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

Go to the documentation of this file.

#ifndef COMPRESSEDAUTOMATONADAPTER_HPP
#define COMPRESSEDAUTOMATONADAPTER_HPP

#include "../cppbase.hpp"

#include <cstdio>
#include <iostream>
#include <fstream>
#include <string>

#include "CompressedAutomatonAdapterInterface.hpp"
#include "CompressedAutomatonDumpingInterface.hpp"
#include "CompressedAutomatonSerializing.hpp"
#include "ManagedStageAutomatonInterface.hpp"

extern "C" void DumpSequenceOfLabels( FILE * fp, const VoidSequence * suffix, UINT encoding );
extern "C" void DumpLabel( const CompressedAutomaton * aut, FILE * fp, UINT tr, UINT encoding );
extern "C" void DumpSequenceOfLabels2( FILE * fp, const VoidSequence * suffix, UINT encoding );
extern "C" void DumpSCDAWGLabel( const SCDAWG * aut, FILE * fp, UINT tr, boolean right, UINT encoding );

namespace lmu { namespace cis { namespace sis {

class CompressedAutomatonAdapter
    : public virtual CompressedAutomatonAdapterInterface
    , public virtual CompressedAutomatonDumpingInterface
    , public virtual ManagedStageAutomatonInterface
{

protected:
    UINT                    C_symbolsize;           // in (machine)-word-width
    CompressedAutomaton*    C_CompressedAutomaton;

public:
    CompressedAutomatonAdapter() : CompressedAutomatonAdapter(1) {
        if (DEBUG_LEVEL > 5) std::cerr << "CompressedAutomatonAdapter::CompressedAutomatonAdapter()" << std::endl;
    }

    CompressedAutomatonAdapter(UINT symbolsize)
        : C_symbolsize( symbolsize )
        // , C_CompressedAutomaton( CompressedAutomatonInit(symbolsize) )
        // , ManagedAutomatonStage_(EMPTY)
    {
        C_CompressedAutomaton = CompressedAutomatonInit(symbolsize);
        if (DEBUG_LEVEL > 5) std::cerr << "CompressedAutomatonAdapter::CompressedAutomatonAdapter( UINT symbolSize = " << symbolsize << " )" << std::endl;
    }

    virtual ~CompressedAutomatonAdapter() {
        if (DEBUG_LEVEL > 5) std::cerr << "virtual CompressedAutomatonAdapter::~CompressedAutomatonAdapter()" << std::endl;
        if (DEBUG_LEVEL > 5) std::cerr << " C_symbolsize = " << C_symbolsize << std::endl;
        CompressedAutomatonFree(C_CompressedAutomaton);
    }

protected:
    /* * * * * * * * * * * *  Any-Closed-State Methods   * * * * * * * * * * * */
    virtual void Free();
    virtual PairState GetInitialPairState() const;

public:
    virtual inline UINT get_symbol_size() const { return C_symbolsize; }
    
    /* * * * * * * * * * * *  Pre-Closed Methods   * * * * * * * * * * * */
    virtual void AddState( UINT state );
    virtual void AddTransition( UINT stateFrom, UINT start, UINT stateTo );

    /* * * * * * * * * * * *  Pre-/Post-Closed/Closing Methods   * * * * * * * * * * * */
    // virtual CompressedAutomaton * Read( FILE * fp );
    // virtual CompressedAutomaton * Read( const S8* fn );

    virtual SinkState Add( const VoidSequence * sharpDocumentDollar ) = 0;
    virtual SinkState Add( const VoidSequenceAdapter& sharpDocumentDollar );
    virtual SinkState Add( const S8* documentDollar );
    virtual SinkState Add( const std::string& word );
    virtual void AddDictionary( std::istream& );

    /* * * * * * * * * * * *  Post-Closed Methods   * * * * * * * * * * * */
    virtual void Shrink();

    virtual void Write( FILE * fp ) const;
    virtual void Write( const S8* fn ) const;

    virtual void DumpStat( FILE * fp ) const;
    virtual void DumpStat( const S8* fn ) const;
    virtual void GenerateLanguage( const S8* fn, UINT encoding = ENCODING_PLAIN ) const;
    virtual void LeftAutomatonGenerateLanguage( FILE * fp, void (*DumpSequenceOfLabels)(FILE *, const VoidSequence *, UINT), UINT encoding ) const;
    virtual void AddTarjanTable();
    // virtual void GenerateLanguage( const S8* fn, void (*DumpSequenceOfLabels)(FILE *, const VoidSequence *, UINT), UINT encoding = ENCODING_PLAIN ) const { FILE* fpOut = Fopen(fn, "wb"); CompressedAutomatonGenerateLanguage( C_CompressedAutomaton, fpOut, DumpSequenceOfLabels, encoding );}

public:
    /* * * * * * * * * * * *  Post-Closed Methods   * * * * * * * * * * * */
    virtual PairState Delta( const PairState * state, const void * symbol ) const;
    virtual PairState Delta( const PairState * state, const char symbol ) const;
    virtual PairState Delta( const void * symbol ) const;
    virtual PairState Delta( const S8* pattern ) const;

    virtual void DumpGV( FILE * fp, void (*DumpLabel)(const CompressedAutomaton *, FILE *, UINT, UINT), UINT encoding );

    virtual UINT number_of_states() const;                  
    virtual UINT number_of_transitions() const;             
    virtual UINT number_of_transitions(State s) const;      

    virtual inline std::string data_at(UINT pos) const {
        char * ptr = (S8*)mVoidSequenceElement( automaton()->data, pos );
        return std::string(
            ptr, 1
        );
    }

    virtual inline UINT data_length() const { return automaton()->data->seqStored; }
// protected:
    virtual CompressedAutomaton* automaton() const = 0;
    // virtual UINT suffixLink(const UINT&) const = 0;

private:
    virtual void Print( std::ostream& os) const;
    virtual void ReadAll( std::istream& in);
    virtual void ReadOne( std::istream& in);
};

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

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