RankedPattern use components

alib2data/src/tree/ranked/RankedPattern.cpp

@@ -25,31 +25,26 @@
 namespace tree {
-RankedPattern::RankedPattern ( const UnrankedPattern & other ) : RankedPatternAlphabet ( alphabet::RankedSymbol ( other.getSubtreeWildcard ( ), 0 ) ) {
-	this->pattern = NULL;
-	RankedNode * element = other.getRoot ( ).cloneAsRanked ( );
-	element->computeMinimalAlphabet ( alphabet );
-	setTree ( std::move ( * element ) );
-	delete element;
+RankedPattern::RankedPattern ( const UnrankedPattern & other ) : std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::set < alphabet::RankedSymbol > { alphabet::RankedSymbol ( other.getSubtreeWildcard ( ), 0 ) } ), std::make_tuple ( alphabet::RankedSymbol ( other.getSubtreeWildcard ( ), 0 ) ) ), pattern ( other.getRoot ( ).cloneAsRanked ( ) ) {
+	pattern->computeMinimalAlphabet ( accessComponent < GeneralAlphabet > ( ).get ( ) );
+
+	this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
 }
-RankedPattern::RankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern ) : RankedPatternAlphabet ( std::move ( subtreeWildcard ) ) {
-	setAlphabet ( std::move ( alphabet ) );
-	this->pattern = NULL;
+RankedPattern::RankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern ) : std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( NULL ) {
 	setTree ( std::move ( pattern ) );
 }
-RankedPattern::RankedPattern ( alphabet::RankedSymbol subtreeWildcard, RankedNode pattern ) : RankedPatternAlphabet ( std::move ( subtreeWildcard ) ) {
-	pattern.computeMinimalAlphabet ( alphabet );
-	this->pattern = NULL;
+RankedPattern::RankedPattern ( alphabet::RankedSymbol subtreeWildcard, RankedNode pattern ) : std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::set < alphabet::RankedSymbol > { subtreeWildcard } ), std::make_tuple ( subtreeWildcard ) ), pattern ( NULL ) {
+	pattern.computeMinimalAlphabet ( accessComponent < GeneralAlphabet > ( ).get ( ) );
 	setTree ( std::move ( pattern ) );
 }
-RankedPattern::RankedPattern ( const RankedPattern & other ) : RankedPatternAlphabet ( other ), pattern ( other.pattern->clone ( ) ) {
+RankedPattern::RankedPattern ( const RankedPattern & other ) : std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern->clone ( ) ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet() ) );
 }
-RankedPattern::RankedPattern ( RankedPattern && other ) noexcept : RankedPatternAlphabet ( other ), pattern ( other.pattern ) {
+RankedPattern::RankedPattern ( RankedPattern && other ) noexcept : std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( other.pattern ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet() ) );
 	other.pattern = NULL;
 }
@@ -73,8 +68,8 @@ RankedPattern & RankedPattern::operator =( const RankedPattern & other ) {
 RankedPattern & RankedPattern::operator =( RankedPattern && other ) noexcept {
 	std::swap ( this->pattern, other.pattern );
-	std::swap ( this->alphabet, other.alphabet );
-	std::swap ( this->subtreeWildcard, other.subtreeWildcard );
+	std::swap ( accessComponent < GeneralAlphabet > ( ).get ( ), other.accessComponent < GeneralAlphabet > ( ).get ( ) );
+	std::swap ( accessElement < SubtreeWildcard > ( ).get ( ), other.accessElement < SubtreeWildcard > ( ).get ( ) );
 	return * this;
 }
@@ -101,16 +96,6 @@ void RankedPattern::setTree ( RankedNode pattern ) {
 	}
 }
-bool RankedPattern::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." );
-
-	return alphabet.erase ( symbol );
-}
-
 void RankedPattern::operator >>( std::ostream & out ) const {
 	out << "(RankedPattern " << * ( this->pattern ) << ")";
 }
@@ -120,12 +105,12 @@ int RankedPattern::compare ( const RankedPattern & other ) const {
 	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 ( alphabet, other.alphabet );
+		res = comp ( getAlphabet(), other.getAlphabet() );
 	}
 	return res;
@@ -157,14 +142,44 @@ RankedPattern RankedPattern::parse ( std::deque < sax::Token >::iterator & input
 void RankedPattern::compose ( std::deque < sax::Token > & out ) const {
 	out.emplace_back ( RankedPattern::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
-	TreeToXMLComposer::composeSubtreeWildcard ( out, subtreeWildcard );
-	TreeToXMLComposer::composeAlphabet ( out, alphabet );
+	TreeToXMLComposer::composeSubtreeWildcard ( out, getSubtreeWildcard() );
+	TreeToXMLComposer::composeAlphabet ( out, getAlphabet() );
 	alib::xmlApi < RankedNode * >::compose ( out, pattern );
 	out.emplace_back ( RankedPattern::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
 }
 } /* namespace tree */
+namespace std {
+
+template < >
+bool tree::RankedPattern::Component < tree::RankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
+	const tree::RankedPattern * pattern = static_cast < const tree::RankedPattern * > ( this );
+
+	return pattern->getRoot ( ).testSymbol ( symbol ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
+}
+
+template < >
+bool tree::RankedPattern::Component < tree::RankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
+	return true;
+}
+
+template < >
+void tree::RankedPattern::Component < tree::RankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
+}
+
+template < >
+bool tree::RankedPattern::Element < tree::RankedPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::available ( const alphabet::RankedSymbol & symbol ) const {
+	return static_cast < const tree::RankedPattern * > ( this )->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+}
+
+template < >
+void tree::RankedPattern::Element < tree::RankedPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::valid ( const alphabet::RankedSymbol & ) const {
+}
+
+} /* namespace std */
+
+
 namespace alib {
 auto rankedPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::RankedPattern > ();

alib2data/src/tree/ranked/RankedPattern.h

@@ -8,24 +8,25 @@
 #ifndef RANKED_PATTERN_H_
 #define RANKED_PATTERN_H_
-#include <vector>
-#include <list>
 #include <string>
 #include <set>
+#include <core/components.hpp>
+
 #include "RankedNode.h"
 #include "../RankedTreeBase.h"
-#include "../common/RankedPatternAlphabet.h"
 namespace tree {
 class RankedNode;
 class UnrankedPattern;
+class GeneralAlphabet;
+class SubtreeWildcard;
 /**
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a pattern of RegExpElement.
  */
-class RankedPattern : public RankedTreeBase, public RankedPatternAlphabet {
+class RankedPattern : public RankedTreeBase, public std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
 protected:
 	RankedNode * pattern;
@@ -60,11 +61,15 @@ public:
 	const RankedNode & getRoot ( ) const;
 	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
-		return RankedPatternAlphabet::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 ( );
 	}
 	/**
@@ -78,12 +83,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