Namespaces |
| namespace | io |
| namespace | semgraph |
Classes |
| class | regexp |
| class | tree |
| | STL-like container implementing a n-ary tree. More...
|
| class | basic_tree_iterator |
| | ############################################################# /// More...
|
| class | basic_const_tree_iterator |
| | const iterator. More...
|
| class | basic_nonconst_tree_iterator |
| | nonconst iterator. More...
|
| class | basic_preorder_iterator |
| | basic preorder iterator. More...
|
| class | basic_sibling_iterator |
| | basic sibling iterator. More...
|
| class | tree_preorder_iterator |
| | preorder iterator. More...
|
| class | const_tree_preorder_iterator |
| | const tree_preorder iterator. More...
|
| class | tree_sibling_iterator |
| | sibling iterator. More...
|
| class | const_tree_sibling_iterator |
| | const sibling iterator. More...
|
| class | accents |
| | The class accents provides a wrapper to transparently create and access an accents_module to handle accentuation for the appropriate language. More...
|
| class | accents_module |
| | The abstract class accents_module generalizes accentuation rules for different languages. More...
|
| class | accents_default |
| | Derived accents_module for null accentuation (eg english). More...
|
| class | accents_es |
| | Derived accents_module for Spanish accentuation. More...
|
| class | accents_gl |
| | Derived accents_module for Galician accentuation. More...
|
| class | aligner |
| class | alternatives |
| | Class alternatives suggests words that are orthogrphically/phonetically similar to input word. More...
|
| class | analyzer |
| | Class analyzer is a meta class that just calls all modules in FreeLing in the right order. More...
|
| class | automat_status |
| | Class to store status information. More...
|
| class | automat |
| | Abstract class to implement a Finite-State Automaton which is used by modules recognizing multiwords (dates, numbers, quantities, ...). More...
|
| class | bioner |
| | The class bioner implements an AdaBoost-Based NE recognizer. More...
|
| class | edge |
| | Class edge stores all information in a chart edge. More...
|
| class | chart |
| | Class chart contains an array of cells that constitute a chart. More...
|
| class | chart_parser |
| | Class chart_parser implements a chart parser. More...
|
| class | compounds |
| | Class compounds implements a compound checker. More...
|
| class | config_file |
| | Class to handle loading a config file for freeling module, with XML-like sections. More...
|
| class | condition |
| | Class condition implements a condition of a CG rule. More...
|
| class | ruleCG |
| | Class rule implements a rule of a CG. More...
|
| class | setCG |
| | auxiliary class to store sets defined in the CG More...
|
| class | constraint_grammar |
| | Class constraint_grammar implements a pseudo CG, ready to be used from a relax PoS tagger. More...
|
| class | coref |
| | The class coref implements a ML-based coreference classificator. More...
|
| class | mention_ab |
| class | coref_fex |
| | Class for the feature extractor. More...
|
| class | csr_kb |
| | class kb: Store information associated to a knowledge base More...
|
| class | database |
| | Class to wrap a berkeley DB database and unify access. More...
|
| class | dates |
| | The class dates provides a wrapper to transparently create and access a dates_module, a temporal expression recognizer for the appropriate language. More...
|
| class | dates_status |
| | Class to store status information. More...
|
| class | dates_module |
| | The abstract class dates_module generalizes temporal expression recognizer for different languages. More...
|
| class | dates_default |
| | The derived class dates_default implements a default date/time recognizer (only simple patterns are recognized). More...
|
| class | dates_es |
| | The derived class dates_es implements a Spanish date/time recognizer. More...
|
| class | dates_ca |
| | The derived class dates_ca implements a Catalan date/time recognizer. More...
|
| class | dates_gl |
| | The derived class dates_gl implements a Galician date/time recognizer. More...
|
| class | dates_pt |
| | The derived class dates_pt implements a Portuguese date/time recognizer. More...
|
| class | dates_en |
| | The derived class dates_en implements an English date/time recognizer. More...
|
| class | dates_ru |
| | The derived class dates_ru implements Russian date/time recognizer. More...
|
| class | dates_fr |
| class | dates_de |
| class | dates_cy |
| class | matching_attrib |
| | The class matching attrib stores attributes for maching condition. More...
|
| class | matching_condition |
| | The class matching condition stores a condition used in a MATCHING operation of a completer rule. More...
|
| class | completer_rule |
| | The class completer_rule stores rules used by the completer of parse trees. More...
|
| class | rule_expression |
| | The class rule_expression stores the conditions for a labeler_rule. More...
|
| class | labeler_rule |
| | labeler_rule is an auxiliary class for the depLabeler More...
|
| class | dep_treeler |
| | Class dep_treeler is a wrapper for a Treeler dependency parser. More...
|
| class | dep_txala_status |
| | Store parsing status information. More...
|
| class | dep_txala |
| | dep_txala is a class for obtaining a dependency tree from chunks. More...
|
| class | dependency_parser |
| | The class dependency_parser is just an abstract class generalizing any dependency parser. More...
|
| class | dictionary |
| | The class dictionary implements dictionary search and suffix analysis for word forms. More...
|
| class | ent_extract |
| class | factory |
| | This template is used by numbers, quantities, dates, and ner classes to dinamycally create the appropriate subclass of numbers_module, quantities_module, dates_module, or ner_module (according to received options). More...
|
| class | fex |
| | Class fex implements a feature extractor. More...
|
| class | lex_entry |
| | Content of one lexicon entry. More...
|
| class | fex_lexicon |
| | Feature lexicon. More...
|
| class | fex_status |
| | Store status about extracted features. More...
|
| class | fex_condition |
| | Class fex_condition stores a condition to be checked on the target. More...
|
| class | feature_function |
| | Class feature_function is an abstrac class to enable calling module to define user-custom feature functions. More...
|
| class | fex_rule |
| | Class fex_rule stores a feature extraction rule. More...
|
| class | fex_rulepack |
| | Class fex_rulepack stores a batch of feature rules to be applied to the same kind of targets. More...
|
| class | foma_FSM |
| | Class foma_FSM is a wrapper for the FOMA library, for the specific use of getting entries from a dictionary with minimum edit distance to given key. More...
|
| class | rule |
| | Class rule implements a rule of a grammar. More...
|
| class | grammar |
| | Class grammar implements a CFG, ready to be used from a chart parser. More...
|
| class | trellis |
| class | emission_states |
| | The class emission_states stores the list of states in the HMM that *may* be generating a given word given the two previous words (and their valid tags). More...
|
| class | hmm_tagger |
| | The class hmm_tagger implements the syntactic analyzer and is the main class, which uses all the others. More...
|
| class | idioma |
| | Class "idioma" implements a visible Markov's model that calculates the probability that a text is in a certain language. More...
|
| class | lang_ident |
| | Class "lang_ident" checks a text against all known languages and sorts the results by probability. More...
|
| class | analysis |
| | Class analysis stores a possible reading (lemma, PoS, probability, distance) for a word. More...
|
| class | word |
| | Class word stores all info related to a word: form, list of analysis, list of tokens (if multiword). More...
|
| class | node |
| | Class node stores nodes of a parse_tree Each node in the tree is either a label (intermediate node) or a word (leaf node) More...
|
| class | parse_tree |
| | Class parse tree is used to store the results of parsing. More...
|
| class | depnode |
| | class denode stores nodes of a dependency tree and parse tree <-> deptree relations More...
|
| class | dep_tree |
| | class dep_tree stores a dependency tree More...
|
| class | processor_status |
| | Virtual class to store the processing state of a sentence. More...
|
| class | argument |
| | Class argument stores information about a predicate argument. More...
|
| class | predicate |
| | Class predicate stores a predicate and its arguments. More...
|
| class | sentence |
| | Class sentence is just a list of words that someone (the splitter) has validated it as a complete sentence. More...
|
| class | paragraph |
| | Class paragraph is just a list of sentences that someone has validated it as a paragraph. More...
|
| class | mention |
| | Class mention is a node in the parse tree, as well as the sequence of tokens subsumed by the node. More...
|
| class | document |
| | Class document is a list of paragraphs. More...
|
| class | lexer |
| | Simple RegEx lexer to parse UTF8 grammar files without depending on flex (or the like) More...
|
| class | lexical_chain |
| | Class lexical_chain represents a lexical chain and computes words and stores (or not) them into the structures. More...
|
| class | locutions_status |
| | Class to store status information. More...
|
| class | locutions |
| | Class locutions recognizes multiwords belonging to a list obtained from a configuration file. More...
|
| class | maco |
| | Class maco implements the morphological analyzer, which uses all the specific analyzers: dates, numbers, dictionary, etc. More...
|
| class | maco_options |
| | Class maco_options implements a set of specific options of the morphological analyzer. More...
|
| class | mention_detector |
| | The class mention_detector implements a rule-based entity mention detector. More...
|
| class | nec |
| | The class nec implements a ML-based NE classificator. More...
|
| class | ner |
| | Class ner implements a wrapper to transparently create and access a ner_module named entity recognizer. More...
|
| class | ner_status |
| | Class to store status information. More...
|
| class | ner_module |
| | The class ner is an abstract class that implements a general NE Recognizer. More...
|
| class | nerc_features |
| | available NERC-specific feature extraction functions. More...
|
| class | np |
| | The class np implements a simple proper noun recognizer. More...
|
| class | numbers |
| | Class numbers implements a wrapper to transparently create and access a numbers_module number recognizer for the appropriate language. More...
|
| class | numbers_status |
| | Class to store status information. More...
|
| class | numbers_module |
| | The abstract class numbers_module generalizes nummeric expression recognizer for different languages. More...
|
| class | numbers_default |
| | The derived class numbers_default implements a default number recognizer (only numbers in digits are recognized). More...
|
| class | numbers_es |
| | The derived class numbers_es implements a Spanish number recognizer. More...
|
| class | numbers_ca |
| | The derived class numbers_ca implements a Catalan number recognizer. More...
|
| class | numbers_gl |
| | The derived class numbers_gl implements a Galician number recognizer. More...
|
| class | numbers_pt |
| | The derived class numbers_pt implements a Portuguese number recognizer. More...
|
| class | numbers_it |
| | The derived class numbers_it implements a Italian number recognizer. More...
|
| class | numbers_en |
| | The derived class numbers_en implements an English number recognizer. More...
|
| class | numbers_ru |
| | The derived class numbers_ru implements an Russian number recognizer. More...
|
| class | numbers_cs |
| | The derived class numbers_cs implements a Czeck number recognizer. More...
|
| class | numbers_de |
| class | phd |
| class | ph_rule |
| | Auxiliar class to store a phonetic change rule. More...
|
| class | rule_set |
| class | phonetics |
| | This class is a will calculate the phonetic translation of a word. More...
|
| class | List |
| class | PrefTree |
| class | probabilities |
| | Class probabilities sets lexical probabilities for each PoS tag of each word in a sentence. More...
|
| class | processor |
| | Abstract class to define the common API of any FreeLing processing module. More...
|
| class | punts |
| | Class numbers implements a punctuation sign recognizer. More...
|
| class | quantities |
| | Class quantities implements a wrapper to transparently create and access a quantities_module monetary expressions detector for the appropriate language. More...
|
| class | quantities_status |
| | Class to store status information. More...
|
| class | quantities_module |
| | The abstract class quantities_module generalizes a percentage, ratios, and currency expression recognizer for different languages. More...
|
| class | quantities_default |
| | The derived class quantities_default implements a default quantities recognizer (only percentages are recognized). More...
|
| class | quantities_es |
| | The derived class quantities_es implements a Spanish quantities recognizer. More...
|
| class | quantities_ca |
| | The derived class quantities_ca implements a Catalan quantities recognizer. More...
|
| class | quantities_gl |
| | The derived class quantities_gl implements a Galician quantities recognizer. More...
|
| class | quantities_pt |
| | The derived class quantities_pt implements a Portuguese quantities recognizer. More...
|
| class | quantities_en |
| | The derived class quantities_en implements an English quantities recognizer. More...
|
| class | quantities_ru |
| | The derived class quantities_ru implements a Russian quantities recognizer. More...
|
| class | RE_map_rule |
| | Auxiliary class to store a single RE_map rule. More...
|
| class | RE_map |
| | Class tag_map implements a mapping from a regexps to an associated data string. More...
|
| class | rel_extract |
| class | node_pattern |
| | Auxiliary class to store relation extraction rules. More...
|
| class | rx_rule |
| | Auxiliary class to store relation extraction rules. More...
|
| class | rel_extract_SPR |
| class | rel_extract_SRL |
| struct | word_pos |
| | Struct that allow us to compare words easily. More...
|
| struct | related_words |
| | Struct that represents a relationship between two words. More...
|
| class | relation |
| | Class relation is a non-instantiable class which defines many virtual methods to check if a word is compatible with the relation or if a word can be stored in the structures of a lexical chain. More...
|
| class | same_word |
| | Class same_word represents the same word relation: two words are related if they are the same word. More...
|
| class | hypernymy |
| | Class hypernymy represents the hypernymy relation: two words are related if one is an hypernymy of the other and the hypernymy depth is smaller or equal than a given maximum. More...
|
| class | same_coref_group |
| | Class same_coref_group represents the same coreference group relation: two words are related if they are in the same coreference group. More...
|
| class | constraint |
| | The class constraint implements a constraint for the relaxation labelling algorithm. More...
|
| class | label |
| | The class label stores all information related to a variable label in the relaxation labelling algorithm. More...
|
| class | problem |
| | The class problem stores the structure of a problem, namely, a vector with a position for each variable to consider, and for each variable, a list of initial weights for each possible label. More...
|
| class | relax |
| | The class relax implements a generic solver for consistent labelling problems, using relaxation labelling algorithm. More...
|
| class | relax_tagger |
| | The class relax_tagger implements a PoS tagger based on relaxation labelling algorithm. More...
|
| class | relaxcor |
| | The class mention_detector implements a rule-based entity mention detector. More...
|
| class | relaxcor_fex |
| | Class for the feature extractor. More...
|
| class | relaxcor_model |
| | The basic class relaxcor_model implements the mention-pair model. More...
|
| class | relaxcor_modelDT |
| | The basic class relaxcor_modelDT implements the mention-pair model based on constraints derived from DTs. More...
|
| class | sense_info |
| | Class sense_info stores several semantic info about a sense. More...
|
| class | posmaprule |
| | Auxiliary class to map FL postags to WN codes. More...
|
| class | semanticDB |
| | Class semanticDB implements a semantic DB interface. More...
|
| class | semgraph_extract |
| class | senses |
| | Class senses implements a sense annotator. More...
|
| class | similarity |
| | This class calculates the similarity between two words. More...
|
| class | smoothingLD |
| | Class smoothingLD computes linear-discount smoothed conditional probabilities P(z|w1...wn) for n-gram transitions. More...
|
| class | splitter |
| | Class splitter implements a sentence splitter, which accumulates lists of words until a sentence is completed, and then returns a list of sentence objects. More...
|
| class | affixes |
| | Class suffixes implements suffixation rules and dictionary search for suffixed word forms. More...
|
| class | sufrule |
| | Class sufrule contains an affixation rule, and is used by class suffixes. More...
|
| class | summarizer |
| | summarizer class summarizes a document using the lexical chains method. More...
|
| class | POS_tagger |
| | The class POS_tagger is just an abstract class generalizing a PoS tagger. More...
|
| class | tagset |
| | The class tagset handles PoS tags long to short conversion and morphosintactic feature decomposition. More...
|
| class | tokenizer |
| | Class tokenizer implements a token splitter, which converts a string into a sequence of word objects, according to a set of tokenization rules read from aconfiguration file. More...
|
| class | traces |
| | Class traces implements trace and error handling utilities. More...
|
| class | ukb |
| class | util |
| | Class util implements some utilities for NLP analyzers: "tolower" for latin alfabets, tags manipulation, wstring2number and viceversa conversions, etc. More...
|
| class | adaboost |
| | Class AdaBoost implement a generic AB learner/classifier, which may be based on any kind of weak rule. More...
|
| class | classifier |
| | The class classifier is an abstract class that implements a general ML classifier. More...
|
| class | dataset |
| | Class dataset stores a set of examples uset to train adaboost models. More...
|
| class | category |
| | Class category is an auxiliar class to store information about the example belonging to a category. More...
|
| class | example |
| | Class example is a vector of real-valued features, each identified by an integer label, plus info about to which classes the example belongs to, and with prediction storage functionalities. More...
|
| class | svm |
| | Class svm implements a bianry SVM classifier. More...
|
| class | vis_viterbi |
| | The class vis_viterbi implements the viterbi algorithm given the weights of different labels, without hidden information. More...
|
| class | wr_params |
| | Class wr_params is a dummy class used to derive the set of parameters of each WR type. More...
|
| class | weak_rule |
| | Class weak_rule is an abstract class generalizing any kind of weak rule that adaboost can use. More...
|
| class | wr_factory |
| | Class wr_factory is a factory enabling to register new types of weak_rules (provided they are derived from weak_rule class below. More...
|
| class | mlDTree_params |
| | Class mlDTree_params stores the set of params for this kind of weak rules. More...
|
| class | dt_node |
| | Class dt_node stores the info in one node of the decision tree. More...
|
| class | mlDTree |
| | Class mlDTree implements a multilabel decision tree that can be used by adaboost as a weak rules. More...
|
Typedefs |
| typedef std::list< edge > | cell |
| | Class cell stores all information in a chart cell.
|
typedef std::pair
< std::wstring, std::wstring > | bigram |
| | The class viterbi stores the two maps for each observation: The delta map stores the maximum probability for each state in that observation, the phi map stores the backpath to maximize the probability.
|
Enumerations |
| enum | AnalysisLevel {
TEXT,
IDENT,
TOKEN,
SPLITTED,
MORFO,
TAGGED,
SENSES,
SHALLOW,
PARSED,
DEP,
COREF,
SEMGRAPH
} |
| enum | TaggerAlgorithm { NO_TAGGER,
HMM,
RELAX
} |
| enum | DependencyParser { NO_DEP,
TXALA,
TREELER
} |
| enum | WSDAlgorithm { NO_WSD,
ALL,
MFS,
UKB
} |
| enum | ForceSelectStrategy { NO_FORCE,
TAGGER,
RETOK
} |
Functions |
| bool | compare_alternatives (const pair< wstring, pair< int, int > > &p1, const pair< wstring, pair< int, int > > &p2) |
| wstring | print_sigma (struct sigma *sigma) |
| template<class T > |
| auto | subsuming_node (T &t, size_t i, size_t j)-> decltype(t.begin()) |
| | get lowest parse tree node that subsumes the *whole* word span i..j
|
| template<class T > |
| auto | left_subsuming_node (T &t, size_t i, size_t j)-> decltype(t.begin()) |
| | get highest parse tree node that subsumes longest word span i..k, such that k<=j
|
| template<class T > |
| auto | right_subsuming_node (T &t, size_t i, size_t j)-> decltype(t.begin()) |
| | get highest parse tree node that subsumes longest word span k..j, such that i<=k
|
Variables |
| const std::wstring | TAG_DIVIDER = "|" |
| | compact data in format lema1 pos1a|pos1b|pos1c lema2 pos2a|posb to save memory
|
| const std::wstring | LEMMA_DIVIDER = " " |
| const std::wstring | UNOBS_INITIAL_STATE = "0.x" |
| const std::wstring | UNOBS_WORD = "<UNOBSERVED_WORD>" |
| locale | current_locale |
| const std::wstring | RE_ROMAN = "^([IVXLCDM]+)$" |
| const std::wstring | RE_DATE_DF = "^(?:(?:((?:[0-3])?(?:\\d))/)(?:((?:(?:[0-1])?(?:\\d)))/)(\\d{1,4}))$" |
| const std::wstring | RE_TIME1_DF = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:h|:)(?:((?:[0-5])?(?:\\d))(?:min|m)?)?)$" |
| const std::wstring | RE_TIME2_DF = "^(?:((?:[0-5])?(?:\\d))(?:min\\.?|m\\.?))$" |
| const std::wstring | RE_DATE_ES = "^(?:(?:((?:[0-3])?(?:\\d))/)(?:((?:(?:[0-1])?(?:\\d))|enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene|feb|mar|abr|may|jun|jul|ago|sep|oct|nov|dic)/)(\\d{1,4}))$" |
| const std::wstring | RE_TIME1_ES = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:h|:)(?:((?:[0-5])?(?:\\d))(?:minutos|min|m)?)?)$" |
| const std::wstring | RE_TIME2_ES = "^(?:((?:[0-5])?(?:\\d))(?:minutos|min\\.?|m\\.?))$" |
| const std::wstring | RE_DATE_CA = "^(?:(?:((?:[0-3])?(?:\\d))/)(?:((?:(?:[0-1])?(?:\\d))|gener|febrer|març|abril|maig|juny|juliol|agost|setembre|octubre|novembre|desembre|gen|feb|mar|abr|mai|jun|jul|ago|set|oct|nov|des)/)(\\d{1,4}))$" |
| const std::wstring | RE_TIME1_CA = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:h|:)(?:((?:[0-5])?(?:\\d))(?:minuts|min|m)?)?)$" |
| const std::wstring | RE_TIME2_CA = "^(?:((?:[0-5])?(?:\\d))(?:minuts|min\\.?|m\\.?))$" |
| const std::wstring | RE_DATE_EN = "^(?:(?:((?:[0-3])?(?:\\d))/)(?:((?:(?:[0-1])?(?:\\d))|january|february|march|april|may|june|july|august|september|october|november|december|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/)(\\d{1,4}))$" |
| const std::wstring | RE_TIME1_EN = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:h|:)(?:((?:[0-5])?(?:\\d))(?:minutes|min|m)?)?)$" |
| const std::wstring | RE_TIME2_EN = "^(?:((?:[0-5])?(?:\\d))(?:minutes|min\\.?|m\\.?))$" |
| const std::wstring | RE_DATE_GL = "^(?:(?:((?:[0-3])?(?:\\d))/)(?:((?:(?:[0-1])?(?:\\d))|xaneiro|febreiro|marzo|abril|maio|xuño|xullo|agosto|setembro|outubro|novembro|decembro|xan|feb|mar|abr|mai|xuñ|xul|ago|set|out|nov|dec)/)(\\d{1,4}))$" |
| const std::wstring | RE_TIME1_GL = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:h|:)(?:((?:[0-5])?(?:\\d))(?:minutos|min|m)?)?)$" |
| const std::wstring | RE_TIME2_GL = "^(?:((?:[0-5])?(?:\\d))(?:minutos|min\\.?|m\\.?))$" |
| const std::wstring | RE_DATE_PT = "^(?:(?:((?:[0-3])?(?:\\d))/)(?:((?:(?:[0-1])?(?:\\d))|janeiro|fevereiro|março|abril|maio|junho|julho|agosto|setembro|outubro|novembro|dezembro|jan|fev|mar|abr|mai|jun|jul|ago|set|out|nov|dez)/)(\\d{1,4}))$" |
| const std::wstring | RE_TIME1_PT = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:h|:)(?:((?:[0-5])?(?:\\d))(?:minutos|min|m)?)?)$" |
| const std::wstring | RE_TIME2_PT = "^(?:((?:[0-5])?(?:\\d))(?:minutos|min\\.?|m\\.?))$" |
| const std::wstring | RE_DATE_RU = "^([0]?[1-9]|[1|2][0-9]|[3][0|1])[./]([0]?[1-9]|[1][0-2])[./]([0-9]{4}|[0-9]{2})$" |
| const std::wstring | RE_TIME_RU = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:ч\\.?|:)(?:((?:[0-5])?(?:\\d))(?:минуты?|мин\\.?)?)?)$" |
| const std::wstring | RE_MINUTES_RU = "^(?:((?:[0-5])?(?:\\d))(?:минуты?|мин\\.?))$" |
| const std::wstring | RE_DATE_FR = "^(?:(?:((?:[0-3])?(?:\\d))/)(?:((?:(?:[0-1])?(?:\\d))|janvier|février|fevrier|mars|avril|mai|juin|juillet|aout|août|septembre|octobre|novembre|décembre|decembre|fév|fev|mar|avr|juil|aou|sep|oct|nov|déc|dec)/)(\\d{1,4}))$" |
| const std::wstring | RE_TIME1_FR = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:h|:)(?:((?:[0-5])?(?:\\d))(?:minutos|min|m)?)?)$" |
| const std::wstring | RE_TIME2_FR = "^(?:((?:[0-5])?(?:\\d))(?:minutes|min\\.?|m\\.?))$" |
| const std::wstring | RE_DATE_CY = "^(?:(?:((?:[0-3])?(?:\\d))/)(?:((?:(?:[0-1])?(?:\\d))|ionawr|chwefror|[mf]awrth|ebrill|[fm]ai|[fm]ehefin|n?gorffennaf|orffennaf|awst|[mf]edi|hydref|th?achwedd|dachwedd|nhachwedd|dd?u|ion|chwe|maw|ebr|meh|gorff|hyd|tach)/)(\\d{1,4}))$" |
| const std::wstring | RE_TIME1_CY = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:h|:)(?:((?:[0-5])?(?:\\d))(?:munud|min|m)?)?)$" |
| const std::wstring | RE_TIME2_CY = "^(?:((?:[0-5])?(?:\\d))(?:munud|mun\\.?|m\\.?))$" |
| const std::wstring | RE_DATE_DE = "^(?:(?:((?:[0-3])?(?:\\d))[/\\.] ?)(?:((?:(?:[0-1])?(?:\\d))|[Jj]anuar|[Ff]ebruar|[Mm]ärz|[Aa]pril|[Mm]ai|[jJ]uni|[jJ]uli|[aA]ugust|[Ss]eptember|[oO]ktober|[nN]ovember|[Dd]ezember|jan|feb|märz|apr|mai|jun|jul|aug|sep|okt|nov|dez)[/\\.] ?)(\\d{1,4}))$" |
| const std::wstring | RE_TIME1_DE = "^(?:((?:(?:[0-1])?(?:\\d))|(?:2(?:[0-4])))(?:h|:)(?:((?:[0-5])?(?:\\d))(?:minuten|min|m)?)?)$" |
| const std::wstring | RE_TIME2_DE = "^(?:((?:[0-5])?(?:\\d))(?:minuten|min\\.?|m\\.?))$" |
| const std::wstring | UNKNOWN_SYMB = "??" |
| const std::wstring | RE_NA = "^(NC|AQ)" |
| const std::wstring | RE_DNP = "^[FWZ]" |
| const std::wstring | RE_CLO = "^[DSC]" |
| const std::wstring | RE_FZ = "^[FZ]" |
| const std::wstring | RE_CONTARG = "_none_" |
| const std::wstring | USER_RE = "^u\\.([0-9]+)=(.+)$" |
| const std::wstring | RE_WNP = "^[NARV]" |
