diff --git a/acompare2/src/GrammarCompare.cpp b/acompare2/src/GrammarCompare.cpp
index e6d963b0516d32f1cc828fa1661dfd7da2a2f5db..ed9178616f6f3c61513fc701a02e7f2a69947e24 100644
--- a/acompare2/src/GrammarCompare.cpp
+++ b/acompare2/src/GrammarCompare.cpp
@@ -107,14 +107,14 @@ bool GrammarCompare::testCompare(const grammar::NonContractingGrammar < > & a, c
a.getTerminalAlphabet() == b.getTerminalAlphabet() ;
}
-bool GrammarCompare::testCompare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b) {
+bool GrammarCompare::testCompare(const grammar::ContextPreservingUnrestrictedGrammar < > & a, const grammar::ContextPreservingUnrestrictedGrammar < > & b) {
return a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
a.getRules() == b.getRules() &&
a.getInitialSymbol() == b.getInitialSymbol() &&
a.getTerminalAlphabet() == b.getTerminalAlphabet() ;
}
-bool GrammarCompare::testCompare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b) {
+bool GrammarCompare::testCompare(const grammar::UnrestrictedGrammar < > & a, const grammar::UnrestrictedGrammar < > & b) {
return a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
a.getRules() == b.getRules() &&
a.getInitialSymbol() == b.getInitialSymbol() &&
@@ -499,7 +499,7 @@ void GrammarCompare::printCompare(const grammar::NonContractingGrammar < > & a,
}
}
-void GrammarCompare::printCompare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b) {
+void GrammarCompare::printCompare(const grammar::ContextPreservingUnrestrictedGrammar < > & a, const grammar::ContextPreservingUnrestrictedGrammar < > & b) {
std::cout << "GrammarCompareer" << std::endl;
if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
@@ -529,7 +529,7 @@ void GrammarCompare::printCompare(const grammar::ContextPreservingUnrestrictedGr
}
}
-void GrammarCompare::printCompare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b) {
+void GrammarCompare::printCompare(const grammar::UnrestrictedGrammar < > & a, const grammar::UnrestrictedGrammar < > & b) {
std::cout << "GrammarCompareer" << std::endl;
if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
@@ -680,7 +680,7 @@ int GrammarCompare::compare(const grammar::NonContractingGrammar < > & a, const
auto GrammarCompareNonContractingGrammar = GrammarCompare::RegistratorWrapper<int, grammar::NonContractingGrammar < >, grammar::NonContractingGrammar < > >(GrammarCompare::compare);
-int GrammarCompare::compare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b) {
+int GrammarCompare::compare(const grammar::ContextPreservingUnrestrictedGrammar < > & a, const grammar::ContextPreservingUnrestrictedGrammar < > & b) {
if(!GrammarCompare::testCompare(a, b)) {
GrammarCompare::printCompare(a, b);
return 1;
@@ -689,9 +689,9 @@ int GrammarCompare::compare(const grammar::ContextPreservingUnrestrictedGrammar&
}
}
-auto GrammarCompareContextPreservingUnrestrictedGrammar = GrammarCompare::RegistratorWrapper<int, grammar::ContextPreservingUnrestrictedGrammar, grammar::ContextPreservingUnrestrictedGrammar>(GrammarCompare::compare);
+auto GrammarCompareContextPreservingUnrestrictedGrammar = GrammarCompare::RegistratorWrapper<int, grammar::ContextPreservingUnrestrictedGrammar < >, grammar::ContextPreservingUnrestrictedGrammar < > >(GrammarCompare::compare);
-int GrammarCompare::compare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b) {
+int GrammarCompare::compare(const grammar::UnrestrictedGrammar < > & a, const grammar::UnrestrictedGrammar < > & b) {
if(!GrammarCompare::testCompare(a, b)) {
GrammarCompare::printCompare(a, b);
return 1;
@@ -700,7 +700,7 @@ int GrammarCompare::compare(const grammar::UnrestrictedGrammar& a, const grammar
}
}
-auto GrammarCompareUnrestrictedGrammar = GrammarCompare::RegistratorWrapper<int, grammar::UnrestrictedGrammar, grammar::UnrestrictedGrammar>(GrammarCompare::compare);
+auto GrammarCompareUnrestrictedGrammar = GrammarCompare::RegistratorWrapper<int, grammar::UnrestrictedGrammar < >, grammar::UnrestrictedGrammar < > >(GrammarCompare::compare);
int GrammarCompare::compare(const grammar::Grammar& a, const grammar::Grammar& b) {
return dispatch(a.getData(), b.getData());
diff --git a/acompare2/src/GrammarCompare.h b/acompare2/src/GrammarCompare.h
index ad2b8efb4db3f2af258bb5083c67f67e2c2a5678..e5057daf945b52b85a52dc0ab37ed7092e4f5a43 100644
--- a/acompare2/src/GrammarCompare.h
+++ b/acompare2/src/GrammarCompare.h
@@ -53,11 +53,11 @@ private:
static bool testCompare(const grammar::NonContractingGrammar < > & a, const grammar::NonContractingGrammar < > & b);
static void printCompare(const grammar::NonContractingGrammar < > & a, const grammar::NonContractingGrammar < > & b);
- static bool testCompare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b);
- static void printCompare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b);
+ static bool testCompare(const grammar::ContextPreservingUnrestrictedGrammar < > & a, const grammar::ContextPreservingUnrestrictedGrammar < > & b);
+ static void printCompare(const grammar::ContextPreservingUnrestrictedGrammar < > & a, const grammar::ContextPreservingUnrestrictedGrammar < > & b);
- static bool testCompare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b);
- static void printCompare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b);
+ static bool testCompare(const grammar::UnrestrictedGrammar < > & a, const grammar::UnrestrictedGrammar < > & b);
+ static void printCompare(const grammar::UnrestrictedGrammar < > & a, const grammar::UnrestrictedGrammar < > & b);
template <class T> static void setCompare(const std::set<T> a, const std::set<T> b);
template <class T> static void listCompare(const std::list<T> a, const std::list<T> b);
@@ -74,8 +74,8 @@ public:
static int compare(const grammar::GNF < > & a, const grammar::GNF < > & b);
static int compare(const grammar::CSG < > & a, const grammar::CSG < > & b);
static int compare(const grammar::NonContractingGrammar < > & a, const grammar::NonContractingGrammar < > & b);
- static int compare(const grammar::ContextPreservingUnrestrictedGrammar& a, const grammar::ContextPreservingUnrestrictedGrammar& b);
- static int compare(const grammar::UnrestrictedGrammar& a, const grammar::UnrestrictedGrammar& b);
+ static int compare(const grammar::ContextPreservingUnrestrictedGrammar < > & a, const grammar::ContextPreservingUnrestrictedGrammar < > & b);
+ static int compare(const grammar::UnrestrictedGrammar < > & a, const grammar::UnrestrictedGrammar < > & b);
static int compare(const grammar::Grammar& a, const grammar::Grammar& b);
};
diff --git a/alib2data/src/grammar/GrammarFeatures.h b/alib2data/src/grammar/GrammarFeatures.h
index f67d97e78bc9c8c21f3dde788b3fbd0ae9520df2..c480acffa1a84f5186094389678025521729c6ed 100644
--- a/alib2data/src/grammar/GrammarFeatures.h
+++ b/alib2data/src/grammar/GrammarFeatures.h
@@ -53,7 +53,9 @@ template<class SymbolType = typename alphabet::Symbol >
class CSG;
template<class SymbolType = typename alphabet::Symbol >
class NonContractingGrammar;
+template<class SymbolType = typename alphabet::Symbol >
class ContextPreservingUnrestrictedGrammar;
+template<class SymbolType = typename alphabet::Symbol >
class UnrestrictedGrammar;
} /* namespace grammar */
diff --git a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.cpp b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.cpp
index e9cd7ca50f1977a9798bbe8d76036b8cc8ae5f4a..3824b5fdb45cc21f521860717c1dd56961cb1c7e 100644
--- a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.cpp
+++ b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.cpp
@@ -6,146 +6,13 @@
*/
#include "ContextPreservingUnrestrictedGrammar.h"
-#include <algorithm>
-#include <sstream>
-
-#include "../../alphabet/Symbol.h"
-
-#include <sax/FromXMLParserHelper.h>
-#include "../common/GrammarFromXMLParser.h"
-#include "../common/GrammarToXMLComposer.h"
#include "../Grammar.h"
#include <object/Object.h>
#include <XmlApi.hpp>
-namespace grammar {
-
-ContextPreservingUnrestrictedGrammar::ContextPreservingUnrestrictedGrammar ( alphabet::Symbol initialSymbol ) : ContextPreservingUnrestrictedGrammar ( std::set < alphabet::Symbol > { initialSymbol }, std::set < alphabet::Symbol > ( ), initialSymbol ) {
-}
-
-ContextPreservingUnrestrictedGrammar::ContextPreservingUnrestrictedGrammar ( std::set < alphabet::Symbol > nonterminalAlphabet, std::set < alphabet::Symbol > terminalAlphabet, alphabet::Symbol initialSymbol ) : std::Components < ContextPreservingUnrestrictedGrammar, alphabet::Symbol, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
-}
-
-GrammarBase * ContextPreservingUnrestrictedGrammar::clone ( ) const {
- return new ContextPreservingUnrestrictedGrammar ( * this );
-}
-
-GrammarBase * ContextPreservingUnrestrictedGrammar::plunder ( ) && {
- return new ContextPreservingUnrestrictedGrammar ( std::move ( * this ) );
-}
-
-bool ContextPreservingUnrestrictedGrammar::addRule ( std::vector < alphabet::Symbol > lContext, alphabet::Symbol leftHandSide, std::vector < alphabet::Symbol > rContext, std::vector < alphabet::Symbol > rightHandSide ) {
- for ( const alphabet::Symbol & symbol : lContext )
- if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
- throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
-
- if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
- throw GrammarException ( "Rule must rewrite nonterminal symbol" );
-
- for ( const alphabet::Symbol & symbol : rContext )
- if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
- throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
-
- for ( const alphabet::Symbol & symbol : rightHandSide )
- if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
- throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
-
- return rules[make_tuple ( std::move ( lContext ), std::move ( leftHandSide ), std::move ( rContext ) )].insert ( std::move ( rightHandSide ) ).second;
-}
-
-const std::map < std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > >, std::set < std::vector < alphabet::Symbol > > > & ContextPreservingUnrestrictedGrammar::getRules ( ) const {
- return rules;
-}
-
-bool ContextPreservingUnrestrictedGrammar::removeRule ( const std::vector < alphabet::Symbol > & lContext, const alphabet::Symbol & leftHandSide, const std::vector < alphabet::Symbol > & rContext, const std::vector < alphabet::Symbol > & rightHandSide ) {
- return rules[make_tuple ( lContext, leftHandSide, rContext )].erase ( rightHandSide );
-}
-
-int ContextPreservingUnrestrictedGrammar::compare ( const ContextPreservingUnrestrictedGrammar & other ) const {
- auto first = std::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
- auto second = std::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
-
- std::compare < decltype ( first ) > comp;
-
- return comp ( first, second );
-}
-
-void ContextPreservingUnrestrictedGrammar::operator >>( std::ostream & out ) const {
- out << "(ContextPreservingUnrestrictedGrammar "
- << "nonterminalAlphabet = " << getNonterminalAlphabet ( )
- << "terminalAlphabet = " << getTerminalAlphabet ( )
- << "initialSymbol = " << getInitialSymbol ( )
- << "rules = " << rules << ")";
-}
-
-ContextPreservingUnrestrictedGrammar::operator std::string ( ) const {
- std::stringstream ss;
- ss << * this;
- return ss.str ( );
-}
-
-ContextPreservingUnrestrictedGrammar ContextPreservingUnrestrictedGrammar::parse ( std::deque < sax::Token >::iterator & input ) {
- sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, ContextPreservingUnrestrictedGrammar::getXmlTagName() );
-
- std::set < alphabet::Symbol > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
- std::set < alphabet::Symbol > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
- alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
-
- ContextPreservingUnrestrictedGrammar grammar ( std::move ( initialSymbol ) );
-
- grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
- grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
-
- GrammarFromXMLParser::parseRules ( input, grammar );
-
- sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, ContextPreservingUnrestrictedGrammar::getXmlTagName() );
- return grammar;
-}
-
-void ContextPreservingUnrestrictedGrammar::parseRule ( std::deque < sax::Token >::iterator & input, ContextPreservingUnrestrictedGrammar & grammar ) {
- std::vector < alphabet::Symbol > lContext = GrammarFromXMLParser::parseRuleLContext ( input );
- alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
- std::vector < alphabet::Symbol > rContext = GrammarFromXMLParser::parseRuleRContext ( input );
- std::vector < alphabet::Symbol > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
-
- grammar.addRule ( std::move ( lContext ), std::move ( lhs ), std::move ( rContext ), std::move ( rhs ) );
-}
-
-void ContextPreservingUnrestrictedGrammar::compose ( std::deque < sax::Token > & out ) const {
- out.emplace_back ( ContextPreservingUnrestrictedGrammar::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
-
- GrammarToXMLComposer::composeNonterminalAlphabet ( out, this->getNonterminalAlphabet ( ) );
- GrammarToXMLComposer::composeTerminalAlphabet ( out, this->getTerminalAlphabet ( ) );
- GrammarToXMLComposer::composeInitialSymbol ( out, this->getInitialSymbol ( ) );
- composeRules ( out );
-
- out.emplace_back ( ContextPreservingUnrestrictedGrammar::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
-}
-
-void ContextPreservingUnrestrictedGrammar::composeRules ( std::deque < sax::Token > & out ) const {
- out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
-
- for ( const auto & rule : this->getRules ( ) )
-
- for ( const auto & rhs : rule.second ) {
- out.emplace_back ( "rule", sax::Token::TokenType::START_ELEMENT );
-
- GrammarToXMLComposer::composeRuleLContext ( out, std::get < 0 > ( rule.first ) );
- GrammarToXMLComposer::composeRuleSingleSymbolLHS ( out, std::get < 1 > ( rule.first ) );
- GrammarToXMLComposer::composeRuleRContext ( out, std::get < 2 > ( rule.first ) );
- GrammarToXMLComposer::composeRuleRHS ( out, rhs );
-
- out.emplace_back ( "rule", sax::Token::TokenType::END_ELEMENT );
- }
-
- out.emplace_back ( "rules", sax::Token::TokenType::END_ELEMENT );
-}
-
-} /* namespace grammar */
-
namespace alib {
-auto ContextPreservingUnrestrictedGrammarParserRegister = xmlApi < grammar::Grammar >::ParserRegister < grammar::ContextPreservingUnrestrictedGrammar > ( );
-auto ContextPreservingUnrestrictedGrammarParserRegister2 = xmlApi < alib::Object >::ParserRegister < grammar::ContextPreservingUnrestrictedGrammar > ( );
+auto ContextPreservingUnrestrictedGrammarParserRegister = xmlApi < grammar::Grammar >::ParserRegister < grammar::ContextPreservingUnrestrictedGrammar < > > ( );
+auto ContextPreservingUnrestrictedGrammarParserRegister2 = xmlApi < alib::Object >::ParserRegister < grammar::ContextPreservingUnrestrictedGrammar < > > ( );
} /* namespace alib */
diff --git a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
index 75e0f591b984439522946f273be538b0cc107349..71c563ef054418d7e02554facbd4c78dcf73809e 100644
--- a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
@@ -8,12 +8,19 @@
#ifndef CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR_H_
#define CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR_H_
-#include "../GrammarException.h"
-#include "../GrammarBase.h"
#include <map>
#include <vector>
+#include <algorithm>
+#include <sstream>
+
#include <core/components.hpp>
-#include "../../alphabet/Symbol.h"
+#include <sax/FromXMLParserHelper.h>
+
+#include "../GrammarBase.h"
+#include "../GrammarFeatures.h"
+#include "../GrammarException.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
namespace grammar {
@@ -24,54 +31,55 @@ class TerminalAlphabet;
class NonterminalAlphabet;
class InitialSymbol;
-class ContextPreservingUnrestrictedGrammar : public GrammarBase, public std::Components < ContextPreservingUnrestrictedGrammar, alphabet::Symbol, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
- std::map < std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > >, std::set < std::vector < alphabet::Symbol > > > rules;
+template < class SymbolType >
+class ContextPreservingUnrestrictedGrammar : public GrammarBase, public std::Components < ContextPreservingUnrestrictedGrammar < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+ std::map < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > >, std::set < std::vector < SymbolType > > > rules;
public:
- explicit ContextPreservingUnrestrictedGrammar ( alphabet::Symbol initialSymbol );
+ explicit ContextPreservingUnrestrictedGrammar ( SymbolType initialSymbol );
- explicit ContextPreservingUnrestrictedGrammar ( std::set < alphabet::Symbol > nonTerminalSymbols, std::set < alphabet::Symbol > terminalSymbols, alphabet::Symbol initialSymbol );
+ explicit ContextPreservingUnrestrictedGrammar ( std::set < SymbolType > nonTerminalSymbols, std::set < SymbolType > terminalSymbols, SymbolType initialSymbol );
virtual GrammarBase * clone ( ) const;
virtual GrammarBase * plunder ( ) &&;
- bool addRule ( std::vector < alphabet::Symbol > lContext, alphabet::Symbol leftHandSide, std::vector < alphabet::Symbol > rContext, std::vector < alphabet::Symbol > rightHandSide );
+ bool addRule ( std::vector < SymbolType > lContext, SymbolType leftHandSide, std::vector < SymbolType > rContext, std::vector < SymbolType > rightHandSide );
- const std::map < std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > >, std::set < std::vector < alphabet::Symbol > > > & getRules ( ) const;
+ const std::map < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > >, std::set < std::vector < SymbolType > > > & getRules ( ) const;
- bool removeRule ( const std::vector < alphabet::Symbol > & lContext, const alphabet::Symbol & leftHandSide, const std::vector < alphabet::Symbol > & rContext, const std::vector < alphabet::Symbol > & rightHandSide );
+ bool removeRule ( const std::vector < SymbolType > & lContext, const SymbolType & leftHandSide, const std::vector < SymbolType > & rContext, const std::vector < SymbolType > & rightHandSide );
- const alphabet::Symbol & getInitialSymbol ( ) const {
- return accessElement < InitialSymbol > ( ).get ( );
+ const SymbolType & getInitialSymbol ( ) const {
+ return this->template accessElement < InitialSymbol > ( ).get ( );
}
- bool setInitialSymbol ( alphabet::Symbol symbol ) {
- return accessElement < InitialSymbol > ( ).set ( std::move ( symbol ) );
+ bool setInitialSymbol ( SymbolType symbol ) {
+ return this->template accessElement < InitialSymbol > ( ).set ( std::move ( symbol ) );
}
- const std::set < alphabet::Symbol > & getNonterminalAlphabet ( ) const {
- return accessComponent < NonterminalAlphabet > ( ).get ( );
+ const std::set < SymbolType > & getNonterminalAlphabet ( ) const {
+ return this->template accessComponent < NonterminalAlphabet > ( ).get ( );
}
- bool addNonterminalSymbol ( alphabet::Symbol symbol ) {
- return accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
+ bool addNonterminalSymbol ( SymbolType symbol ) {
+ return this->template accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
}
- void setNonterminalAlphabet ( std::set < alphabet::Symbol > symbols ) {
- accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
+ void setNonterminalAlphabet ( std::set < SymbolType > symbols ) {
+ this->template accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
}
- const std::set < alphabet::Symbol > & getTerminalAlphabet ( ) const {
- return accessComponent < TerminalAlphabet > ( ).get ( );
+ const std::set < SymbolType > & getTerminalAlphabet ( ) const {
+ return this->template accessComponent < TerminalAlphabet > ( ).get ( );
}
- bool addTerminalSymbol ( alphabet::Symbol symbol ) {
- return accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
+ bool addTerminalSymbol ( SymbolType symbol ) {
+ return this->template accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
}
- void setTerminalAlphabet ( std::set < alphabet::Symbol > symbols ) {
- accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
+ void setTerminalAlphabet ( std::set < SymbolType > symbols ) {
+ this->template accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
}
virtual int compare ( const ObjectBase & other ) const {
@@ -99,24 +107,159 @@ public:
void composeRules ( std::deque < sax::Token > & out ) const;
};
+template < class SymbolType >
+ContextPreservingUnrestrictedGrammar < SymbolType >::ContextPreservingUnrestrictedGrammar ( SymbolType initialSymbol ) : ContextPreservingUnrestrictedGrammar ( std::set < SymbolType > { initialSymbol }, std::set < SymbolType > ( ), initialSymbol ) {
+}
+
+template < class SymbolType >
+ContextPreservingUnrestrictedGrammar < SymbolType >::ContextPreservingUnrestrictedGrammar ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < ContextPreservingUnrestrictedGrammar, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
+}
+
+template < class SymbolType >
+GrammarBase * ContextPreservingUnrestrictedGrammar < SymbolType >::clone ( ) const {
+ return new ContextPreservingUnrestrictedGrammar ( * this );
+}
+
+template < class SymbolType >
+GrammarBase * ContextPreservingUnrestrictedGrammar < SymbolType >::plunder ( ) && {
+ return new ContextPreservingUnrestrictedGrammar ( std::move ( * this ) );
+}
+
+template < class SymbolType >
+bool ContextPreservingUnrestrictedGrammar < SymbolType >::addRule ( std::vector < SymbolType > lContext, SymbolType leftHandSide, std::vector < SymbolType > rContext, std::vector < SymbolType > rightHandSide ) {
+ for ( const SymbolType & symbol : lContext )
+ if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
+ throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
+
+ if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
+ throw GrammarException ( "Rule must rewrite nonterminal symbol" );
+
+ for ( const SymbolType & symbol : rContext )
+ if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
+ throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
+
+ for ( const SymbolType & symbol : rightHandSide )
+ if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
+ throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
+
+ return rules[make_tuple ( std::move ( lContext ), std::move ( leftHandSide ), std::move ( rContext ) )].insert ( std::move ( rightHandSide ) ).second;
+}
+
+template < class SymbolType >
+const std::map < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > >, std::set < std::vector < SymbolType > > > & ContextPreservingUnrestrictedGrammar < SymbolType >::getRules ( ) const {
+ return rules;
+}
+
+template < class SymbolType >
+bool ContextPreservingUnrestrictedGrammar < SymbolType >::removeRule ( const std::vector < SymbolType > & lContext, const SymbolType & leftHandSide, const std::vector < SymbolType > & rContext, const std::vector < SymbolType > & rightHandSide ) {
+ return rules[make_tuple ( lContext, leftHandSide, rContext )].erase ( rightHandSide );
+}
+
+template < class SymbolType >
+int ContextPreservingUnrestrictedGrammar < SymbolType >::compare ( const ContextPreservingUnrestrictedGrammar & other ) const {
+ auto first = std::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
+ auto second = std::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
+
+ std::compare < decltype ( first ) > comp;
+
+ return comp ( first, second );
+}
+
+template < class SymbolType >
+void ContextPreservingUnrestrictedGrammar < SymbolType >::operator >>( std::ostream & out ) const {
+ out << "(ContextPreservingUnrestrictedGrammar "
+ << "nonterminalAlphabet = " << getNonterminalAlphabet ( )
+ << "terminalAlphabet = " << getTerminalAlphabet ( )
+ << "initialSymbol = " << getInitialSymbol ( )
+ << "rules = " << rules << ")";
+}
+
+template < class SymbolType >
+ContextPreservingUnrestrictedGrammar < SymbolType >::operator std::string ( ) const {
+ std::stringstream ss;
+ ss << * this;
+ return ss.str ( );
+}
+
+template < class SymbolType >
+ContextPreservingUnrestrictedGrammar < SymbolType > ContextPreservingUnrestrictedGrammar < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, ContextPreservingUnrestrictedGrammar::getXmlTagName() );
+
+ std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
+ std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
+ SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+
+ ContextPreservingUnrestrictedGrammar < SymbolType > grammar ( std::move ( initialSymbol ) );
+
+ grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
+ grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
+
+ GrammarFromXMLParser::parseRules ( input, grammar );
+
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, ContextPreservingUnrestrictedGrammar::getXmlTagName() );
+ return grammar;
+}
+
+template < class SymbolType >
+void ContextPreservingUnrestrictedGrammar < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, ContextPreservingUnrestrictedGrammar & grammar ) {
+ std::vector < SymbolType > lContext = GrammarFromXMLParser::parseRuleLContext ( input );
+ SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
+ std::vector < SymbolType > rContext = GrammarFromXMLParser::parseRuleRContext ( input );
+ std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+
+ grammar.addRule ( std::move ( lContext ), std::move ( lhs ), std::move ( rContext ), std::move ( rhs ) );
+}
+
+template < class SymbolType >
+void ContextPreservingUnrestrictedGrammar < SymbolType >::compose ( std::deque < sax::Token > & out ) const {
+ out.emplace_back ( ContextPreservingUnrestrictedGrammar::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
+
+ GrammarToXMLComposer::composeNonterminalAlphabet ( out, this->getNonterminalAlphabet ( ) );
+ GrammarToXMLComposer::composeTerminalAlphabet ( out, this->getTerminalAlphabet ( ) );
+ GrammarToXMLComposer::composeInitialSymbol ( out, this->getInitialSymbol ( ) );
+ composeRules ( out );
+
+ out.emplace_back ( ContextPreservingUnrestrictedGrammar::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
+}
+
+template < class SymbolType >
+void ContextPreservingUnrestrictedGrammar < SymbolType >::composeRules ( std::deque < sax::Token > & out ) const {
+ out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
+
+ for ( const auto & rule : this->getRules ( ) )
+
+ for ( const auto & rhs : rule.second ) {
+ out.emplace_back ( "rule", sax::Token::TokenType::START_ELEMENT );
+
+ GrammarToXMLComposer::composeRuleLContext ( out, std::get < 0 > ( rule.first ) );
+ GrammarToXMLComposer::composeRuleSingleSymbolLHS ( out, std::get < 1 > ( rule.first ) );
+ GrammarToXMLComposer::composeRuleRContext ( out, std::get < 2 > ( rule.first ) );
+ GrammarToXMLComposer::composeRuleRHS ( out, rhs );
+
+ out.emplace_back ( "rule", sax::Token::TokenType::END_ELEMENT );
+ }
+
+ out.emplace_back ( "rules", sax::Token::TokenType::END_ELEMENT );
+}
+
} /* namespace grammar */
namespace std {
-template < >
-class ComponentConstraint< grammar::ContextPreservingUnrestrictedGrammar, alphabet::Symbol, grammar::TerminalAlphabet > {
+template < class SymbolType >
+class ComponentConstraint< grammar::ContextPreservingUnrestrictedGrammar < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
public:
- static bool used ( const grammar::ContextPreservingUnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- for ( const std::pair < const std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > >, std::set < std::vector < alphabet::Symbol > > > & rule : grammar.getRules ( ) ) {
- for ( const alphabet::Symbol & lCont : std::get < 0 > ( rule.first ) )
+ static bool used ( const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & grammar, const SymbolType & symbol ) {
+ for ( const std::pair < const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > >, std::set < std::vector < SymbolType > > > & rule : grammar.getRules ( ) ) {
+ for ( const SymbolType & lCont : std::get < 0 > ( rule.first ) )
if ( lCont == symbol )
return true;
- for ( const alphabet::Symbol & rCont : std::get < 2 > ( rule.first ) )
+ for ( const SymbolType & rCont : std::get < 2 > ( rule.first ) )
if ( rCont == symbol )
return true;
- for ( const std::vector < alphabet::Symbol > & rhs : rule.second )
+ for ( const std::vector < SymbolType > & rhs : rule.second )
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
@@ -125,62 +268,62 @@ public:
return false;
}
- static bool available ( const grammar::ContextPreservingUnrestrictedGrammar &, const alphabet::Symbol & ) {
+ static bool available ( const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > &, const SymbolType & ) {
return true;
}
- static void valid ( const grammar::ContextPreservingUnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- if ( grammar.accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
+ static void valid ( const grammar::ContextPreservingUnrestrictedGrammar < 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" );
}
};
-template < >
-class ComponentConstraint< grammar::ContextPreservingUnrestrictedGrammar, alphabet::Symbol, grammar::NonterminalAlphabet > {
+template < class SymbolType >
+class ComponentConstraint< grammar::ContextPreservingUnrestrictedGrammar < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
public:
- static bool used ( const grammar::ContextPreservingUnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- for ( const std::pair < const std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > >, std::set < std::vector < alphabet::Symbol > > > & rule : grammar.getRules ( ) ) {
- for ( const alphabet::Symbol & lCont : std::get < 0 > ( rule.first ) )
+ static bool used ( const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & grammar, const SymbolType & symbol ) {
+ for ( const std::pair < const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > >, std::set < std::vector < SymbolType > > > & rule : grammar.getRules ( ) ) {
+ for ( const SymbolType & lCont : std::get < 0 > ( rule.first ) )
if ( lCont == symbol )
return true;
if ( std::get < 1 > ( rule.first ) == symbol )
return true;
- for ( const alphabet::Symbol & rCont : std::get < 2 > ( rule.first ) )
+ for ( const SymbolType & rCont : std::get < 2 > ( rule.first ) )
if ( rCont == symbol )
return true;
- for ( const std::vector < alphabet::Symbol > & rhs : rule.second )
+ for ( const std::vector < SymbolType > & rhs : rule.second )
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
}
- if ( grammar.accessElement < grammar::InitialSymbol > ( ).get ( ) == symbol )
+ if ( grammar.template accessElement < grammar::InitialSymbol > ( ).get ( ) == symbol )
return true;
return false;
}
- static bool available ( const grammar::ContextPreservingUnrestrictedGrammar &, const alphabet::Symbol & ) {
+ static bool available ( const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > &, const SymbolType & ) {
return true;
}
- static void valid ( const grammar::ContextPreservingUnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- if ( grammar.accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
+ static void valid ( const grammar::ContextPreservingUnrestrictedGrammar < 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" );
}
};
-template < >
-class ElementConstraint< grammar::ContextPreservingUnrestrictedGrammar, alphabet::Symbol, grammar::InitialSymbol > {
+template < class SymbolType >
+class ElementConstraint< grammar::ContextPreservingUnrestrictedGrammar < SymbolType >, SymbolType, grammar::InitialSymbol > {
public:
- static bool available ( const grammar::ContextPreservingUnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- return grammar.accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
+ static bool available ( const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > & grammar, const SymbolType & symbol ) {
+ return grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
}
- static void valid ( const grammar::ContextPreservingUnrestrictedGrammar &, const alphabet::Symbol & ) {
+ static void valid ( const grammar::ContextPreservingUnrestrictedGrammar < SymbolType > &, const SymbolType & ) {
}
};
diff --git a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.cpp b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.cpp
index a9f6bf77532bd7f07ace988e9983a7bd16567b6a..a9f70009f42aa08155471d725ed9ac94d105189e 100644
--- a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.cpp
+++ b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.cpp
@@ -6,140 +6,13 @@
*/
#include "UnrestrictedGrammar.h"
-#include <algorithm>
-#include <sstream>
-
-#include "../../alphabet/Symbol.h"
-
-#include <sax/FromXMLParserHelper.h>
-#include "../common/GrammarFromXMLParser.h"
-#include "../common/GrammarToXMLComposer.h"
#include "../Grammar.h"
#include <object/Object.h>
#include <XmlApi.hpp>
-namespace grammar {
-
-UnrestrictedGrammar::UnrestrictedGrammar ( alphabet::Symbol initialSymbol ) : UnrestrictedGrammar ( std::set < alphabet::Symbol > { initialSymbol }, std::set < alphabet::Symbol > ( ), initialSymbol ) {
-}
-
-UnrestrictedGrammar::UnrestrictedGrammar ( std::set < alphabet::Symbol > nonterminalAlphabet, std::set < alphabet::Symbol > terminalAlphabet, alphabet::Symbol initialSymbol ) : std::Components < UnrestrictedGrammar, alphabet::Symbol, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
-}
-
-GrammarBase * UnrestrictedGrammar::clone ( ) const {
- return new UnrestrictedGrammar ( * this );
-}
-
-GrammarBase * UnrestrictedGrammar::plunder ( ) && {
- return new UnrestrictedGrammar ( std::move ( * this ) );
-}
-
-bool UnrestrictedGrammar::addRule ( std::vector < alphabet::Symbol > leftHandSide, std::vector < alphabet::Symbol > rightHandSide ) {
- if ( std::all_of ( leftHandSide.begin ( ), leftHandSide.end ( ), [this] ( const alphabet::Symbol symbol ) {
- return !getNonterminalAlphabet ( ).count ( symbol );
- } ) )
- throw GrammarException ( "Rule must rewrite nonterminal symbol" );
-
- for ( const alphabet::Symbol & symbol : leftHandSide )
- if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
- throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
-
- for ( const alphabet::Symbol & symbol : rightHandSide )
- if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
- throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
-
- return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
-}
-
-const std::map < std::vector < alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > > & UnrestrictedGrammar::getRules ( ) const {
- return rules;
-}
-
-bool UnrestrictedGrammar::removeRule ( const std::vector < alphabet::Symbol > & leftHandSide, const std::vector < alphabet::Symbol > & rightHandSide ) {
- return rules[leftHandSide].erase ( rightHandSide );
-}
-
-int UnrestrictedGrammar::compare ( const UnrestrictedGrammar & other ) const {
- auto first = std::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
- auto second = std::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
-
- std::compare < decltype ( first ) > comp;
-
- return comp ( first, second );
-}
-
-void UnrestrictedGrammar::operator >>( std::ostream & out ) const {
- out << "(UnrestrictedGrammar "
- << "nonterminalAlphabet = " << getNonterminalAlphabet ( )
- << "terminalAlphabet = " << getTerminalAlphabet ( )
- << "initialSymbol = " << getInitialSymbol ( )
- << "rules = " << rules << ")";
-}
-
-UnrestrictedGrammar::operator std::string ( ) const {
- std::stringstream ss;
- ss << * this;
- return ss.str ( );
-}
-
-UnrestrictedGrammar UnrestrictedGrammar::parse ( std::deque < sax::Token >::iterator & input ) {
- sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, UnrestrictedGrammar::getXmlTagName() );
-
- std::set < alphabet::Symbol > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
- std::set < alphabet::Symbol > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
- alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
-
- UnrestrictedGrammar grammar ( std::move ( initialSymbol ) );
-
- grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
- grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
-
- GrammarFromXMLParser::parseRules ( input, grammar );
-
- sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, UnrestrictedGrammar::getXmlTagName() );
- return grammar;
-}
-
-void UnrestrictedGrammar::parseRule ( std::deque < sax::Token >::iterator & input, UnrestrictedGrammar & grammar ) {
- std::vector < alphabet::Symbol > lhs = GrammarFromXMLParser::parseRuleLHS ( input );
- std::vector < alphabet::Symbol > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
-
- grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
-}
-
-void UnrestrictedGrammar::compose ( std::deque < sax::Token > & out ) const {
- out.emplace_back ( UnrestrictedGrammar::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
-
- GrammarToXMLComposer::composeNonterminalAlphabet ( out, this->getNonterminalAlphabet ( ) );
- GrammarToXMLComposer::composeTerminalAlphabet ( out, this->getTerminalAlphabet ( ) );
- GrammarToXMLComposer::composeInitialSymbol ( out, this->getInitialSymbol ( ) );
- composeRules ( out );
-
- out.emplace_back ( UnrestrictedGrammar::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
-}
-
-void UnrestrictedGrammar::composeRules ( std::deque < sax::Token > & out ) const {
- out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
-
- for ( const auto & rule : this->getRules ( ) )
-
- for ( const auto & rhs : rule.second ) {
- out.emplace_back ( "rule", sax::Token::TokenType::START_ELEMENT );
-
- GrammarToXMLComposer::composeRuleLHS ( out, rule.first );
- GrammarToXMLComposer::composeRuleRHS ( out, rhs );
-
- out.emplace_back ( "rule", sax::Token::TokenType::END_ELEMENT );
- }
-
- out.emplace_back ( "rules", sax::Token::TokenType::END_ELEMENT );
-}
-
-} /* namespace grammar */
-
namespace alib {
-auto UnrestrictedGrammarParserRegister = xmlApi < grammar::Grammar >::ParserRegister < grammar::UnrestrictedGrammar > ( );
-auto UnrestrictedGrammarParserRegister2 = xmlApi < alib::Object >::ParserRegister < grammar::UnrestrictedGrammar > ( );
+auto UnrestrictedGrammarParserRegister = xmlApi < grammar::Grammar >::ParserRegister < grammar::UnrestrictedGrammar < > > ( );
+auto UnrestrictedGrammarParserRegister2 = xmlApi < alib::Object >::ParserRegister < grammar::UnrestrictedGrammar < > > ( );
} /* namespace alib */
diff --git a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
index dd37202da9c02e92247e9f54476e77bb504ab9c9..a907f91d0ce78654a48f5c00ea3c27747a253baf 100644
--- a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
@@ -8,12 +8,19 @@
#ifndef UNRESTRICTED_GRAMMAR_H_
#define UNRESTRICTED_GRAMMAR_H_
-#include "../GrammarException.h"
-#include "../GrammarBase.h"
#include <map>
#include <vector>
+#include <algorithm>
+#include <sstream>
+
#include <core/components.hpp>
-#include "../../alphabet/Symbol.h"
+#include <sax/FromXMLParserHelper.h>
+
+#include "../GrammarBase.h"
+#include "../GrammarFeatures.h"
+#include "../GrammarException.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
namespace grammar {
@@ -24,54 +31,55 @@ class TerminalAlphabet;
class NonterminalAlphabet;
class InitialSymbol;
-class UnrestrictedGrammar : public GrammarBase, public std::Components < UnrestrictedGrammar, alphabet::Symbol, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
- std::map < std::vector < alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > > rules;
+template < class SymbolType >
+class UnrestrictedGrammar : public GrammarBase, public std::Components < UnrestrictedGrammar < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+ std::map < std::vector < SymbolType >, std::set < std::vector < SymbolType > > > rules;
public:
- explicit UnrestrictedGrammar ( alphabet::Symbol initialSymbol );
+ explicit UnrestrictedGrammar ( SymbolType initialSymbol );
- explicit UnrestrictedGrammar ( std::set < alphabet::Symbol > nonTerminalSymbols, std::set < alphabet::Symbol > terminalSymbols, alphabet::Symbol initialSymbol );
+ explicit UnrestrictedGrammar ( std::set < SymbolType > nonTerminalSymbols, std::set < SymbolType > terminalSymbols, SymbolType initialSymbol );
virtual GrammarBase * clone ( ) const;
virtual GrammarBase * plunder ( ) &&;
- bool addRule ( std::vector < alphabet::Symbol > leftHandSide, std::vector < alphabet::Symbol > rightHandSide );
+ bool addRule ( std::vector < SymbolType > leftHandSide, std::vector < SymbolType > rightHandSide );
- const std::map < std::vector < alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > > & getRules ( ) const;
+ const std::map < std::vector < SymbolType >, std::set < std::vector < SymbolType > > > & getRules ( ) const;
- bool removeRule ( const std::vector < alphabet::Symbol > & leftHandSide, const std::vector < alphabet::Symbol > & rightHandSide );
+ bool removeRule ( const std::vector < SymbolType > & leftHandSide, const std::vector < SymbolType > & rightHandSide );
- const alphabet::Symbol & getInitialSymbol ( ) const {
- return accessElement < InitialSymbol > ( ).get ( );
+ const SymbolType & getInitialSymbol ( ) const {
+ return this->template accessElement < InitialSymbol > ( ).get ( );
}
- bool setInitialSymbol ( alphabet::Symbol symbol ) {
- return accessElement < InitialSymbol > ( ).set ( std::move ( symbol ) );
+ bool setInitialSymbol ( SymbolType symbol ) {
+ return this->template accessElement < InitialSymbol > ( ).set ( std::move ( symbol ) );
}
- const std::set < alphabet::Symbol > & getNonterminalAlphabet ( ) const {
- return accessComponent < NonterminalAlphabet > ( ).get ( );
+ const std::set < SymbolType > & getNonterminalAlphabet ( ) const {
+ return this->template accessComponent < NonterminalAlphabet > ( ).get ( );
}
- bool addNonterminalSymbol ( alphabet::Symbol symbol ) {
- return accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
+ bool addNonterminalSymbol ( SymbolType symbol ) {
+ return this->template accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
}
- void setNonterminalAlphabet ( std::set < alphabet::Symbol > symbols ) {
- accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
+ void setNonterminalAlphabet ( std::set < SymbolType > symbols ) {
+ this->template accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
}
- const std::set < alphabet::Symbol > & getTerminalAlphabet ( ) const {
- return accessComponent < TerminalAlphabet > ( ).get ( );
+ const std::set < SymbolType > & getTerminalAlphabet ( ) const {
+ return this->template accessComponent < TerminalAlphabet > ( ).get ( );
}
- bool addTerminalSymbol ( alphabet::Symbol symbol ) {
- return accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
+ bool addTerminalSymbol ( SymbolType symbol ) {
+ return this->template accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
}
- void setTerminalAlphabet ( std::set < alphabet::Symbol > symbols ) {
- accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
+ void setTerminalAlphabet ( std::set < SymbolType > symbols ) {
+ this->template accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
}
virtual int compare ( const ObjectBase & other ) const {
@@ -99,19 +107,148 @@ public:
void composeRules ( std::deque < sax::Token > & out ) const;
};
+template < class SymbolType >
+UnrestrictedGrammar < SymbolType >::UnrestrictedGrammar ( SymbolType initialSymbol ) : UnrestrictedGrammar ( std::set < SymbolType > { initialSymbol }, std::set < SymbolType > ( ), initialSymbol ) {
+}
+
+template < class SymbolType >
+UnrestrictedGrammar < SymbolType >::UnrestrictedGrammar ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < UnrestrictedGrammar, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
+}
+
+template < class SymbolType >
+GrammarBase * UnrestrictedGrammar < SymbolType >::clone ( ) const {
+ return new UnrestrictedGrammar ( * this );
+}
+
+template < class SymbolType >
+GrammarBase * UnrestrictedGrammar < SymbolType >::plunder ( ) && {
+ return new UnrestrictedGrammar ( std::move ( * this ) );
+}
+
+template < class SymbolType >
+bool UnrestrictedGrammar < SymbolType >::addRule ( std::vector < SymbolType > leftHandSide, std::vector < SymbolType > rightHandSide ) {
+ if ( std::all_of ( leftHandSide.begin ( ), leftHandSide.end ( ), [this] ( const SymbolType symbol ) {
+ return !getNonterminalAlphabet ( ).count ( symbol );
+ } ) )
+ throw GrammarException ( "Rule must rewrite nonterminal symbol" );
+
+ for ( const SymbolType & symbol : leftHandSide )
+ if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
+ throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
+
+ for ( const SymbolType & symbol : rightHandSide )
+ if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
+ throw GrammarException ( "Symbol \"" + std::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
+
+ return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
+}
+
+template < class SymbolType >
+const std::map < std::vector < SymbolType >, std::set < std::vector < SymbolType > > > & UnrestrictedGrammar < SymbolType >::getRules ( ) const {
+ return rules;
+}
+
+template < class SymbolType >
+bool UnrestrictedGrammar < SymbolType >::removeRule ( const std::vector < SymbolType > & leftHandSide, const std::vector < SymbolType > & rightHandSide ) {
+ return rules[leftHandSide].erase ( rightHandSide );
+}
+
+template < class SymbolType >
+int UnrestrictedGrammar < SymbolType >::compare ( const UnrestrictedGrammar & other ) const {
+ auto first = std::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
+ auto second = std::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
+
+ std::compare < decltype ( first ) > comp;
+
+ return comp ( first, second );
+}
+
+template < class SymbolType >
+void UnrestrictedGrammar < SymbolType >::operator >>( std::ostream & out ) const {
+ out << "(UnrestrictedGrammar "
+ << "nonterminalAlphabet = " << getNonterminalAlphabet ( )
+ << "terminalAlphabet = " << getTerminalAlphabet ( )
+ << "initialSymbol = " << getInitialSymbol ( )
+ << "rules = " << rules << ")";
+}
+
+template < class SymbolType >
+UnrestrictedGrammar < SymbolType >::operator std::string ( ) const {
+ std::stringstream ss;
+ ss << * this;
+ return ss.str ( );
+}
+
+template < class SymbolType >
+UnrestrictedGrammar < SymbolType > UnrestrictedGrammar < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, UnrestrictedGrammar::getXmlTagName() );
+
+ std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
+ std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
+ SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+
+ UnrestrictedGrammar < SymbolType > grammar ( std::move ( initialSymbol ) );
+
+ grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
+ grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
+
+ GrammarFromXMLParser::parseRules ( input, grammar );
+
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, UnrestrictedGrammar::getXmlTagName() );
+ return grammar;
+}
+
+template < class SymbolType >
+void UnrestrictedGrammar < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, UnrestrictedGrammar & grammar ) {
+ std::vector < SymbolType > lhs = GrammarFromXMLParser::parseRuleLHS ( input );
+ std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+
+ grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
+}
+
+template < class SymbolType >
+void UnrestrictedGrammar < SymbolType >::compose ( std::deque < sax::Token > & out ) const {
+ out.emplace_back ( UnrestrictedGrammar::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
+
+ GrammarToXMLComposer::composeNonterminalAlphabet ( out, this->getNonterminalAlphabet ( ) );
+ GrammarToXMLComposer::composeTerminalAlphabet ( out, this->getTerminalAlphabet ( ) );
+ GrammarToXMLComposer::composeInitialSymbol ( out, this->getInitialSymbol ( ) );
+ composeRules ( out );
+
+ out.emplace_back ( UnrestrictedGrammar::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
+}
+
+template < class SymbolType >
+void UnrestrictedGrammar < SymbolType >::composeRules ( std::deque < sax::Token > & out ) const {
+ out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
+
+ for ( const auto & rule : this->getRules ( ) )
+
+ for ( const auto & rhs : rule.second ) {
+ out.emplace_back ( "rule", sax::Token::TokenType::START_ELEMENT );
+
+ GrammarToXMLComposer::composeRuleLHS ( out, rule.first );
+ GrammarToXMLComposer::composeRuleRHS ( out, rhs );
+
+ out.emplace_back ( "rule", sax::Token::TokenType::END_ELEMENT );
+ }
+
+ out.emplace_back ( "rules", sax::Token::TokenType::END_ELEMENT );
+}
+
} /* namespace grammar */
namespace std {
-template < >
-class ComponentConstraint< grammar::UnrestrictedGrammar, alphabet::Symbol, grammar::TerminalAlphabet > {
+template < class SymbolType >
+class ComponentConstraint< grammar::UnrestrictedGrammar < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
public:
- static bool used ( const grammar::UnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- for ( const std::pair < const std::vector < alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > > & rule : grammar.getRules ( ) ) {
+ static bool used ( const grammar::UnrestrictedGrammar < SymbolType > & grammar, const SymbolType & symbol ) {
+ for ( const std::pair < const std::vector < SymbolType >, std::set < std::vector < SymbolType > > > & rule : grammar.getRules ( ) ) {
if ( std::find ( rule.first.begin ( ), rule.first.end ( ), symbol ) != rule.first.end ( ) )
return true;
- for ( const std::vector < alphabet::Symbol > & rhs : rule.second )
+ for ( const std::vector < SymbolType > & rhs : rule.second )
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
@@ -120,54 +257,54 @@ public:
return false;
}
- static bool available ( const grammar::UnrestrictedGrammar &, const alphabet::Symbol & ) {
+ static bool available ( const grammar::UnrestrictedGrammar < SymbolType > &, const SymbolType & ) {
return true;
}
- static void valid ( const grammar::UnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- if ( grammar.accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
+ static void valid ( const grammar::UnrestrictedGrammar < 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" );
}
};
-template < >
-class ComponentConstraint< grammar::UnrestrictedGrammar, alphabet::Symbol, grammar::NonterminalAlphabet > {
+template < class SymbolType >
+class ComponentConstraint< grammar::UnrestrictedGrammar < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
public:
- static bool used ( const grammar::UnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- for ( const std::pair < const std::vector < alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > > & rule : grammar.getRules ( ) ) {
+ static bool used ( const grammar::UnrestrictedGrammar < SymbolType > & grammar, const SymbolType & symbol ) {
+ for ( const std::pair < const std::vector < SymbolType >, std::set < std::vector < SymbolType > > > & rule : grammar.getRules ( ) ) {
if ( std::find ( rule.first.begin ( ), rule.first.end ( ), symbol ) != rule.first.end ( ) )
return true;
- for ( const std::vector < alphabet::Symbol > & rhs : rule.second )
+ for ( const std::vector < SymbolType > & rhs : rule.second )
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
}
- if ( grammar.accessElement < grammar::InitialSymbol > ( ).get ( ) == symbol )
+ if ( grammar.template accessElement < grammar::InitialSymbol > ( ).get ( ) == symbol )
return true;
return false;
}
- static bool available ( const grammar::UnrestrictedGrammar &, const alphabet::Symbol & ) {
+ static bool available ( const grammar::UnrestrictedGrammar < SymbolType > &, const SymbolType & ) {
return true;
}
- static void valid ( const grammar::UnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- if ( grammar.accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
+ static void valid ( const grammar::UnrestrictedGrammar < 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" );
}
};
-template < >
-class ElementConstraint< grammar::UnrestrictedGrammar, alphabet::Symbol, grammar::InitialSymbol > {
+template < class SymbolType >
+class ElementConstraint< grammar::UnrestrictedGrammar < SymbolType >, SymbolType, grammar::InitialSymbol > {
public:
- static bool available ( const grammar::UnrestrictedGrammar & grammar, const alphabet::Symbol & symbol ) {
- return grammar.accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
+ static bool available ( const grammar::UnrestrictedGrammar < SymbolType > & grammar, const SymbolType & symbol ) {
+ return grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
}
- static void valid ( const grammar::UnrestrictedGrammar &, const alphabet::Symbol & ) {
+ static void valid ( const grammar::UnrestrictedGrammar < SymbolType > &, const SymbolType & ) {
}
};
diff --git a/alib2data/test-src/grammar/GrammarTest.cpp b/alib2data/test-src/grammar/GrammarTest.cpp
index e8495252fa58ce3dc17fcaf114a3458d78d3e2e5..118d5f8adf5a7411a536db47f632b55a84524e90 100644
--- a/alib2data/test-src/grammar/GrammarTest.cpp
+++ b/alib2data/test-src/grammar/GrammarTest.cpp
@@ -35,36 +35,37 @@ void GrammarTest::tearDown() {
}
void GrammarTest::testUnrestrictedParser() {
- grammar::UnrestrictedGrammar grammar(alphabet::symbolFrom(1));
-
- grammar.addNonterminalSymbol(alphabet::symbolFrom(1));
- grammar.addNonterminalSymbol(alphabet::symbolFrom(2));
- grammar.addNonterminalSymbol(alphabet::symbolFrom(3));
- grammar.addTerminalSymbol(alphabet::symbolFrom("a"));
- grammar.addTerminalSymbol(alphabet::symbolFrom("b"));
-
- grammar.addRule({alphabet::symbolFrom(1)}, {alphabet::symbolFrom("a"), alphabet::symbolFrom(2)});
- grammar.addRule({alphabet::symbolFrom(2)}, {alphabet::symbolFrom("b"), alphabet::symbolFrom(3)});
- grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(2), alphabet::symbolFrom(2)}, std::vector<alphabet::Symbol> {alphabet::symbolFrom("a"), alphabet::symbolFrom(2)});
- grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(2)}, std::vector<alphabet::Symbol> {alphabet::symbolFrom("b"), alphabet::symbolFrom(3)});
- grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(1)}, std::vector<alphabet::Symbol> {alphabet::symbolFrom(3)});
- grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(1)}, std::vector<alphabet::Symbol> {alphabet::symbolFrom("a"), alphabet::symbolFrom("a"), alphabet::symbolFrom("a"), alphabet::symbolFrom(2)});
- grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(2)}, std::vector<alphabet::Symbol> {});
-
- CPPUNIT_ASSERT( grammar == grammar );
{
+ grammar::UnrestrictedGrammar < > grammar(alphabet::symbolFrom(1));
+
+ grammar.addNonterminalSymbol(alphabet::symbolFrom(1));
+ grammar.addNonterminalSymbol(alphabet::symbolFrom(2));
+ grammar.addNonterminalSymbol(alphabet::symbolFrom(3));
+ grammar.addTerminalSymbol(alphabet::symbolFrom("a"));
+ grammar.addTerminalSymbol(alphabet::symbolFrom("b"));
+
+ grammar.addRule({alphabet::symbolFrom(1)}, {alphabet::symbolFrom("a"), alphabet::symbolFrom(2)});
+ grammar.addRule({alphabet::symbolFrom(2)}, {alphabet::symbolFrom("b"), alphabet::symbolFrom(3)});
+ grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(2), alphabet::symbolFrom(2)}, std::vector<alphabet::Symbol> {alphabet::symbolFrom("a"), alphabet::symbolFrom(2)});
+ grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(2)}, std::vector<alphabet::Symbol> {alphabet::symbolFrom("b"), alphabet::symbolFrom(3)});
+ grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(1)}, std::vector<alphabet::Symbol> {alphabet::symbolFrom(3)});
+ grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(1)}, std::vector<alphabet::Symbol> {alphabet::symbolFrom("a"), alphabet::symbolFrom("a"), alphabet::symbolFrom("a"), alphabet::symbolFrom(2)});
+ grammar.addRule(std::vector<alphabet::Symbol> {alphabet::symbolFrom(2)}, std::vector<alphabet::Symbol> {});
+
+ CPPUNIT_ASSERT( grammar == grammar );
+
std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
std::string tmp;
sax::SaxComposeInterface::printMemory(tmp, tokens);
std::deque<sax::Token> tokens2;
sax::SaxParseInterface::parseMemory(tmp, tokens2);
- grammar::UnrestrictedGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::UnrestrictedGrammar>(std::move(tokens2));
+ grammar::UnrestrictedGrammar < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::UnrestrictedGrammar < > >(std::move(tokens2));
CPPUNIT_ASSERT( grammar == grammar2 );
}
{
- grammar::ContextPreservingUnrestrictedGrammar grammar(alphabet::symbolFrom(1));
+ grammar::ContextPreservingUnrestrictedGrammar < > grammar(alphabet::symbolFrom(1));
grammar.addNonterminalSymbol(alphabet::symbolFrom(1));
grammar.addNonterminalSymbol(alphabet::symbolFrom(2));
@@ -77,18 +78,18 @@ void GrammarTest::testUnrestrictedParser() {
grammar.addRule(std::vector<alphabet::Symbol> {}, alphabet::symbolFrom(1), std::vector<alphabet::Symbol> {}, std::vector<alphabet::Symbol> {alphabet::symbolFrom(3)});
grammar.addRule(std::vector<alphabet::Symbol> {}, alphabet::symbolFrom(1), std::vector<alphabet::Symbol> {}, std::vector<alphabet::Symbol> {alphabet::symbolFrom("a"), alphabet::symbolFrom("a"), alphabet::symbolFrom("a"), alphabet::symbolFrom(2)});
grammar.addRule(std::vector<alphabet::Symbol> {}, alphabet::symbolFrom(2), std::vector<alphabet::Symbol> {}, std::vector<alphabet::Symbol> {});
+
CPPUNIT_ASSERT( grammar == grammar );
- {
- std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
- std::string tmp;
- sax::SaxComposeInterface::printMemory(tmp, tokens);
- std::deque<sax::Token> tokens2;
- sax::SaxParseInterface::parseMemory(tmp, tokens2);
- grammar::ContextPreservingUnrestrictedGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::ContextPreservingUnrestrictedGrammar>(std::move(tokens2));
+ std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(grammar);
+ std::string tmp;
+ sax::SaxComposeInterface::printMemory(tmp, tokens);
- CPPUNIT_ASSERT( grammar == grammar2 );
- }
+ std::deque<sax::Token> tokens2;
+ sax::SaxParseInterface::parseMemory(tmp, tokens2);
+ grammar::ContextPreservingUnrestrictedGrammar < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::ContextPreservingUnrestrictedGrammar < > >(std::move(tokens2));
+
+ CPPUNIT_ASSERT( grammar == grammar2 );
}
}
diff --git a/alib2str/src/grammar/GrammarFromStringParser.cpp b/alib2str/src/grammar/GrammarFromStringParser.cpp
index 4aea27dbb64b529dd7f343b05e99d7f19b233c4e..aa352b1c0882f9acad6e31a730b94ac44cda4d5a 100644
--- a/alib2str/src/grammar/GrammarFromStringParser.cpp
+++ b/alib2str/src/grammar/GrammarFromStringParser.cpp
@@ -548,22 +548,22 @@ CSG < > GrammarFromStringParser::parseCSG(std::istream& input) const {
return parsePreservingCSLikeGrammar< CSG < > >(input);
}
-ContextPreservingUnrestrictedGrammar GrammarFromStringParser::parseContextPreservingUnrestrictedGrammar(std::istream& input) const {
+ContextPreservingUnrestrictedGrammar < > GrammarFromStringParser::parseContextPreservingUnrestrictedGrammar(std::istream& input) const {
GrammarFromStringLexer::Token token = m_GrammarLexer.next(input);
if(token.type != GrammarFromStringLexer::TokenType::CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR) {
throw exception::CommonException("Unrecognised ContextPreservingUnrestrictedGrammar token.");
}
- return parsePreservingCSLikeGrammar<ContextPreservingUnrestrictedGrammar>(input);
+ return parsePreservingCSLikeGrammar<ContextPreservingUnrestrictedGrammar < > >(input);
}
-UnrestrictedGrammar GrammarFromStringParser::parseUnrestrictedGrammar(std::istream& input) const {
+UnrestrictedGrammar < > GrammarFromStringParser::parseUnrestrictedGrammar(std::istream& input) const {
GrammarFromStringLexer::Token token = m_GrammarLexer.next(input);
if(token.type != GrammarFromStringLexer::TokenType::UNRESTRICTED_GRAMMAR) {
throw exception::CommonException("Unrecognised UnrestrictedGrammar token.");
}
- return parseCSLikeGrammar<UnrestrictedGrammar>(input);
+ return parseCSLikeGrammar<UnrestrictedGrammar < > >(input);
}
} /* namespace grammar */
diff --git a/alib2str/src/grammar/GrammarFromStringParser.h b/alib2str/src/grammar/GrammarFromStringParser.h
index 6c452befaa679e120272ba5a1b5d6ffb3daa3885..1f5454b6b587051908d87873bc857e7d0ba7f27a 100644
--- a/alib2str/src/grammar/GrammarFromStringParser.h
+++ b/alib2str/src/grammar/GrammarFromStringParser.h
@@ -58,8 +58,8 @@ private:
NonContractingGrammar < > parseNonContractingGrammar(std::istream& input) const;
CSG < > parseCSG(std::istream& input) const;
- ContextPreservingUnrestrictedGrammar parseContextPreservingUnrestrictedGrammar(std::istream& input) const;
- UnrestrictedGrammar parseUnrestrictedGrammar(std::istream& input) const;
+ ContextPreservingUnrestrictedGrammar < > parseContextPreservingUnrestrictedGrammar(std::istream& input) const;
+ UnrestrictedGrammar < > parseUnrestrictedGrammar(std::istream& input) const;
template<typename T> friend struct alib::stringApi;
};
diff --git a/alib2str/src/grammar/GrammarToStringComposer.cpp b/alib2str/src/grammar/GrammarToStringComposer.cpp
index 1c95721982b99e54555f2dd4da74b4bd49f2dc1e..ced274a23b47bcc71c49407d1350140135264bbc 100644
--- a/alib2str/src/grammar/GrammarToStringComposer.cpp
+++ b/alib2str/src/grammar/GrammarToStringComposer.cpp
@@ -261,18 +261,18 @@ void GrammarToStringComposer::compose(std::ostream& output, const NonContracting
GrammarToStringComposer::RegistratorWrapper<void, NonContractingGrammar < > > GrammarToStringComposerNonContractingGrammar = GrammarToStringComposer::RegistratorWrapper<void, NonContractingGrammar < > >(GrammarToStringComposer::compose);
-void GrammarToStringComposer::compose(std::ostream& output, const ContextPreservingUnrestrictedGrammar& grammar) {
+void GrammarToStringComposer::compose(std::ostream& output, const ContextPreservingUnrestrictedGrammar < > & grammar) {
output << "CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR";
composePreservingCSLikeGrammar(output, grammar);
}
-GrammarToStringComposer::RegistratorWrapper<void, ContextPreservingUnrestrictedGrammar> GrammarToStringComposerContextPreservingUnrestructedGrammar = GrammarToStringComposer::RegistratorWrapper<void, ContextPreservingUnrestrictedGrammar>(GrammarToStringComposer::compose);
+GrammarToStringComposer::RegistratorWrapper<void, ContextPreservingUnrestrictedGrammar < > > GrammarToStringComposerContextPreservingUnrestructedGrammar = GrammarToStringComposer::RegistratorWrapper<void, ContextPreservingUnrestrictedGrammar < > >(GrammarToStringComposer::compose);
-void GrammarToStringComposer::compose(std::ostream& output, const UnrestrictedGrammar& grammar) {
+void GrammarToStringComposer::compose(std::ostream& output, const UnrestrictedGrammar < > & grammar) {
output << "UNRESTRICTED_GRAMMAR";
composeCSLikeGrammar(output, grammar);
}
-GrammarToStringComposer::RegistratorWrapper<void, UnrestrictedGrammar> GrammarToStringComposerUnrestructedGrammar = GrammarToStringComposer::RegistratorWrapper<void, UnrestrictedGrammar>(GrammarToStringComposer::compose);
+GrammarToStringComposer::RegistratorWrapper<void, UnrestrictedGrammar < > > GrammarToStringComposerUnrestructedGrammar = GrammarToStringComposer::RegistratorWrapper<void, UnrestrictedGrammar < > >(GrammarToStringComposer::compose);
}
diff --git a/alib2str/src/grammar/GrammarToStringComposer.h b/alib2str/src/grammar/GrammarToStringComposer.h
index 216dc73034fbba67de267f067f6ef1fcf100d382..d61fc55affc9d14623c774dbba2cd845f2d0fcd0 100644
--- a/alib2str/src/grammar/GrammarToStringComposer.h
+++ b/alib2str/src/grammar/GrammarToStringComposer.h
@@ -35,8 +35,8 @@ public:
static void compose(std::ostream& output, const GNF < > & grammar);
static void compose(std::ostream& output, const CSG < > & grammar);
static void compose(std::ostream& output, const NonContractingGrammar < > & grammar);
- static void compose(std::ostream& output, const ContextPreservingUnrestrictedGrammar& grammar);
- static void compose(std::ostream& output, const UnrestrictedGrammar& grammar);
+ static void compose(std::ostream& output, const ContextPreservingUnrestrictedGrammar < > & grammar);
+ static void compose(std::ostream& output, const UnrestrictedGrammar < > & grammar);
};
}