diff --git a/alib2common/src/base/CommonBase.hpp b/alib2common/src/base/CommonBase.hpp
index c537870be68283d67f94fde19a15efc3003c2ec1..fe5170fc388f2b6460f4385e7bb2eff9309be691 100644
--- a/alib2common/src/base/CommonBase.hpp
+++ b/alib2common/src/base/CommonBase.hpp
@@ -24,8 +24,14 @@ public:
template < typename T >
class CommonBaseMiddle : public CommonBaseBase {
public:
+ /**
+ * Virtual copy constructor
+ */
virtual T * clone ( ) const = 0;
+ /**
+ * Virtual move constructor
+ */
virtual T * plunder ( ) && = 0;
bool operator !=( const T & other ) const {
diff --git a/alib2common/src/object/ObjectBase.h b/alib2common/src/object/ObjectBase.h
index 2079613dccfadcee9124134455c8ae6442b49aa6..797155e21bcfeaea71e419063900b341ef4bf12e 100644
--- a/alib2common/src/object/ObjectBase.h
+++ b/alib2common/src/object/ObjectBase.h
@@ -16,18 +16,33 @@
namespace alib {
/**
- * Represents generic object.
+ * Represents a base for any object.
*/
class ObjectBase : public alib::CommonBase<ObjectBase>, public std::cow_shared_ptr_base {
public:
virtual void compose ( std::deque < sax::Token > & out ) const = 0;
- virtual ObjectBase * clone() const = 0;
- virtual ObjectBase * plunder() && = 0;
-
+ /**
+ * @copydoc alib::CommonBase<ObjectBase>::clone()
+ */
+ virtual ObjectBase * clone() const override = 0;
+
+ /**
+ * @copydoc alib::CommonBase<ObjectBase>::plunder()
+ */
+ virtual ObjectBase * plunder() && override = 0;
+
+ /**
+ * \brief Similar to operator ++.
+ *
+ * \details Effectively may discard or preserve the instance based on the way how the incrementation can be done.
+ */
virtual ObjectBase * inc() && = 0;
- virtual ObjectBase * normalize() && = 0;
+ /**
+ * @copydoc alib::CommonBase<ObjectBase>::normalize()
+ */
+ virtual ObjectBase * normalize() && override = 0;
};
} /* namespace alib */
diff --git a/alib2data/src/grammar/GrammarBase.h b/alib2data/src/grammar/GrammarBase.h
index 42642a72ed36f0219d55a0a9cad1bf05896af21c..bb22382ddea9b6b397b11c07fcbb8c7156320b20 100644
--- a/alib2data/src/grammar/GrammarBase.h
+++ b/alib2data/src/grammar/GrammarBase.h
@@ -13,14 +13,24 @@
namespace grammar {
/**
- * Represents symbol in an alphabet.
+ * \brief Represents base for a concrete grammar type.
*/
class GrammarBase : public alib::ObjectBase {
public:
- virtual GrammarBase* clone() const = 0;
- virtual GrammarBase* plunder() && = 0;
+ /**
+ * @copydoc alib::ObjectBase::clone()
+ */
+ virtual GrammarBase* clone() const override = 0;
- virtual GrammarBase* normalize ( ) && = 0;
+ /**
+ * @copydoc alib::ObjectBase::plunder()
+ */
+ virtual GrammarBase* plunder() && override = 0;
+
+ /**
+ * @copydoc alib::ObjectBase::normalize()
+ */
+ virtual GrammarBase* normalize ( ) && override = 0;
};
} /* namespace grammar */
diff --git a/alib2data/src/grammar/Regular/LeftRG.h b/alib2data/src/grammar/Regular/LeftRG.h
index 25e76ddd978114265e67e67542e1b5e1b014ffd8..f5d1f9f5799d532cb8187137544a98cdbeb28258 100644
--- a/alib2data/src/grammar/Regular/LeftRG.h
+++ b/alib2data/src/grammar/Regular/LeftRG.h
@@ -18,36 +18,42 @@
#include <sax/FromXMLParserHelper.h>
#include <object/UniqueObject.h>
-#include "../GrammarBase.h"
-#include "../GrammarFeatures.h"
-#include "../GrammarException.h"
-#include "../common/GrammarFromXMLParser.h"
-#include "../common/GrammarToXMLComposer.h"
-#include "../common/GrammarNormalize.h"
+#include <grammar/GrammarBase.h>
+#include <grammar/GrammarFeatures.h>
+#include <grammar/GrammarException.h>
+#include <grammar/common/GrammarFromXMLParser.h>
+#include <grammar/common/GrammarToXMLComposer.h>
+#include <grammar/common/GrammarNormalize.h>
#include <alphabet/common/SymbolNormalize.h>
namespace grammar {
-/**
- * Left regular grammar in chomsky normal form. Type 2 in Chomsky hierarchy. Produces regular languages.
- * Definition is similar to all common definitions of regular grammars. Additionaly contains boolean signaling whether the grammar generates empty string or don't.
- * G = (N, T, P, S, E)
- * N = nonempty finite set of nonterminal symbols
- * T = finite set of terminal symbols - having this empty won't let grammar do much though
- * P = set of production rules of the form A -> aB or A -> a, where A, B \in N and a \in T
- * S = initial nonterminal symbol
- * E = boolean signaling wheter grammar generates empty string or don't
- *
- * This definition has simplier handling of empty string generation and it is compatible with common definitions where the transformation from this definition to the common definition and backwards is trivial
- */
class TerminalAlphabet;
class NonterminalAlphabet;
class InitialSymbol;
+/**
+ * \brief
+ * Left regular grammar in Chomsky hierarchy or type 2 in Chomsky hierarchy. Generates regular languages.
+
+ * \details
+ * Definition is similar to all common definitions of regular grammars. Additionaly contains boolean signaling whether the grammar generates empty string or don't.
+ * Hence the A -> \eps and not even S -> \eps, where A \in N is not allowed.
+ * G = (N, T, P, S, E),
+ * N (NonterminalAlphabet) = nonempty finite set of nonterminal symbols,
+ * T (TerminalAlphabet) = finite set of terminal symbols - having this empty won't let grammar do much though,
+ * P = set of production rules of the form A -> aB or A -> a, where A, B \in N and a \in T,
+ * S (InitialSymbol) = initial nonterminal symbol,
+ * E = boolean signaling wheter grammar generates empty string or don't.
+ *
+ * This definition has simplier handling of empty string generation and it is compatible with common definitions where the transformation from this definition to the common definition and backwards is straightforward.
+ *
+ * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
+ */
template < class SymbolType >
class LeftRG final : public GrammarBase, public std::Components < LeftRG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
/**
- * Transition function as mapping from nonterminal symbol on the left hand side to set of either terminal symbols or doublets of terminal symbol and nonterminal symbol
+ * Transition function as mapping from nonterminal symbol on the left hand side to set of either terminal symbols or doublets of terminal symbol and nonterminal symbol.
*/
std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
@@ -58,156 +64,328 @@ class LeftRG final : public GrammarBase, public std::Components < LeftRG < Symbo
public:
/**
- * Creates a new instance of Left regular grammar with concrete initial symbol
+ * \brief Creates a new instance of Left regular grammar with concrete initial symbol.
+ *
+ * \param initialSymbol the initial symbol of the grammar
*/
explicit LeftRG ( SymbolType initialSymbol );
/**
- * Creates a new instance of Left regular grammar with concrete nonterminal, terminal alphabet and initial symbol
+ * \brief Creates a new instance of Left regular grammar with concrete nonterminal, terminal alphabet and initial symbol.
+ *
+ * \param nonTerminalSymbols the initial nonterminal alphabet
+ * \param terminalSymbols the initial terminal alphabet
+ * \param initialSymbol the initial symbol of the grammar
*/
explicit LeftRG ( std::set < SymbolType > nonTerminalSymbols, std::set < SymbolType > terminalSymbols, SymbolType initialSymbol );
/**
- * @copydoc alib::base::clone()
+ * @copydoc grammar::GrammarBase::clone()
*/
- virtual GrammarBase * clone ( ) const;
+ virtual GrammarBase * clone ( ) const override;
/**
- * @copydoc alib::base::plunder()
+ * @copydoc grammar::GrammarBase::plunder()
*/
- virtual GrammarBase * plunder ( ) &&;
+ virtual GrammarBase * plunder ( ) && override;
/**
- * Add a new rule of a grammar in form of A -> aB or A -> a, where A, B \in N and a \in T
+ * \brief Add a new rule of a grammar.
+ *
+ * \details The rule is in a form of A -> aB or A -> a, where A, B \in N and a \in T.
+ *
+ * \param leftHandSide the left hand side of the rule
+ * \param rightHandSide the right hand side of the rule
+ *
+ * \returns true if the rule was indeed added, false othervise
*/
bool addRule ( SymbolType leftHandSide, std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rightHandSide );
/**
- * Add a new rule of a grammar in form of A -> a, where A \in N and a \in T
+ * \brief Add a new rule of a grammar.
+ *
+ * \details The rule is in a form of A -> a, where A \in N and a \in T.
+ *
+ * \param leftHandSide the left hand side of the rule
+ * \param rightHandSide the right hand side of the rule
+ *
+ * \returns true if the rule was indeed added, false othervise
*/
bool addRule ( SymbolType leftHandSide, SymbolType rightHandSide );
/**
- * Add a new rule of a grammar in form of A -> aB, where A, B \in N and a \in T
+ * \brief Add a new rule of a grammar.
+ *
+ * \details The rule is in a form of A -> aB, where A, B \in N and a \in T.
+ *
+ * \param leftHandSide the left hand side of the rule
+ * \param rightHandSide the right hand side of the rule
+ *
+ * \returns true if the rule was indeed added, false othervise
*/
bool addRule ( SymbolType leftHandSide, std::pair < SymbolType, SymbolType > rightHandSide );
/**
- * Add a new rules of a grammar in form of A -> aB | bC | ... | a | b | ..., where A, B, C ... \in N and a, b ... \in T
+ * \brief Add new rules of a grammar.
+ *
+ * \details The rules are in form of A -> aB | bC | ... | a | b | ..., where A, B, C ... \in N and a, b ... \in T.
+ *
+ * \param leftHandSide the left hand side of the rule
+ * \param rightHandSide a set of right hand sides of the rule
*/
void addRules ( SymbolType leftHandSide, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > rightHandSide );
/**
- * Get rules of the grammar
+ * Get rules of the grammar.
+ *
+ * \returns rules of the grammar
*/
const std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & getRules ( ) const;
/**
- * Add a new rule of a grammar in form of A -> aB or A -> a, where A, B \in N and a \in T
+ * Remove a rule of a grammar in form of A -> aB or A -> a, where A, B \in N and a \in T.
+ *
+ * \param leftHandSide the left hand side of the rule
+ * \param rightHandSide the right hand side of the rule
+ *
+ * \returns true if the rule was indeed removed, false othervise
*/
bool removeRule ( const SymbolType & leftHandSide, const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rightHandSide );
/**
- * Add a new rule of a grammar in form of A -> a, where A \in N and a \in T
+ * Remove a rule of a grammar in form of A -> a, where A \in N and a \in T.
+ *
+ * \param leftHandSide the left hand side of the rule
+ * \param rightHandSide the right hand side of the rule
+ *
+ * \returns true if the rule was indeed removed, false othervise
*/
bool removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide );
/**
- * Add a new rule of a grammar in form of A -> aB, where A, B \in N and a \in T
+ * Remove a rule of a grammar in form of A -> aB, where A, B \in N and a \in T.
+ *
+ * \param leftHandSide the left hand side of the rule
+ * \param rightHandSide the right hand side of the rule
+ *
+ * \returns true if the rule was indeed removed, false othervise
*/
bool removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, SymbolType > & rightHandSide );
+ /**
+ * Add a new rule of a grammar in form of A -> aB or A -> a, where A, B \in N and a \in T as stored in combination of leftHandSide and rightHandSide
+ *
+ * \param leftHandSide the left hand side of the rule
+ * \param rightHandSide the right hand side of the rule
+ *
+ * \returns true if the rule was indeed added, false othervise
+ */
bool addRawRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide );
+ /**
+ * Get rules in most common format of rules as mapping from leftHandSide to rightHandSides represented by vectors of symbols.
+ *
+ * \returns rules of the grammar
+ */
std::map < SymbolType, std::set < std::vector < SymbolType > > > getRawRules ( ) const;
+ /**
+ * Remove a rule of a grammar in form of A -> aB or A -> a, where A, B \in N and a \in T as stored in combination of leftHandSide and rightHandSide
+ *
+ * \returns true if the rule was indeed removed, false othervise
+ */
bool removeRawRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide );
+ /**
+ * Getter of initial symbol.
+ *
+ * \returns the initial symbol of the grammar
+ */
const SymbolType & getInitialSymbol ( ) const {
return this->template accessElement < InitialSymbol > ( ).get ( );
}
+ /**
+ * Setter of initial symbol.
+ *
+ * \param symbol new initial symbol of the grammar
+ *
+ * \returns true of the initial symbol was indeed changed
+ */
bool setInitialSymbol ( SymbolType symbol ) {
return this->template accessElement < InitialSymbol > ( ).set ( std::move ( symbol ) );
}
+ /**
+ * Getter of nonterminal alphabet.
+ *
+ * \returns the nonterminal alphabet of the grammar
+ */
const std::set < SymbolType > & getNonterminalAlphabet ( ) const {
return this->template accessComponent < NonterminalAlphabet > ( ).get ( );
}
+ /**
+ * Adder of nonterminal symbol.
+ *
+ * \param symbol the new symbol to be added to nonterminal alphabet
+ *
+ * \returns true if the symbol was indeed added
+ */
bool addNonterminalSymbol ( SymbolType symbol ) {
return this->template accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
}
+ /**
+ * Setter of nonterminal alphabet.
+ *
+ * \param symbols completely new nonterminal alphabet
+ */
void setNonterminalAlphabet ( std::set < SymbolType > symbols ) {
this->template accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
}
+ /**
+ * Getter of terminal alphabet.
+ *
+ * \returns the terminal alphabet of the grammar
+ */
const std::set < SymbolType > & getTerminalAlphabet ( ) const {
return this->template accessComponent < TerminalAlphabet > ( ).get ( );
}
+ /**
+ * Adder of terminal symbol.
+ *
+ * \param symbol the new symbol tuo be added to nonterminal alphabet
+ *
+ * \returns true if the symbol was indeed added
+ */
bool addTerminalSymbol ( SymbolType symbol ) {
return this->template accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
}
+ /**
+ * Setter of terminal alphabet.
+ *
+ * \param symbol completely new nontemrinal alphabet
+ */
void setTerminalAlphabet ( std::set < SymbolType > symbols ) {
this->template accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
}
/**
- * Sets sign representing that grammar generates or doesn't generate empty word
+ * Sets sign representing that grammar generates or doesn't generate empty word.
+ *
+ * \param genEps sign representing the posibility of generating empty string from the grammar
*/
void setGeneratesEpsilon ( bool genEps );
/**
- * Gets sign representing that grammar generates or doesn't generate empty word
+ * Gets sign representing that grammar generates or doesn't generate empty word.
+ *
+ * \returns sign representing the posibility of generating empty string from the grammar
*/
bool getGeneratesEpsilon ( ) const;
/**
- * double dispatch operator helper
+ * \brief Comparison helper method evaluating allowing deeper comparison of this with other class of the same type.
+ *
+ * \details If the other class is of different type the relative order is computer by means of type_index.
+ *
+ * \param other the other class to compare with
+ *
+ * \returns result of actual comparison if type of this class and other class is the same, result of difference of type indexes othervise.
*/
- virtual int compare ( const ObjectBase & other ) const {
+ virtual int compare ( const ObjectBase & other ) const override {
if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
return std::type_index ( typeid ( * this ) ) - std::type_index ( typeid ( other ) );
}
/**
- * compare
- * @param other the other instance
+ * Actual compare method
+ *
+ * \param other the other instance
+ *
+ * \returns actual relation between two by type same grammar instances
*/
- virtual int compare ( const LeftRG & other ) const;
+ int compare ( const LeftRG & other ) const;
/**
- * print this instance as raw representation to ostream
+ * Print this instance as raw representation to ostream
+ *
* @param os ostream where to print
*/
- virtual void operator >>( std::ostream & os ) const;
+ virtual void operator >>( std::ostream & os ) const override;
/**
- * casts this instance to as compact as possible string representation
+ * Casts this instance to as compact as possible string representation
+ *
+ * \returns string representation of the grammar
*/
- virtual explicit operator std::string ( ) const;
+ virtual explicit operator std::string ( ) const override;
+ /**
+ * \brief The XML tag name of class.
+ *
+ * \details Intentionaly a static member function to be safe in the initialisation before the main function starts.
+ *
+ * \returns string representing the XML tag name of the class
+ */
static const std::string & getXmlTagName() {
static std::string xmlTagName = "LeftRG";
return xmlTagName;
}
+ /**
+ * Parsing from a sequence of xml tokens helper.
+ *
+ * \params input the iterator to sequence of xml tokens to parse from
+ *
+ * \returns the new instance of the grammar
+ */
static LeftRG parse ( std::deque < sax::Token >::iterator & input );
+
+ /**
+ * Helper for parsing of individual rules of the grammar from a sequence of xml tokens.
+ *
+ * \params input the iterator to sequence of xml tokens to parse from
+ * \params grammar the grammar to add the rule to
+ */
static void parseRule ( std::deque < sax::Token >::iterator & input, LeftRG & grammar );
- void compose ( std::deque < sax::Token > & out ) const;
+ /**
+ * Composing to a sequence of xml tokens helper.
+ *
+ * \param out sink for new xml tokens representing the grammar
+ */
+ virtual void compose ( std::deque < sax::Token > & out ) const override;
+
+ /**
+ * Helper for composing rules of the grammar to a sequence of xml tokens.
+ *
+ * \param out sink for xml tokens representing the rules of the grammar
+ */
void composeRules ( std::deque < sax::Token > & out ) const;
- virtual alib::ObjectBase * inc ( ) &&;
+ /**
+ * @copydoc alib::GrammarBase::inc()
+ */
+ virtual alib::ObjectBase * inc ( ) && override;
+ /**
+ * Type of normalized type.
+ */
typedef LeftRG < > normalized_type;
- virtual GrammarBase * normalize ( ) && {
+ /**
+ * Helper for normalisation of types specified by templates used as internal datatypes of symbols.
+ *
+ * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
+ */
+ virtual GrammarBase * normalize ( ) && override {
if ( typeid ( LeftRG < > ) == typeid ( LeftRG < SymbolType > ) )
return this;
@@ -489,16 +667,29 @@ void LeftRG < SymbolType >::composeRules ( std::deque < sax::Token > & out ) con
template < class SymbolType >
alib::ObjectBase* LeftRG < SymbolType >::inc() && {
- return new alib::UniqueObject(alib::Object(std::move(*this)), primitive::Integer(0));
+ return new alib::UniqueObject ( alib::Object ( std::move ( * this ) ), primitive::Integer ( 0 ) );
}
} /* namespace grammar */
namespace std {
+/**
+ * Helper class specifying constraints for the grammar's internal terminal alphabet component.
+ *
+ * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
+ */
template < class SymbolType >
class ComponentConstraint< grammar::LeftRG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
public:
+ /**
+ * Returns true if the terminal symbol is still used in some rule of the grammar.
+ *
+ * \param grammar the tested grammar
+ * \param symbol the tested symbol
+ *
+ * \returns true if the symbol is used, false othervise
+ */
static bool used ( const grammar::LeftRG < SymbolType > & grammar, const SymbolType & symbol ) {
for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
for ( const std::variant < SymbolType, std::pair < SymbolType, SymbolType > > & rhs : rule.second )
@@ -508,19 +699,45 @@ public:
return false;
}
+ /**
+ * Returns true as all terminal symbols are possibly available to be terminal symbols.
+ *
+ * \returns true
+ */
static bool available ( const grammar::LeftRG < SymbolType > &, const SymbolType & ) {
return true;
}
+ /**
+ * Throws runtime exception if the symbol requested to be terminal symbol is already in nonterminal alphabet.
+ *
+ * \param grammar the tested grammar
+ * \param symbol the tested symbol
+ *
+ * \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
+ */
static void valid ( const grammar::LeftRG < SymbolType > & grammar, const SymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + std::to_string ( symbol ) + "cannot be in terminal alphabet since it is already nonterminal alphabet" );
}
};
+/**
+ * Helper class specifying constraints for the grammar's internal nonterminal alphabet component.
+ *
+ * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
+ */
template < class SymbolType >
class ComponentConstraint< grammar::LeftRG < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
public:
+ /**
+ * Returns true if the nonterminal symbol is still used in some rule of the grammar or if it is the initial symbol of the grammar.
+ *
+ * \param grammar the tested grammar
+ * \param symbol the tested symbol
+ *
+ * \returns true if the symbol is used, false othervise
+ */
static bool used ( const grammar::LeftRG < SymbolType > & grammar, const SymbolType & symbol ) {
for ( const std::pair < const SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
@@ -538,23 +755,52 @@ public:
return false;
}
+ /**
+ * Returns true as all terminal symbols are possibly available to be terminal symbols.
+ *
+ * \returns true
+ */
static bool available ( const grammar::LeftRG < SymbolType > &, const SymbolType & ) {
return true;
}
+ /**
+ * Throws runtime exception if the symbol requested to be nonterminal symbol is already in terminal alphabet.
+ *
+ * \param grammar the tested grammar
+ * \param symbol the tested symbol
+ *
+ * \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
+ */
static void valid ( const grammar::LeftRG < SymbolType > & grammar, const SymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + std::to_string ( symbol ) + "cannot be in nonterminal alphabet since it is already in terminal alphabet" );
}
};
+/**
+ * Helper class specifying constraints for the grammar's internal initial symbol component.
+ *
+ * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
+ */
template < class SymbolType >
class ElementConstraint< grammar::LeftRG < SymbolType >, SymbolType, grammar::InitialSymbol > {
public:
+ /**
+ * Returns true if the symbol requested to be initial is available in nonterminal alphabet.
+ *
+ * \param grammar the tested grammar
+ * \param symbol the tested symbol
+ *
+ * \returns true if the tested symbol is in nonterminal alphabet
+ */
static bool available ( const grammar::LeftRG < SymbolType > & grammar, const SymbolType & symbol ) {
return grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
}
+ /**
+ * All symbols are posibly valid as initial symbols.
+ */
static void valid ( const grammar::LeftRG < SymbolType > &, const SymbolType & ) {
}
};