diff --git a/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.cpp b/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.cpp
deleted file mode 100644
index 63e63ea4dba1162df420338853b2ac5b2fff7a88..0000000000000000000000000000000000000000
--- a/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * 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 nonlinear variable " + ( std::string ) symbol + " has nonzero rank" );
-
- alphabet.insert ( std::move ( subtreeWildcard ) );
-}
-
-bool RankedNonlinearPatternAlphabet::addNonlinearVariable ( alphabet::RankedSymbol symbol ) {
- if ( !alphabet.count ( symbol ) )
- throw TreeException ( "Subtree nonlinear variable \"" + ( std::string ) symbol + "\" is not in the alphabet." );
-
- if ( symbol.getRank ( ).getData ( ) != 0 )
- throw TreeException ( "Subtree nonlinear variable " + ( 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 ) )
- addNonlinearVariable ( 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 );
-
- nonlinearVariables = std::move ( newSymbols );
-}
-
-const std::set < alphabet::RankedSymbol > & RankedNonlinearPatternAlphabet::getNonlinearVariables ( ) const {
- return nonlinearVariables;
-}
-
-bool RankedNonlinearPatternAlphabet::removeNonlinearVariable ( const alphabet::RankedSymbol & symbol ) {
- return nonlinearVariables.insert ( std::move ( symbol ) ).second;
-}
-
-} /* namespace tree */
diff --git a/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.h b/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.h
deleted file mode 100644
index 3b1345a445bf7c3bd7c7b61bf787e2640a843071..0000000000000000000000000000000000000000
--- a/alib2data/src/tree/common/RankedNonlinearPatternAlphabet.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * 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/ranked/RankedNonlinearPattern.cpp b/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
index 992ebc0488dc8b569abd6994b0c36be585b5d80e..b132197087b9493515c0fd3e917367b146fbd038 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
@@ -25,29 +25,25 @@
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;
+RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern ) : std::Components < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( NULL ) {
setTree ( std::move ( pattern ) );
}
-RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, RankedNode pattern ) : RankedNonlinearPatternAlphabet ( std::move ( subtreeWildcard ), std::move ( nonlinearVariables ) ) {
- pattern.computeMinimalAlphabet ( alphabet );
- this->pattern = NULL;
+RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, RankedNode pattern ) : std::Components < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( nonlinearVariables + std::set < alphabet::RankedSymbol > { subtreeWildcard }, nonlinearVariables ), std::make_tuple ( subtreeWildcard ) ), pattern ( NULL ) {
+ pattern.computeMinimalAlphabet ( accessComponent < GeneralAlphabet > ( ).get ( ) );
setTree ( std::move ( pattern ) );
}
-RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, RankedNode pattern ) : RankedNonlinearPatternAlphabet ( std::move ( subtreeWildcard ), { } ) {
- pattern.computeMinimalAlphabet ( alphabet );
- this->pattern = NULL;
+RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, RankedNode pattern ) : std::Components < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::set < alphabet::RankedSymbol > { subtreeWildcard }, std::set < alphabet::RankedSymbol > { } ), std::make_tuple ( subtreeWildcard ) ), pattern ( NULL ) {
+ pattern.computeMinimalAlphabet ( accessComponent < GeneralAlphabet > ( ).get ( ) );
setTree ( std::move ( pattern ) );
}
-RankedNonlinearPattern::RankedNonlinearPattern ( const RankedNonlinearPattern & other ) : RankedNonlinearPatternAlphabet ( other ), pattern ( other.pattern->clone ( ) ) {
+RankedNonlinearPattern::RankedNonlinearPattern ( const RankedNonlinearPattern & other ) : std::Components < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ), other.getNonlinearVariables ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern->clone ( ) ) {
this->pattern->attachAlphabet ( & ( this->getAlphabet() ) );
}
-RankedNonlinearPattern::RankedNonlinearPattern ( RankedNonlinearPattern && other ) noexcept : RankedNonlinearPatternAlphabet ( other ), pattern ( other.pattern ) {
+RankedNonlinearPattern::RankedNonlinearPattern ( RankedNonlinearPattern && other ) noexcept : std::Components < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ), std::move ( other.accessComponent < NonlinearAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( other.pattern ) {
this->pattern->attachAlphabet ( & ( this->getAlphabet() ) );
other.pattern = NULL;
}
@@ -71,9 +67,9 @@ RankedNonlinearPattern & RankedNonlinearPattern::operator =( const RankedNonline
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 );
+ std::swap ( accessComponent < GeneralAlphabet > ( ).get ( ), other.accessComponent < GeneralAlphabet > ( ).get ( ) );
+ std::swap ( accessComponent < NonlinearAlphabet > ( ).get ( ), other.accessComponent < NonlinearAlphabet > ( ).get ( ) );
+ std::swap ( accessElement < SubtreeWildcard > ( ).get ( ), other.accessElement < SubtreeWildcard > ( ).get ( ) );
return * this;
}
@@ -100,21 +96,6 @@ void RankedNonlinearPattern::setTree ( RankedNode pattern ) {
}
}
-bool RankedNonlinearPattern::removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol ) {
- if ( this->pattern->testSymbol ( symbol ) )
- throw TreeException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
-
- if ( this->subtreeWildcard == symbol )
- throw TreeException ( "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 TreeException ( "Input symbol \"" + ( std::string ) symbol + "\" is nonlinearVariable." );
-
- return alphabet.erase ( symbol );
-}
-
void RankedNonlinearPattern::operator >>( std::ostream & out ) const {
out << "(RankedNonlinearPattern " << * ( this->pattern ) << ")";
}
@@ -124,17 +105,17 @@ int RankedNonlinearPattern::compare ( const RankedNonlinearPattern & other ) con
if ( res == 0 ) {
std::compare < alphabet::RankedSymbol > comp;
- res = comp ( subtreeWildcard, other.subtreeWildcard );
+ res = comp ( getSubtreeWildcard ( ), other.getSubtreeWildcard ( ) );
}
if ( res == 0 ) {
std::compare < std::set < alphabet::RankedSymbol > > comp;
- res = comp ( nonlinearVariables, other.nonlinearVariables );
+ res = comp ( getNonlinearVariables(), other.getNonlinearVariables() );
}
if ( res == 0 ) {
std::compare < std::set < alphabet::RankedSymbol > > comp;
- res = comp ( alphabet, other.alphabet );
+ res = comp ( getAlphabet(), other.getAlphabet() );
}
return res;
@@ -167,15 +148,70 @@ RankedNonlinearPattern RankedNonlinearPattern::parse ( std::deque < sax::Token >
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 );
+ TreeToXMLComposer::composeSubtreeWildcard ( out, getSubtreeWildcard() );
+ TreeToXMLComposer::composeNonlinearVariables ( out, getNonlinearVariables() );
+ TreeToXMLComposer::composeAlphabet ( out, getAlphabet() );
alib::xmlApi < RankedNode * >::compose ( out, pattern );
out.emplace_back ( RankedNonlinearPattern::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
}
} /* namespace tree */
+namespace std {
+
+template < >
+bool tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
+ const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
+
+ return pattern->getRoot ( ).testSymbol ( symbol ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern->accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
+}
+
+template < >
+bool tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
+ return true;
+}
+
+template < >
+void tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
+}
+
+template < >
+bool tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::used ( const alphabet::RankedSymbol & ) const {
+ return false;
+}
+
+template < >
+bool tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::available ( const alphabet::RankedSymbol & symbol ) const {
+ const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
+
+ return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+}
+
+template < >
+void tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::valid ( const alphabet::RankedSymbol & symbol ) const {
+ const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
+
+ if ( pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol )
+ throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as nonlinear variable since it is already subtree wildcard" );
+}
+
+template < >
+bool tree::RankedNonlinearPattern::Element < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::available ( const alphabet::RankedSymbol & symbol ) const {
+ const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
+
+ return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+}
+
+template < >
+void tree::RankedNonlinearPattern::Element < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::valid ( const alphabet::RankedSymbol & symbol ) const {
+ const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
+
+ if ( pattern->accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
+ throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as subtree wildcard since it is already nonlinear variable" );
+}
+
+} /* namespace std */
+
namespace alib {
auto RankedNonlinearPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::RankedNonlinearPattern > ( );
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.h b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
index 2c74d1377116932976747be99f6ae88ea6382989..7394fdfd4c3e367af0a3bde6fd7d92b38758c043 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
@@ -8,24 +8,26 @@
#ifndef RANKED_NONLINEAR_PATTERN_H_
#define RANKED_NONLINEAR_PATTERN_H_
-#include <vector>
-#include <list>
#include <string>
#include <set>
+#include <core/components.hpp>
+
#include "RankedNode.h"
#include "../RankedTreeBase.h"
-#include "../common/RankedNonlinearPatternAlphabet.h"
namespace tree {
class RankedNode;
class UnrankedPattern;
+class GeneralAlphabet;
+class SubtreeWildcard;
+class NonlinearAlphabet;
/**
* Represents regular expression parsed from the XML. Regular expression is stored
* as a pattern of RegExpElement.
*/
-class RankedNonlinearPattern : public RankedTreeBase, public RankedNonlinearPatternAlphabet {
+class RankedNonlinearPattern : public RankedTreeBase, public std::Components < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
protected:
RankedNode * pattern;
@@ -60,11 +62,19 @@ public:
const RankedNode & getRoot ( ) const;
const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
- return RankedNonlinearPatternAlphabet::getAlphabet ( );
+ return accessComponent < GeneralAlphabet > ( ).get ( );
}
void extendAlphabet ( const std::set < alphabet::RankedSymbol > & symbols ) {
- addSymbolsToAlphabet ( symbols );
+ accessComponent < GeneralAlphabet > ( ).add ( symbols );
+ }
+
+ const alphabet::RankedSymbol & getSubtreeWildcard ( ) const {
+ return accessElement < SubtreeWildcard > ( ).get ( );
+ }
+
+ const std::set < alphabet::RankedSymbol > & getNonlinearVariables ( ) const {
+ return accessComponent < NonlinearAlphabet > ( ).get ( );
}
/**
@@ -78,12 +88,6 @@ public:
*/
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