symbol-layer.h

#include <iostream> 

using std::cin; 
using std::cout;





typedef Symbol Symbol;

typedef SymbolSet SymbolSet;

typedef SymbolIterator SymbolIterator;

typedef SymbolPair SymbolPair;

typedef SymbolPairSet SymbolPairSet;

typedef SymbolPairIterator SymbolPairIterator;

typedef KeyTable KeyTable;







Symbol define_symbol( const char *s );

bool is_symbol( const char *s );

Symbol get_symbol( const char *s );

const char * get_symbol_name( Symbol s ); 

bool is_equal( Symbol s1, Symbol s2 );





SymbolSet *create_empty_symbol_set();

SymbolSet *insert_symbol( Symbol s, SymbolSet *Si );

bool has_symbol( Symbol s, SymbolSet *Si );




SymbolIterator begin_sigma_symbol( SymbolSet *Si );

SymbolIterator end_sigma_symbol( SymbolSet *Si );

size_t size_sigma_symbol( SymbolSet *Si );

Symbol get_sigma_symbol( SymbolIterator Si );




SymbolPair *define_symbolpair( Symbol s1, Symbol s2 );

Symbol get_input_symbol( SymbolPair *s );

Symbol get_output_symbol( SymbolPair *s );




SymbolPairSet *create_empty_symbolpair_set();

SymbolPairSet *insert_symbolpair( SymbolPair *p, SymbolPairSet *Pi );

bool has_symbolpair( SymbolPair *p, SymbolPairSet *Pi );




SymbolPairIterator begin_pi_symbol( SymbolPairSet *Pi );

SymbolPairIterator end_pi_symbol( SymbolPairSet *Pi );

size_t size_pi_symbol( SymbolPairSet *Pi );

SymbolPair *get_pi_symbolpair( SymbolPairIterator pi );






KeyTable *create_key_table();

bool is_key( Key i, KeyTable *T );

bool is_symbol( Symbol s, KeyTable *T );
 void associate_key( Key i, KeyTable *T, Symbol s );

Key get_key( Symbol s, KeyTable *T );

Key get_unused_key( KeyTable * T );

Symbol get_key_symbol( Key i, KeyTable *T );

KeySet *get_key_set( KeyTable *T );

SymbolSet *get_symbol_set( KeyTable *T );


KeyTable *read_symbol_table( istream& is, bool binary=false );   


void write_symbol_table( KeyTable *T, ostream& os, bool binary=false );          

KeyTable * gather_flag_diacritic_table( KeyTable * kt );







TransducerHandle longest_match_tokenizer( KeySet * ks, KeyTable * kt );

TransducerHandle longest_match_tokenizer2( KeyTable * kt );

KeyTable * recode_key_table(KeyTable * kt, const char * epsilon_replacement);

KeyPairVector * tokenize_string_pair(TransducerHandle tokeniser, const
char * upper, const char * lower, KeyTable* inputKeys);

KeyVector *  tokenize_string(TransducerHandle tokeniser, 
                             const char * string, 
                             KeyTable* inputKeys);

KeyVector * longest_match_tokenize(TransducerHandle tokenizer, 
                                   const char * string, 
                                   KeyTable* inputKeys);

KeyPairVector * longest_match_tokenize_pair(TransducerHandle tokenizer, 
                                            const char * string1, 
                                            const char * string2, 
                                            KeyTable* inputKeys);

KeyPairVector * tokenize_pair_string(TransducerHandle tokeniser, char *pairs, KeyTable* inputKeys);
 TransducerHandle
pairstring_to_transducer( const char *str, KeyTable *T );


TransducerHandle read_transducer_text( istream& is, KeyTable *T, bool sfst=false );


bool has_symbol_table(istream &is);


TransducerHandle read_transducer( istream &is, KeyTable *T );

TransducerHandle harmonize_transducer( TransducerHandle t, KeyTable *T_old, KeyTable *T_new );






char * transducer_to_pairstring( TransducerHandle t, KeyTable *T, bool spaces=true, bool print_epsilons=true );

void print_transducer( TransducerHandle t, KeyTable *T, bool print_weights=false, ostream &ostr=std::cout, bool old=false );


void write_transducer( TransducerHandle t, KeyTable *T, ostream &os=std::cout, bool backwards_compatibility=false );


void write_runtime_transducer( TransducerHandle t, KeyTable * kt, FILE * output_file);


/* \brief Write transducer \a t to file filename. Key table \a T is stored with the
 * transducer. 

@see write_transducer */
void write_transducer( TransducerHandle t, const char *filename, KeyTable *T, bool backwards_compatibility=false );


void print_key_table(KeyTable *T);

/* \brief Read a binary transducer from file \a filename and harmonize it
 * according to the key table \a T.

@pre The transducer that is read must have a key table stored with it. */
TransducerHandle read_transducer( const char *filename, KeyTable *T );

// vim: set ft=cpp.doxygen:

---