From a2744e4f4791badbff3c698152567e9de014397b Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Mon, 14 Mar 2016 11:35:01 +0100
Subject: [PATCH] add RankedNonlinearPattern
---
.../common/RankedNonlinearPatternAlphabet.cpp | 60 ++++++
.../common/RankedNonlinearPatternAlphabet.h | 59 ++++++
.../src/tree/common/TreeFromXMLParser.cpp | 22 +++
alib2data/src/tree/common/TreeFromXMLParser.h | 5 +
.../src/tree/common/TreeToXMLComposer.cpp | 18 ++
alib2data/src/tree/common/TreeToXMLComposer.h | 3 +
alib2data/src/tree/ranked/RankedNode.h | 1 +
.../tree/ranked/RankedNonlinearPattern.cpp | 179 ++++++++++++++++++
.../src/tree/ranked/RankedNonlinearPattern.h | 126 ++++++++++++
9 files changed, 473 insertions(+)
create mode 100644 alib2data/src/tree/common/RankedNonlinearPatternAlphabet.cpp
create mode 100644 alib2data/src/tree/common/RankedNonlinearPatternAlphabet.h
create mode 100644 alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
create mode 100644 alib2data/src/tree/ranked/RankedNonlinearPattern.h
diff --git a/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.cpp b/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.cpp
new file mode 100644
index 0000000000..a57e7db2d4
--- /dev/null
+++ b/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.cpp
@@ -0,0 +1,60 @@
+/*
+ * RankedNonlinearAlphabet.cpp
+ *
+ * Created on: Mar 13, 2016
+ * Author: Jan Travnicek
+ */
+
+#include "RankedNonlinearPatternAlphabet.h"
+#include "../TreeException.h"
+
+#include <algorithm>
+
+namespace tree {
+
+RankedNonlinearPatternAlphabet::RankedNonlinearPatternAlphabet(alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> nonlinearVariables) : RankedPatternAlphabet(subtreeWildcard), nonlinearVariables(nonlinearVariables) {
+ for(const alphabet::RankedSymbol& symbol : nonlinearVariables) {
+ if(symbol.getRank().getData() != 0)
+ throw TreeException("Subtree wildcard symbol " + (std::string) symbol + " has nonzero rank");
+ }
+ alphabet.insert(std::move(subtreeWildcard));
+}
+
+bool RankedNonlinearPatternAlphabet::addNonlinearVariable(alphabet::RankedSymbol symbol) {
+ if (!alphabet.count(symbol))
+ throw TreeException("Subtree wildcard symbol \"" + (std::string) symbol + "\" is not in the alphabet.");
+
+ if(symbol.getRank().getData() != 0)
+ throw TreeException("Subtree wildcard symbol " + (std::string) symbol + " has nonzero rank");
+
+ return nonlinearVariables.insert(symbol).second;
+
+}
+
+void RankedNonlinearPatternAlphabet::addNonlinearVariables(std::set<alphabet::RankedSymbol> symbols) {
+ for(alphabet::RankedSymbol addedSymbol : std::move(symbols)) {
+ addSymbolToAlphabet(std::move(addedSymbol));
+ }
+}
+
+void RankedNonlinearPatternAlphabet::setNonlinearVariables(std::set<alphabet::RankedSymbol> newSymbols) {
+ std::set<alphabet::RankedSymbol> removed;
+ std::set_difference(nonlinearVariables.begin(), nonlinearVariables.end(), newSymbols.begin(), newSymbols.end(), std::inserter(removed, removed.end()));
+
+ for(const alphabet::RankedSymbol& removedSymbol : removed) {
+ removeNonlinearVariable(removedSymbol);
+ }
+
+ alphabet = std::move(newSymbols);
+}
+
+const std::set<alphabet::RankedSymbol>& RankedNonlinearPatternAlphabet::getNonlinearVariables() const {
+ return nonlinearVariables;
+}
+
+bool RankedNonlinearPatternAlphabet::removeNonlinearVariable(const alphabet::RankedSymbol& symbol) {
+ return alphabet.insert(std::move(symbol)).second;
+}
+
+} /* namespace tree */
+
diff --git a/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.h b/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.h
new file mode 100644
index 0000000000..61134e7ab2
--- /dev/null
+++ b/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.h
@@ -0,0 +1,59 @@
+/*
+ * RankedNonlinearPatternAlphabet.h
+ *
+ * Created on: Mar 13, 2016
+ * Author: Jan Travnicek
+ */
+
+#ifndef RANKED_NONLINEAR_PATTERN_ALPHABET_H_
+#define RANKED_NONLINEAR_PATTERN_ALPHABET_H_
+
+#include "RankedPatternAlphabet.h"
+
+namespace tree {
+
+/**
+ * Abstract base class for all strings. Contains common elements of strings.
+ */
+class RankedNonlinearPatternAlphabet : public RankedPatternAlphabet {
+protected:
+ std::set<alphabet::RankedSymbol> nonlinearVariables;
+
+public:
+ RankedNonlinearPatternAlphabet(alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> nonlinearVariables);
+
+ /**
+ * Adds the nonlinear variable = symbol representing subtree substitution place in the pattern
+ * @param symbol Symbol to set
+ */
+ bool addNonlinearVariable(alphabet::RankedSymbol symbol);
+
+ /**
+ * Adds the nonlinear variables = symbols representing subtree substitution place in the pattern
+ * @param symbol Symbol to set
+ */
+ void addNonlinearVariables(std::set<alphabet::RankedSymbol> symbols);
+
+ /**
+ * Sets the nonlinear variables = symbol representing subtree substitution place in the pattern
+ * @param symbol Symbol to set
+ */
+ void setNonlinearVariables(std::set<alphabet::RankedSymbol> symbols);
+
+ /**
+ * @return symbols representing nonlinear variables
+ */
+ const std::set<alphabet::RankedSymbol> & getNonlinearVariables() const;
+
+ /**
+ * Removes the nonlinear variable = symbol representing subtree substitution place in the pattern
+ * @param symbol Symbol to set
+ */
+ bool removeNonlinearVariable(const alphabet::RankedSymbol& symbol);
+
+};
+
+} /* namespace tree */
+
+#endif /* RANKED_NONLINEAR_PATTERN_ALPHABET_H_ */
+
diff --git a/alib2data/src/tree/common/TreeFromXMLParser.cpp b/alib2data/src/tree/common/TreeFromXMLParser.cpp
index 3ae21204f7..3b42f2b95c 100644
--- a/alib2data/src/tree/common/TreeFromXMLParser.cpp
+++ b/alib2data/src/tree/common/TreeFromXMLParser.cpp
@@ -117,4 +117,26 @@ UnrankedNode * TreeFromXMLParser::parseUnrankedNode ( std::deque < sax::Token >:
return new UnrankedNode ( symbol, children );
}
+std::set < alphabet::RankedSymbol > TreeFromXMLParser::parseRankedNonlinearVariables ( std::deque < sax::Token >::iterator & input ) {
+ std::set < alphabet::RankedSymbol > rankedSymbols;
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "rankedNonlinearVariables" );
+
+ while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
+ rankedSymbols.insert ( alib::xmlApi < alphabet::RankedSymbol >::parse ( input ) );
+
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "rankedNonlinearVariables" );
+ return rankedSymbols;
+}
+
+std::set < alphabet::Symbol > TreeFromXMLParser::parseUnrankedNonlinearVariables ( std::deque < sax::Token >::iterator & input ) {
+ std::set < alphabet::Symbol > symbols;
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "nonlinearVariables" );
+
+ while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
+ symbols.insert ( alib::xmlApi < alphabet::Symbol >::parse ( input ) );
+
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "nonlinearVariables" );
+ return symbols;
+}
+
} /* namespace tree */
diff --git a/alib2data/src/tree/common/TreeFromXMLParser.h b/alib2data/src/tree/common/TreeFromXMLParser.h
index 3a0b174d8e..400758941e 100644
--- a/alib2data/src/tree/common/TreeFromXMLParser.h
+++ b/alib2data/src/tree/common/TreeFromXMLParser.h
@@ -26,8 +26,10 @@ class TreeFromXMLParser {
public:
static RankedNode * parseRankedNode ( std::deque < sax::Token >::iterator & input );
static UnrankedNode * parseUnrankedNode ( std::deque < sax::Token >::iterator & input );
+
static std::vector < alphabet::RankedSymbol > parseRankedContent ( std::deque < sax::Token >::iterator & input );
static std::vector < alphabet::Symbol > parseUnrankedContent ( std::deque < sax::Token >::iterator & input );
+
static std::set < alphabet::RankedSymbol > parseRankedAlphabet ( std::deque < sax::Token >::iterator & input );
static std::set < alphabet::Symbol > parseUnrankedAlphabet ( std::deque < sax::Token >::iterator & input );
@@ -36,6 +38,9 @@ public:
static alphabet::Symbol parseSubtreeWildcardSymbol ( std::deque < sax::Token >::iterator & input );
static alphabet::RankedSymbol parseSubtreeWildcardRankedSymbol ( std::deque < sax::Token >::iterator & input );
+
+ static std::set < alphabet::RankedSymbol > parseRankedNonlinearVariables ( std::deque < sax::Token >::iterator & input );
+ static std::set < alphabet::Symbol > parseUnrankedNonlinearVariables ( std::deque < sax::Token >::iterator & input );
};
} /* namespace tree */
diff --git a/alib2data/src/tree/common/TreeToXMLComposer.cpp b/alib2data/src/tree/common/TreeToXMLComposer.cpp
index b0bec827c0..89bee9d20f 100644
--- a/alib2data/src/tree/common/TreeToXMLComposer.cpp
+++ b/alib2data/src/tree/common/TreeToXMLComposer.cpp
@@ -90,4 +90,22 @@ void TreeToXMLComposer::composeContent ( std::deque < sax::Token > & out, const
out.emplace_back ( "content", sax::Token::TokenType::END_ELEMENT );
}
+void TreeToXMLComposer::composeNonlinearVariables ( std::deque < sax::Token > & out, const std::set < alphabet::RankedSymbol > & symbols ) {
+ out.emplace_back ( sax::Token ( "rankedNonlinearVariables", sax::Token::TokenType::START_ELEMENT ) );
+
+ for ( const auto & symbol : symbols )
+ alib::xmlApi < alphabet::RankedSymbol >::compose ( out, symbol );
+
+ out.emplace_back ( sax::Token ( "rankedNonlinearVariables", sax::Token::TokenType::END_ELEMENT ) );
+}
+
+void TreeToXMLComposer::composeNonlinearVariables ( std::deque < sax::Token > & out, const std::set < alphabet::Symbol > & symbols ) {
+ out.emplace_back ( sax::Token ( "nonlinearVariables", sax::Token::TokenType::START_ELEMENT ) );
+
+ for ( const auto & symbol : symbols )
+ alib::xmlApi < alphabet::Symbol >::compose ( out, symbol );
+
+ out.emplace_back ( sax::Token ( "nonlinearVariables", sax::Token::TokenType::END_ELEMENT ) );
+}
+
} /* namespace tree */
diff --git a/alib2data/src/tree/common/TreeToXMLComposer.h b/alib2data/src/tree/common/TreeToXMLComposer.h
index 8629a79ccd..8fc8e13322 100644
--- a/alib2data/src/tree/common/TreeToXMLComposer.h
+++ b/alib2data/src/tree/common/TreeToXMLComposer.h
@@ -37,6 +37,9 @@ public:
static void composeContent(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& content);
static void composeContent(std::deque<sax::Token>& out, const std::vector<alphabet::RankedSymbol>& content);
+
+ static void composeNonlinearVariables(std::deque<sax::Token>& out, const std::set<alphabet::RankedSymbol>& symbols);
+ static void composeNonlinearVariables(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols);
};
} /* namespace tree */
diff --git a/alib2data/src/tree/ranked/RankedNode.h b/alib2data/src/tree/ranked/RankedNode.h
index 99569f1acd..9303af9ec1 100644
--- a/alib2data/src/tree/ranked/RankedNode.h
+++ b/alib2data/src/tree/ranked/RankedNode.h
@@ -113,6 +113,7 @@ public:
friend class UnrankedPattern;
friend class RankedTree;
friend class RankedPattern;
+ friend class RankedNonlinearPattern;
};
} /* namespace tree */
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp b/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
new file mode 100644
index 0000000000..c126dcc1c0
--- /dev/null
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
@@ -0,0 +1,179 @@
+/*
+ * RankedNonlinearPattern.cpp
+ *
+ * Created on: Nov 23, 2013
+ * Author: Jan Travnicek
+ */
+
+#include "RankedNonlinearPattern.h"
+#include <exception/AlibException.h>
+
+#include <iostream>
+#include <algorithm>
+#include <sstream>
+
+#include "../unranked/UnrankedPattern.h"
+
+#include <sax/FromXMLParserHelper.h>
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../RankedTreeWrapper.h"
+#include <object/Object.h>
+#include <XmlApi.hpp>
+#include <cast/CastApi.hpp>
+
+namespace tree {
+
+RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern ) : RankedNonlinearPatternAlphabet ( std::move ( subtreeWildcard ), std::move(nonlinearVariables) ) {
+ setAlphabet ( std::move ( alphabet ) );
+ this->pattern = NULL;
+ setTree ( std::move ( pattern ) );
+}
+
+RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, RankedNode pattern ) : RankedNonlinearPatternAlphabet ( std::move ( subtreeWildcard ), {} ) {
+ pattern.computeMinimalAlphabet ( alphabet );
+ this->pattern = NULL;
+ setTree ( std::move ( pattern ) );
+}
+
+RankedNonlinearPattern::RankedNonlinearPattern ( const RankedNonlinearPattern & other ) : RankedNonlinearPatternAlphabet ( other ), pattern ( other.pattern->clone ( ) ) {
+ this->pattern->attachTree ( this );
+}
+
+RankedNonlinearPattern::RankedNonlinearPattern ( RankedNonlinearPattern && other ) noexcept : RankedNonlinearPatternAlphabet ( other ), pattern ( other.pattern ) {
+ this->pattern->attachTree ( this );
+ other.pattern = NULL;
+}
+
+RankedTreeBase * RankedNonlinearPattern::clone ( ) const {
+ return new RankedNonlinearPattern ( * this );
+}
+
+RankedTreeBase * RankedNonlinearPattern::plunder ( ) && {
+ return new RankedNonlinearPattern ( std::move ( * this ) );
+}
+
+RankedNonlinearPattern & RankedNonlinearPattern::operator =( const RankedNonlinearPattern & other ) {
+ if ( this == & other )
+ return * this;
+
+ * this = RankedNonlinearPattern ( other );
+
+ return * this;
+}
+
+RankedNonlinearPattern & RankedNonlinearPattern::operator =( RankedNonlinearPattern && other ) noexcept {
+ std::swap ( this->pattern, other.pattern );
+ std::swap ( this->alphabet, other.alphabet );
+ std::swap ( this->subtreeWildcard, other.subtreeWildcard );
+ std::swap ( this->nonlinearVariables, other.nonlinearVariables );
+
+ return * this;
+}
+
+RankedNonlinearPattern::~RankedNonlinearPattern ( ) noexcept {
+ delete pattern;
+}
+
+const RankedNode & RankedNonlinearPattern::getRoot ( ) const {
+ return * pattern;
+}
+
+RankedNode & RankedNonlinearPattern::getRoot ( ) {
+ return * pattern;
+}
+
+void RankedNonlinearPattern::setTree ( RankedNode pattern ) {
+ delete this->pattern;
+ this->pattern = std::move ( pattern ).plunder ( );
+
+ if ( !this->pattern->attachTree ( this ) ) {
+ delete this->pattern;
+ throw exception::AlibException ( "Input symbols not in the alphabet." );
+ }
+}
+
+bool RankedNonlinearPattern::removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol ) {
+ if ( this->pattern->testSymbol ( symbol ) )
+ throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
+
+ if ( this->subtreeWildcard == symbol )
+ throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is subtreeWildcard." );
+
+ if ( std::any_of(this->nonlinearVariables.begin(), this->nonlinearVariables.end(), [&](const alphabet::RankedSymbol& nonlinearVariable) {
+ return nonlinearVariable == symbol;
+ } ) )
+ throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is nonlinearVariable." );
+
+ return alphabet.erase ( symbol );
+}
+
+void RankedNonlinearPattern::operator >>( std::ostream & out ) const {
+ out << "(RankedNonlinearPattern " << * ( this->pattern ) << ")";
+}
+
+int RankedNonlinearPattern::compare ( const RankedNonlinearPattern & other ) const {
+ int res = pattern->compare ( * other.pattern );
+
+ if ( res == 0 ) {
+ std::compare < alphabet::RankedSymbol > comp;
+ res = comp ( subtreeWildcard, other.subtreeWildcard );
+ }
+
+ if ( res == 0 ) {
+ std::compare < std::set < alphabet::RankedSymbol > > comp;
+ res = comp ( nonlinearVariables, other.nonlinearVariables );
+ }
+
+ if ( res == 0 ) {
+ std::compare < std::set < alphabet::RankedSymbol > > comp;
+ res = comp ( alphabet, other.alphabet );
+ }
+
+ return res;
+}
+
+void RankedNonlinearPattern::nicePrint ( std::ostream & os ) const {
+ pattern->nicePrint ( os );
+}
+
+RankedNonlinearPattern::operator std::string ( ) const {
+ std::stringstream ss;
+ ss << * this;
+ return ss.str ( );
+}
+
+const std::string RankedNonlinearPattern::XML_TAG_NAME = "RankedNonlinearPattern";
+
+RankedNonlinearPattern RankedNonlinearPattern::parse ( std::deque < sax::Token >::iterator & input ) {
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, RankedNonlinearPattern::XML_TAG_NAME );
+ alphabet::RankedSymbol subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardRankedSymbol ( input );
+ std::set < alphabet::RankedSymbol > nonlinearVariables = TreeFromXMLParser::parseRankedNonlinearVariables ( input );
+ std::set < alphabet::RankedSymbol > rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet ( input );
+ RankedNode * root = alib::xmlApi < RankedNode * >::parse ( input );
+ RankedNonlinearPattern tree ( std::move ( subtreeWildcardSymbol ), std::move( nonlinearVariables ), std::move ( rankedAlphabet ), std::move ( * root ) );
+
+ delete root;
+ sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, RankedNonlinearPattern::XML_TAG_NAME );
+ return tree;
+}
+
+void RankedNonlinearPattern::compose ( std::deque < sax::Token > & out ) const {
+ out.emplace_back ( RankedNonlinearPattern::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
+ TreeToXMLComposer::composeSubtreeWildcard ( out, subtreeWildcard );
+ TreeToXMLComposer::composeNonlinearVariables ( out, nonlinearVariables );
+ TreeToXMLComposer::composeAlphabet ( out, alphabet );
+ alib::xmlApi < RankedNode * >::compose ( out, pattern );
+ out.emplace_back ( RankedNonlinearPattern::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace tree */
+
+namespace alib {
+
+auto RankedNonlinearPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::RankedNonlinearPattern > ();
+auto RankedNonlinearPatternParserRegister2 = xmlApi < tree::RankedTreeWrapper >::ParserRegister < tree::RankedNonlinearPattern > ();
+auto RankedNonlinearPatternParserRegister3 = xmlApi < alib::Object >::ParserRegister < tree::RankedNonlinearPattern > ();
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.h b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
new file mode 100644
index 0000000000..e81ac20518
--- /dev/null
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
@@ -0,0 +1,126 @@
+/*
+ * RankedNonlinearPattern.h
+ *
+ * Created on: Nov 23, 2013
+ * Author: Jan Travnicek
+ */
+
+#ifndef RANKED_NONLINEAR_PATTERN_H_
+#define RANKED_NONLINEAR_PATTERN_H_
+
+#include <vector>
+#include <list>
+#include <string>
+#include <set>
+#include "RankedNode.h"
+#include "../RankedTreeBase.h"
+#include "../common/RankedNonlinearPatternAlphabet.h"
+
+namespace tree {
+
+class RankedNode;
+class UnrankedPattern;
+
+/**
+ * Represents regular expression parsed from the XML. Regular expression is stored
+ * as a pattern of RegExpElement.
+ */
+class RankedNonlinearPattern : public RankedTreeBase, public RankedNonlinearPatternAlphabet {
+protected:
+ RankedNode * pattern;
+
+public:
+ /**
+ * @copydoc RankedNode::clone() const
+ */
+ virtual RankedTreeBase * clone ( ) const;
+
+ /**
+ * @copydoc RankedNode::plunder() const
+ */
+ virtual RankedTreeBase * plunder ( ) &&;
+
+ explicit RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern );
+ explicit RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, RankedNode pattern );
+
+ /**
+ * Copy constructor.
+ * @param other pattern to copy
+ */
+ RankedNonlinearPattern ( const RankedNonlinearPattern & other );
+ RankedNonlinearPattern ( RankedNonlinearPattern && other ) noexcept;
+ RankedNonlinearPattern & operator =( const RankedNonlinearPattern & other );
+ RankedNonlinearPattern & operator =( RankedNonlinearPattern && other ) noexcept;
+ ~RankedNonlinearPattern ( ) noexcept;
+
+ /**
+ * @return Root node of the regular expression pattern
+ */
+ const RankedNode & getRoot ( ) const;
+
+ const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
+ return RankedNonlinearPatternAlphabet::getAlphabet ( );
+ }
+
+ void extendAlphabet ( const std::set < alphabet::RankedSymbol > & symbols ) {
+ addSymbolsToAlphabet ( symbols );
+ }
+
+ /**
+ * @return Root node of the regular expression pattern
+ */
+ RankedNode & getRoot ( );
+
+ /**
+ * Sets the root node of the regular expression pattern
+ * @param pattern root node to set
+ */
+ void setTree ( RankedNode pattern );
+
+ /**
+ * Removes symbol from the alphabet of symbol available in the regular expression
+ * @param symbol removed symbol from the alphabet
+ */
+ bool removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol );
+
+ /**
+ * Prints XML representation of the pattern to the output stream.
+ * @param out output stream to which print the pattern
+ * @param pattern pattern to print
+ */
+ virtual void operator >>( std::ostream & out ) const;
+
+ virtual int compare ( const ObjectBase & other ) const {
+ 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 ) );
+ }
+
+ virtual int compare ( const RankedNonlinearPattern & other ) const;
+
+ void nicePrint ( std::ostream & os ) const;
+
+ virtual explicit operator std::string ( ) const;
+
+ const static std::string XML_TAG_NAME;
+
+ static RankedNonlinearPattern parse ( std::deque < sax::Token >::iterator & input );
+
+ void compose ( std::deque < sax::Token > & out ) const;
+};
+
+} /* namespace tree */
+
+namespace std {
+
+template < >
+struct compare < tree::RankedNonlinearPattern > {
+ int operator ()( const tree::RankedNonlinearPattern & first, const tree::RankedNonlinearPattern & second ) const {
+ return first.compare ( second );
+ }
+
+};
+
+} /* namespace std */
+
+#endif /* RANKED_NONLINEAR_PATTERN_H_ */
--
GitLab