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

Go to the documentation of this file.

#ifndef SCDAWGADAPTER_HPP
#define SCDAWGADAPTER_HPP

#include "../cppbase.hpp"

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

#include "CompressedAutomatonAdapter.hpp"
#include "SerializingAutomaton.hpp"
#include "VoidSequenceAdapter.hpp"



namespace lmu { namespace cis { namespace sis {

class SCDAWGAdapterInterface {
    virtual bool delta_left() = 0;
    virtual bool delta_right() = 0;
};




class SCDAWGAdapter
    : public virtual CompressedAutomatonAdapter
    , public virtual CompressedAutomatonDumpingInterface
    , public SerializingAutomaton<SCDAWG>
    // , public virtual SCDAWGAdapterInterface
{
protected:
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * *  Members  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    SCDAWG*                     C_SCDAWG;               
    SCDAWGBuildHelp*            C_SCDAWGBuildHelp;      


public:


    /* unfortunately constructor delegation is not supported by gcc just yet */
    // using CompressedAutomatonAdapter::CompressedAutomatonAdapter;


    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * *  Constructors   * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

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

    SCDAWGAdapter(UINT symbolsize)
        : C_SCDAWG( SCDAWGInit(symbolsize) )
        , C_SCDAWGBuildHelp( SCDAWGBuildHelpInit( this->C_SCDAWG ) )
        // , : CompressedAutomatonAdapter( symbolsize )
        {
            if (DEBUG_LEVEL >= 5) std::cerr << "SCDAWGAdapter::SCDAWGAdapter( UINT symbolSize = " << symbolsize << " )" << std::endl;
    }

    virtual inline UINT get_symbol_size() const { return automaton()->data->elementSize; }

    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * *  Destructors  * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    virtual ~SCDAWGAdapter() {
        if (DEBUG_LEVEL >= 5) std::cerr << "virtual SCDAWGAdapter::~SCDAWGAdapter()" << std::endl;
        SCDAWGBuildHelpFree(C_SCDAWGBuildHelp);
        // TODO!
        // if( tarjanTable ){
        //     SCDAWGAddTarjanTable( aut );
        // }
        SCDAWGFree(C_SCDAWG);
    }


    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * *  Copy-Constructors  * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    SCDAWGAdapter( const SCDAWGAdapter& other ) = delete;               
    SCDAWGAdapter& operator=( const SCDAWGAdapter& other ) = delete;    



    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * *  Methods  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    virtual SinkState Add( const VoidSequence * sharpDocumentDollar ) override;



    virtual SCDAWG * Read( FILE * fp );
    virtual SCDAWG * Read( const S8* fn );  



    virtual void Close();



    virtual void Shrink();



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



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



    virtual void DumpGV( const S8 * fn, UINT encoding = ENCODING_PLAIN ) const;
    


    void dumpGV(const S8 * fn, UINT encoding) const;
    



    void DumpGVRight( const S8 * fn, UINT encoding = ENCODING_PLAIN ) const;



    virtual void AddTarjanTable();



    virtual void GenerateLanguage( const S8* fnOut, UINT encoding = ENCODING_PLAIN ) const;



    virtual void SortTransitions();

    // virtual void GenerateLanguage(FILE*, void (*)(FILE*, const VoidSequence*, UINT), UINT) const {




    void BuildSCDAWG( const S8 * fnIn, const S8 * fnOutOutput, UINT bitsPerSymbol = 8, UINT enc = ENCODING_PLAIN, boolean tarjanTable = NO );



protected:
    virtual UINT suffixLink( const UINT& state ) const;



    virtual CompressedAutomaton* automaton() const;



    virtual CompressedAutomaton* left_automaton() const;



    virtual PairState GetInitialPairState() const override;



    virtual SCDAWGBuildHelp* buildhelp() const;



    virtual PairState Delta( const PairState * state, const void * symbol ) const override;



    virtual inline CompressedAutomaton* mRight() { return C_SCDAWGBuildHelp->aut->right; }



    virtual inline CompressedAutomaton* mLeft() { return C_SCDAWGBuildHelp->aut->left; }



    virtual inline SCDAWGBuildHelp* help() { return C_SCDAWGBuildHelp; }



    virtual UINT FindRightState( UINT l );




    public: virtual inline UINT printsymbolsize() const { return automaton()->data->elementSize; }

}; /* End of class SCDAWGAdapter */

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

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