diff --git a/alib2algo/src/regexp/convert/ToAutomaton.h b/alib2algo/src/regexp/convert/ToAutomaton.h
index 8de21c97231864dc8629cad35ad6ee80323825af..81fc6903b70211f3ed217602d8df76a30007f9e9 100644
--- a/alib2algo/src/regexp/convert/ToAutomaton.h
+++ b/alib2algo/src/regexp/convert/ToAutomaton.h
@@ -33,7 +33,7 @@ public:
*
* \param regexp the regular expression
*
- * \return finite automaotn equivalent to original regular expression.
+ * \return finite automaotn equivalent to original regular expression
*/
template < class SymbolType >
static automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > convert ( const regexp::FormalRegExp < SymbolType > & regexp );
@@ -45,7 +45,7 @@ public:
*
* \param regexp the regular expression
*
- * \return finite automaotn equivalent to original regular expression.
+ * \return finite automaotn equivalent to original regular expression
*/
template < class SymbolType >
static automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > convert ( const regexp::UnboundedRegExp < SymbolType > & regexp );
diff --git a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
index 7feb5ae6dbad1f4ab24a9334d2fafb4f90822719..774a2b6b16ef3a7f87c5b56bc6f1b3feb3d59a2e 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
@@ -12,8 +12,17 @@ namespace regexp {
namespace convert {
-auto ToAutomatonDerivationFormalRegExp = registration::AbstractRegister < ToAutomatonDerivation, automaton::DFA < DefaultSymbolType, unsigned >, const regexp::FormalRegExp < > & > ( ToAutomatonDerivation::convert );
-auto ToAutomatonDerivationUnboundedRegExp = registration::AbstractRegister < ToAutomatonDerivation, automaton::DFA < DefaultSymbolType, unsigned >, const regexp::UnboundedRegExp < > & > ( ToAutomatonDerivation::convert );
+auto ToAutomatonDerivationFormalRegExp = registration::AbstractRegister < ToAutomatonDerivation, automaton::DFA < DefaultSymbolType, unsigned >, const regexp::FormalRegExp < > & > ( ToAutomatonDerivation::convert ).setDocumentation (
+"Implements conversion of regular expressions to finite automata usign Brzozowski's derivation algorithm.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return finite automaton accepting the language described by the original regular expression" );
+
+auto ToAutomatonDerivationUnboundedRegExp = registration::AbstractRegister < ToAutomatonDerivation, automaton::DFA < DefaultSymbolType, unsigned >, const regexp::UnboundedRegExp < > & > ( ToAutomatonDerivation::convert, "regexp" ).setDocumentation (
+"Implements conversion of regular expressions to finite automata usign Brzozowski's derivation algorithm.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return finite automaton accepting the language described by the original regular expression" );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToAutomatonDerivation.h b/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
index b0b53a9c3d5694413de2d2a4b3b5b67ef3d39238..191f4652301a732c1d51522cfcfc253724772d54 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
@@ -34,8 +34,14 @@ namespace convert {
class ToAutomatonDerivation {
public:
/**
- * Performs conversion.
- * @return FSM equivalent to original regular expression.
+ * Implements conversion of regular expressions to finite automata usign Brzozowski's derivation algorithm.
+ *
+ * \tparam T the type of regular expression to convert
+ * \tparam SymbolType the type of symbols in the regular expression
+ *
+ * \param regexp the regexp to convert
+ *
+ * \return finite automaton accepting the language described by the original regular expression
*/
template < class T, class SymbolType = typename T::symbol_type >
static automaton::DFA < SymbolType, unsigned > convert ( const T & regexp );
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
index 8e8b4d6b2838531d7e161e4c051179240b2e876a..5ec6b8a8d14dbef0b26e7dc4aa92f52d79f0d087 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
@@ -12,8 +12,17 @@ namespace regexp {
namespace convert {
-auto ToAutomatonGlushkovUnboundedRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::UnboundedRegExp < > & > ( ToAutomatonGlushkov::convert );
-auto ToAutomatonGlushkovFormalRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::FormalRegExp < > & > ( ToAutomatonGlushkov::convert );
+auto ToAutomatonGlushkovUnboundedRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::UnboundedRegExp < > & > ( ToAutomatonGlushkov::convert, "regexp" ).setDocumentation (
+"Implements conversion of regular expressions to finite automata usign Glushkov's method of neighbours.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return finite automaton accepting the language described by the original regular expression" );
+
+auto ToAutomatonGlushkovFormalRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::FormalRegExp < > & > ( ToAutomatonGlushkov::convert, "regexp" ).setDocumentation (
+"Implements conversion of regular expressions to finite automata usign Glushkov's method of neighbours.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return finite automaton accepting the language described by the original regular expression" );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
index a7444ba28a912eab0831d473731de994c6d1c5a3..fb68149322938374db576cbcaa6d976ed0d07f4e 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
@@ -38,9 +38,13 @@ namespace convert {
class ToAutomatonGlushkov {
public:
/**
- * Performs conversion.
- * @param re Original regular expression.
- * @return NFA equivalent to original regular expression.
+ * Implements conversion of regular expressions to finite automata usign Glushkov's method of neighbours.
+ *
+ * \tparam SymbolType the type of symbols in the regular expression
+ *
+ * \param regexp the regexp to convert
+ *
+ * \return finite automaton accepting the language described by the original regular expression
*/
template < class SymbolType >
static automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > convert ( const regexp::UnboundedRegExp < SymbolType > & regexp );
diff --git a/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
index d9b50f26dcdc8f5779a10f4b29cba146c7ddf336..63663685d53d1d77e6a9b5b10b3370d192e07e8b 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
@@ -51,8 +51,17 @@ automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::UnboundedRe
return automaton;
}
-auto ToAutomatonThompsonFormalRegExp = registration::AbstractRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, const regexp::FormalRegExp < > & > ( ToAutomatonThompson::convert );
-auto ToAutomatonThompsonUnboundedRegExp = registration::AbstractRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, const regexp::UnboundedRegExp < > & > ( ToAutomatonThompson::convert );
+auto ToAutomatonThompsonFormalRegExp = registration::AbstractRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, const regexp::FormalRegExp < > & > ( ToAutomatonThompson::convert, "regexp" ).setDocumentation (
+"Implements conversion of regular expressions to finite automata usign Thompson's method of incremental construction.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return finite automaton accepting the language described by the original regular expression" );
+
+auto ToAutomatonThompsonUnboundedRegExp = registration::AbstractRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, const regexp::UnboundedRegExp < > & > ( ToAutomatonThompson::convert, "regexp" ).setDocumentation (
+"Implements conversion of regular expressions to finite automata usign Thompson's method of incremental construction.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return finite automaton accepting the language described by the original regular expression" );
// ----------------------------------------------------------------------------
diff --git a/alib2algo/src/regexp/convert/ToAutomatonThompson.h b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
index c6973cd0c42a49bb8671a2fb3c08fb6ad7862d96..25acbfd7e4964934912088acb135fbb65c77c920 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonThompson.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
@@ -29,11 +29,19 @@ namespace convert {
class ToAutomatonThompson {
public:
/**
- * Performs conversion.
- * @param regexp regexp to convert
- * @return nondeterministic finite automaton with epsilon transitions accepting language described by the regexp
+ * Implements conversion of regular expressions to finite automata usign Thompson's method of incremental construction.
+ *
+ * \tparam SymbolType the type of symbols in the regular expression
+ *
+ * \param regexp the regexp to convert
+ *
+ * \return finite automaton accepting the language described by the original regular expression
*/
static automaton::EpsilonNFA < > convert(const regexp::FormalRegExp < > & regexp);
+
+ /**
+ * \overload
+ */
static automaton::EpsilonNFA < > convert(const regexp::UnboundedRegExp < > & regexp);
class Unbounded {
diff --git a/alib2algo/src/regexp/convert/ToGrammar.cpp b/alib2algo/src/regexp/convert/ToGrammar.cpp
index 0bb63c7a909372612659b13f6bcc93e1563d4975..40919d23384e9a716b94196027efd21652218500 100644
--- a/alib2algo/src/regexp/convert/ToGrammar.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammar.cpp
@@ -12,8 +12,17 @@ namespace regexp {
namespace convert {
-auto ToGrammarFormalRegExp = registration::AbstractRegister < ToGrammar, grammar::RightRG < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::FormalRegExp < > & > ( ToGrammar::convert );
-auto ToGrammarUnboundedRegExp = registration::AbstractRegister < ToGrammar, grammar::RightRG < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::UnboundedRegExp < > & > ( ToGrammar::convert );
+auto ToGrammarFormalRegExp = registration::AbstractRegister < ToGrammar, grammar::RightRG < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::FormalRegExp < > & > ( ToGrammar::convert, "regexp" ).setDocumentation (
+"Converts the regular expression into a grammar (@sa regexp::convert::ToGrammarRightRGGlushkov::convert).\n\
+\n\
+@param regexp the regular expression\n\
+@return right regular grammar equivalent to original regular expression" );
+
+auto ToGrammarUnboundedRegExp = registration::AbstractRegister < ToGrammar, grammar::RightRG < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::UnboundedRegExp < > & > ( ToGrammar::convert, "regexp" ).setDocumentation (
+"Converts the regular expression into a grammar (@sa regexp::convert::ToGrammarRightRGGlushkov::convert).\n\
+\n\
+@param regexp the regular expression\n\
+@return right regular grammar equivalent to original regular expression" );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToGrammar.h b/alib2algo/src/regexp/convert/ToGrammar.h
index c4f386c2354407d0b8600876825a8269597e2ee8..dba255164dc48d1fdfa4b8b0d5139b3fbd35b11b 100644
--- a/alib2algo/src/regexp/convert/ToGrammar.h
+++ b/alib2algo/src/regexp/convert/ToGrammar.h
@@ -14,16 +14,21 @@ namespace regexp {
namespace convert {
+/**
+ * Conversion of regular expression to regular grammar.
+ * This class serves as a "default wrapper" over the conversion of RE to RG. It delegates to the glushkov conversion algorithm.
+ * @sa regexp::convert::ToGrammarRightRGGlushkov
+ */
class ToGrammar {
public:
/**
- * Performs conversion.
+ * Converts the regular expression into a grammar (@sa regexp::convert::ToGrammarRightRGGlushkov::convert).
*
- * \tparam SymbolType type of symbols in the regexp
+ * \tparam SymbolType the type of regular expression
*
- * \param regexp the converted regexp
+ * \param regexp the regular expression
*
- * \return right regular grammar equivalent to source regexp.
+ * \return right regular grammar equivalent to original regular expression.
*/
template < class SymbolType >
static grammar::RightRG < SymbolType, ext::pair < SymbolType, unsigned > > convert(const regexp::FormalRegExp < SymbolType > & regexp);
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
index b6f2df7a1a0b2de48559606f98603a171227cf8e..c0dadd865f8d33b387e885618dbce9e50b26f2ec 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
@@ -12,8 +12,17 @@ namespace regexp {
namespace convert {
-auto ToGrammarRightRGDerivationUnboundedRegExp = registration::AbstractRegister < ToGrammarRightRGDerivation, grammar::RightRG < DefaultSymbolType, unsigned >, const regexp::UnboundedRegExp < > & > ( ToGrammarRightRGDerivation::convert );
-auto ToGrammarRightRGDerivationFormalRegExp = registration::AbstractRegister < ToGrammarRightRGDerivation, grammar::RightRG < DefaultSymbolType, unsigned >, const regexp::FormalRegExp < > & > ( ToGrammarRightRGDerivation::convert );
+auto ToGrammarRightRGDerivationUnboundedRegExp = registration::AbstractRegister < ToGrammarRightRGDerivation, grammar::RightRG < DefaultSymbolType, unsigned >, const regexp::UnboundedRegExp < > & > ( ToGrammarRightRGDerivation::convert, "regexp" ).setDocumentation (
+"Implements conversion of regular expressions to regular grammars usign Brzozowski's derivation algorithm.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return right regular grammar generating the language described by the original regular expression" );
+
+auto ToGrammarRightRGDerivationFormalRegExp = registration::AbstractRegister < ToGrammarRightRGDerivation, grammar::RightRG < DefaultSymbolType, unsigned >, const regexp::FormalRegExp < > & > ( ToGrammarRightRGDerivation::convert, "regexp" ).setDocumentation (
+"Implements conversion of regular expressions to regular grammars usign Brzozowski's derivation algorithm.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return right regular grammar generating the language described by the original regular expression" );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
index 2791abadf9a8bec1a046568717c4667d76981dfd..3f31331bbec4982d115d2b18ac8bb69d3fa4b592 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
@@ -29,14 +29,20 @@ namespace regexp {
namespace convert {
/**
- * Converts reg. expression to right regular grammar using brzozowski derivation algorithm.
+ * Converts regular expression to right regular grammar using Brzozowski's derivation algorithm.
* Source: Melichar 2.137
*/
class ToGrammarRightRGDerivation {
public:
/**
- * Performs conversion.
- * @return right regular grammar equivalent to source regexp.
+ * Implements conversion of regular expressions to regular grammars usign Brzozowski's derivation algorithm.
+ *
+ * \tparam T the type of regular expression to convert
+ * \tparam SymbolType the type of symbols in the regular expression
+ *
+ * \param regexp the regexp to convert
+ *
+ * \return right regular grammar generating the language described by the original regular expression
*/
template < class T, class SymbolType = typename regexp::SymbolTypeOfRegexp < T > >
static grammar::RightRG < SymbolType, unsigned > convert ( const T & regexp );
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
index ee9e2abcdaa976b67274e6aa5e1df248d111786c..2350319c39bafc6ff63dcb25c744bb935b8092bd 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
@@ -12,8 +12,17 @@ namespace regexp {
namespace convert {
-auto ToGrammarRightRGGlushkovUnboundedRegExp = registration::AbstractRegister < ToGrammarRightRGGlushkov, grammar::RightRG < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::UnboundedRegExp < > & > ( ToGrammarRightRGGlushkov::convert );
-auto ToGrammarRightRGGlushkovFormalRegExp = registration::AbstractRegister < ToGrammarRightRGGlushkov, grammar::RightRG < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::FormalRegExp < > & > ( ToGrammarRightRGGlushkov::convert );
+auto ToGrammarRightRGGlushkovUnboundedRegExp = registration::AbstractRegister < ToGrammarRightRGGlushkov, grammar::RightRG < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::UnboundedRegExp < > & > ( ToGrammarRightRGGlushkov::convert, "regexp" ).setDocumentation (
+"Implements conversion of regular expressions to finite automata usign Glushkov's method of neighbours.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return right regular grammar generating the language described by the original regular expression" );
+
+auto ToGrammarRightRGGlushkovFormalRegExp = registration::AbstractRegister < ToGrammarRightRGGlushkov, grammar::RightRG < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::FormalRegExp < > & > ( ToGrammarRightRGGlushkov::convert, "regexp" ).setDocumentation (
+"Implements conversion of regular expressions to finite automata usign Glushkov's method of neighbours.\n\
+\n\
+@param regexp the regexp to convert\n\
+@return right regular grammar generating the language described by the original regular expression" );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
index d6588235a137975564ab06d1afefb069af6e636f..7bf32eedeb7051f5937f6c8e20c56a28204012e0 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
@@ -28,19 +28,19 @@ namespace regexp {
namespace convert {
/**
- * Converts regular expression to right regular grammar using Glushkov algorithm.
+ * Converts regular expression to right regular grammar using Glushkov algorithm of neighbours.
* Source: None yet.
*/
class ToGrammarRightRGGlushkov {
public:
/**
- * Performs conversion.
+ * Implements conversion of regular expressions to finite automata usign Glushkov's method of neighbours.
*
- * \tparam SymbolType tye of symbols in the regular expression
+ * \tparam SymbolType the type of symbols in the regular expression
*
- * \param regexp original regular expression
+ * \param regexp the regexp to convert
*
- * \return right regular grammar equivalent to source regexp.
+ * \return right regular grammar generating the language described by the original regular expression
*/
template < class SymbolType >
static grammar::RightRG < SymbolType, ext::pair < SymbolType, unsigned > > convert(const regexp::FormalRegExp < SymbolType > & regexp);