From 7dca9d2f994d7df60d225259cec42d1371283f98 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Tue, 3 May 2016 22:04:23 +0200
Subject: [PATCH] make unranked trees use smart pointers
---
.../src/arbology/exact/ExactPatternMatch.cpp | 4 +-
.../src/arbology/exact/ExactSubtreeMatch.cpp | 4 +-
.../src/tree/generate/RandomTreeFactory.cpp | 22 +++---
.../src/tree/common/TreeFromXMLParser.cpp | 8 +-
alib2data/src/tree/common/TreeFromXMLParser.h | 2 +-
alib2data/src/tree/ranked/RankedNode.cpp | 15 ++--
alib2data/src/tree/ranked/RankedNode.h | 2 +-
alib2data/src/tree/unranked/PrefixBarTree.cpp | 2 +-
alib2data/src/tree/unranked/UnrankedNode.cpp | 79 +++++--------------
alib2data/src/tree/unranked/UnrankedNode.h | 32 ++------
.../unranked/UnrankedNonlinearPattern.cpp | 24 +++---
.../tree/unranked/UnrankedNonlinearPattern.h | 2 +-
.../src/tree/unranked/UnrankedPattern.cpp | 26 +++---
alib2data/src/tree/unranked/UnrankedPattern.h | 2 +-
alib2data/src/tree/unranked/UnrankedTree.cpp | 26 +++---
alib2data/src/tree/unranked/UnrankedTree.h | 2 +-
alib2raw/src/tree/TreeFromRawParser.cpp | 40 +++-------
alib2raw/src/tree/TreeFromRawParser.h | 3 +-
alib2str/src/tree/TreeFromStringParser.cpp | 40 +++++-----
alib2str/src/tree/TreeFromStringParser.h | 2 +-
alib2str/src/tree/TreeToStringComposer.cpp | 4 +-
astat2/src/TreeStat.cpp | 6 +-
22 files changed, 129 insertions(+), 218 deletions(-)
diff --git a/alib2algo/src/arbology/exact/ExactPatternMatch.cpp b/alib2algo/src/arbology/exact/ExactPatternMatch.cpp
index aa2738b21a..31342bff37 100644
--- a/alib2algo/src/arbology/exact/ExactPatternMatch.cpp
+++ b/alib2algo/src/arbology/exact/ExactPatternMatch.cpp
@@ -36,7 +36,7 @@ bool ExactPatternMatch::matchHelper ( const tree::UnrankedNode & subject, const
if ( subject.getChildren ( ).size ( ) != pattern.getChildren ( ).size ( ) ) return false;
- for ( const std::tuple < const tree::UnrankedNode *, const tree::UnrankedNode * > & childs : std::make_tuple_foreach ( subject.getChildren ( ), pattern.getChildren ( ) ) )
+ for ( const std::tuple < std::smart_ptr < const tree::UnrankedNode >, std::smart_ptr < const tree::UnrankedNode > > & childs : std::make_tuple_foreach ( subject.getChildren ( ), pattern.getChildren ( ) ) )
if ( !matchHelper ( * std::get < 0 > ( childs ), * std::get < 1 > ( childs ), subtreeVariable ) ) return false;
return true;
@@ -81,7 +81,7 @@ void ExactPatternMatch::matchInternal ( unsigned & index, std::set < unsigned >
index++;
- for ( const tree::UnrankedNode * child : subject.getChildren ( ) )
+ for ( const std::smart_ptr < const tree::UnrankedNode > & child : subject.getChildren ( ) )
matchInternal ( index, occ, * child, pattern, subtreeVariable );
}
diff --git a/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp b/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp
index c3aae2a0d2..07388e8bed 100644
--- a/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp
+++ b/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp
@@ -27,7 +27,7 @@ bool ExactSubtreeMatch::matchHelper ( const tree::UnrankedNode & subject, const
if ( subject.getChildren ( ).size ( ) != pattern.getChildren ( ).size ( ) ) return false;
- for ( const std::tuple < const tree::UnrankedNode *, const tree::UnrankedNode * > & childs : std::make_tuple_foreach ( subject.getChildren ( ), pattern.getChildren ( ) ) )
+ for ( const std::tuple < std::smart_ptr < const tree::UnrankedNode >, std::smart_ptr < const tree::UnrankedNode > > & childs : std::make_tuple_foreach ( subject.getChildren ( ), pattern.getChildren ( ) ) )
if ( !matchHelper ( * std::get < 0 > ( childs ), * std::get < 1 > ( childs ) ) ) return false;
return true;
@@ -48,7 +48,7 @@ void ExactSubtreeMatch::matchInternal ( unsigned & index, std::set < unsigned >
index++;
- for ( const tree::UnrankedNode * child : subject.getChildren ( ) )
+ for ( const std::smart_ptr < const tree::UnrankedNode > & child : subject.getChildren ( ) )
matchInternal ( index, occ, * child, pattern );
}
diff --git a/alib2algo/src/tree/generate/RandomTreeFactory.cpp b/alib2algo/src/tree/generate/RandomTreeFactory.cpp
index d0cd078eb3..4ae101b37f 100644
--- a/alib2algo/src/tree/generate/RandomTreeFactory.cpp
+++ b/alib2algo/src/tree/generate/RandomTreeFactory.cpp
@@ -105,31 +105,31 @@ struct Node {
}
}
- UnrankedNode * createUnrankedNode ( ) {
- std::vector < UnrankedNode * > children;
+ UnrankedNode createUnrankedNode ( ) {
+ std::vector < std::smart_ptr < UnrankedNode > > children;
Node * nextChild = child;
for ( int i = 0; i < rank; i++ ) {
- children.push_back ( nextChild->createUnrankedNode ( ) );
+ children.emplace_back ( std::make_smart < UnrankedNode > ( nextChild->createUnrankedNode ( ) ) );
nextChild = nextChild->right;
}
- return new UnrankedNode ( alphabet::symbolFrom ( symbol ), children );
+ return UnrankedNode ( alphabet::symbolFrom ( symbol ), std::move ( children ) );
}
- UnrankedNode * createUnrankedPatternNode ( ) {
+ UnrankedNode createUnrankedPatternNode ( ) {
if ( rank == 0 ) {
- return new UnrankedNode ( alphabet::Symbol ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD ), { } );
+ return UnrankedNode ( alphabet::Symbol ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD ), { } );
} else {
- std::vector < UnrankedNode * > children;
+ std::vector < std::smart_ptr < UnrankedNode > > children;
Node * nextChild = child;
for ( int i = 0; i < rank; i++ ) {
- children.push_back ( nextChild->createUnrankedPatternNode ( ) );
+ children.emplace_back ( std::make_smart < UnrankedNode > ( nextChild->createUnrankedPatternNode ( ) ) );
nextChild = nextChild->right;
}
- return new UnrankedNode ( alphabet::symbolFrom ( symbol ), children );
+ return UnrankedNode ( alphabet::symbolFrom ( symbol ), std::move ( children ) );
}
}
@@ -274,7 +274,7 @@ UnrankedTree RandomTreeFactory::generateUnrankedTree ( int depth, int nodesCount
for ( std::vector < char >::const_iterator it = alphabet.begin ( ); it != alphabet.end ( ); ++it )
treeAlphabet.insert ( alphabet::symbolFrom ( * it ) );
- UnrankedTree tree ( treeAlphabet, * std::move ( root->createUnrankedNode ( ) ) );
+ UnrankedTree tree ( treeAlphabet, std::move ( root->createUnrankedNode ( ) ) );
delete root;
return tree;
}
@@ -292,7 +292,7 @@ UnrankedPattern RandomTreeFactory::generateUnrankedPattern ( int depth, int node
alphabet::Symbol subtreeWildcard ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD );
treeAlphabet.insert ( subtreeWildcard );
- UnrankedPattern tree ( std::move ( subtreeWildcard ), treeAlphabet, * std::move ( root->createUnrankedPatternNode ( ) ) );
+ UnrankedPattern tree ( std::move ( subtreeWildcard ), treeAlphabet, std::move ( root->createUnrankedPatternNode ( ) ) );
delete root;
return tree;
}
diff --git a/alib2data/src/tree/common/TreeFromXMLParser.cpp b/alib2data/src/tree/common/TreeFromXMLParser.cpp
index 79f8383925..11aa1a1c3f 100644
--- a/alib2data/src/tree/common/TreeFromXMLParser.cpp
+++ b/alib2data/src/tree/common/TreeFromXMLParser.cpp
@@ -101,17 +101,17 @@ RankedNode TreeFromXMLParser::parseRankedNode ( std::deque < sax::Token >::itera
return RankedNode ( std::move ( symbol ), std::move ( children ) );
}
-UnrankedNode * TreeFromXMLParser::parseUnrankedNode ( std::deque < sax::Token >::iterator & input ) {
+UnrankedNode TreeFromXMLParser::parseUnrankedNode ( std::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "unrankedNode" );
alphabet::Symbol symbol = alib::xmlApi < alphabet::Symbol >::parse ( input );
- std::vector < UnrankedNode * > children;
+ std::vector < std::smart_ptr < UnrankedNode > > children;
while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
- children.push_back ( parseUnrankedNode ( input ) );
+ children.emplace_back ( std::make_smart< UnrankedNode > ( parseUnrankedNode ( input ) ) );
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "unrankedNode" );
- return new UnrankedNode ( std::move ( symbol ), std::move ( children ) );
+ return UnrankedNode ( std::move ( symbol ), std::move ( children ) );
}
std::set < alphabet::RankedSymbol > TreeFromXMLParser::parseRankedNonlinearVariables ( std::deque < sax::Token >::iterator & input ) {
diff --git a/alib2data/src/tree/common/TreeFromXMLParser.h b/alib2data/src/tree/common/TreeFromXMLParser.h
index 3aab8d039c..292bf38d22 100644
--- a/alib2data/src/tree/common/TreeFromXMLParser.h
+++ b/alib2data/src/tree/common/TreeFromXMLParser.h
@@ -25,7 +25,7 @@ namespace tree {
class TreeFromXMLParser {
public:
static RankedNode parseRankedNode ( std::deque < sax::Token >::iterator & input );
- static UnrankedNode * parseUnrankedNode ( 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 );
diff --git a/alib2data/src/tree/ranked/RankedNode.cpp b/alib2data/src/tree/ranked/RankedNode.cpp
index 6cea1fef7c..74aa02e3a8 100644
--- a/alib2data/src/tree/ranked/RankedNode.cpp
+++ b/alib2data/src/tree/ranked/RankedNode.cpp
@@ -15,30 +15,27 @@
namespace tree {
-RankedNode::RankedNode ( alphabet::RankedSymbol symbol, std::vector < std::smart_ptr < RankedNode > > children ) : symbol ( std::move ( symbol ) ), children ( std::move ( children ) ), alphabet ( NULL ) {
+RankedNode::RankedNode ( alphabet::RankedSymbol symbol, std::vector < std::smart_ptr < RankedNode > > children ) : symbol ( std::move ( symbol ) ), children ( std::move ( children ) ), parent ( NULL ), alphabet ( NULL ) {
if ( this->children.size ( ) != this->symbol.getRank ( ).getData ( ) ) throw TreeException ( "Number of children doesn't match the rank of the symbol" );
for ( std::smart_ptr < RankedNode > & element : this->children )
element->parent = this;
this->attachAlphabet ( NULL );
- this->parent = NULL;
}
-RankedNode::RankedNode ( const RankedNode & other ) : symbol ( other.symbol ), children ( other.children ), alphabet ( NULL ) {
+RankedNode::RankedNode ( const RankedNode & other ) : symbol ( other.symbol ), children ( other.children ), parent ( NULL ), alphabet ( NULL ) {
for ( std::smart_ptr < RankedNode > & element : this->children )
element->parent = this;
this->attachAlphabet ( NULL );
- this->parent = NULL;
}
-RankedNode::RankedNode ( RankedNode && other ) noexcept : symbol ( std::move ( other.symbol ) ), children ( std::move ( other.children ) ), alphabet ( NULL ) {
+RankedNode::RankedNode ( RankedNode && other ) noexcept : symbol ( std::move ( other.symbol ) ), children ( std::move ( other.children ) ), parent ( NULL ), alphabet ( NULL ) {
for ( std::smart_ptr < RankedNode > & element : this->children )
element->parent = this;
this->attachAlphabet ( NULL );
- this->parent = NULL;
}
RankedNode & RankedNode::operator =( const RankedNode & other ) {
@@ -91,7 +88,7 @@ void RankedNode::setSymbol ( alphabet::RankedSymbol symbol ) {
}
void RankedNode::swap ( RankedNode & other ) {
- const std::set < alphabet::RankedSymbol > * thisParentTree = this->alphabet;
+ const std::set < alphabet::RankedSymbol > * thisParentTree = this->alphabet;
const std::set < alphabet::RankedSymbol > * otherParentTree = other.alphabet;
RankedNode tmp = std::move ( other );
@@ -104,10 +101,10 @@ void RankedNode::swap ( RankedNode & other ) {
}
UnrankedNode RankedNode::asUnranked ( ) const {
- std::vector < UnrankedNode * > unrankedChildren;
+ std::vector < std::smart_ptr < UnrankedNode > > unrankedChildren;
for ( const std::smart_ptr < const RankedNode > & child : this->getChildren() )
- unrankedChildren.push_back ( new UnrankedNode ( child->asUnranked ( ) ) );
+ unrankedChildren.emplace_back ( std::make_smart < UnrankedNode > ( child->asUnranked ( ) ) );
return UnrankedNode ( this->symbol.getSymbol ( ), std::move ( unrankedChildren ) );
}
diff --git a/alib2data/src/tree/ranked/RankedNode.h b/alib2data/src/tree/ranked/RankedNode.h
index a441bdb545..6709235867 100644
--- a/alib2data/src/tree/ranked/RankedNode.h
+++ b/alib2data/src/tree/ranked/RankedNode.h
@@ -8,10 +8,10 @@
#ifndef RANKED_NODE_H_
#define RANKED_NODE_H_
-#include "../../alphabet/LabeledSymbol.h"
#include "../../alphabet/RankedSymbol.h"
#include <vector>
#include <set>
+#include <XmlApi.hpp>
namespace tree {
diff --git a/alib2data/src/tree/unranked/PrefixBarTree.cpp b/alib2data/src/tree/unranked/PrefixBarTree.cpp
index adec2aa147..be0f5ed2e0 100644
--- a/alib2data/src/tree/unranked/PrefixBarTree.cpp
+++ b/alib2data/src/tree/unranked/PrefixBarTree.cpp
@@ -44,7 +44,7 @@ PrefixBarTree::PrefixBarTree ( const UnrankedTree & tree ) : PrefixBarTree ( alp
void PrefixBarTree::toPrefixBar ( const UnrankedNode & node ) {
m_Data.push_back ( node.getSymbol ( ) );
- for ( const UnrankedNode * child : node.getChildren ( ) )
+ for ( const std::smart_ptr < const UnrankedNode > & child : node.getChildren ( ) )
toPrefixBar ( * child );
m_Data.push_back ( bar );
diff --git a/alib2data/src/tree/unranked/UnrankedNode.cpp b/alib2data/src/tree/unranked/UnrankedNode.cpp
index 59c4a3171e..7163f5d7d5 100644
--- a/alib2data/src/tree/unranked/UnrankedNode.cpp
+++ b/alib2data/src/tree/unranked/UnrankedNode.cpp
@@ -16,24 +16,21 @@
namespace tree {
-UnrankedNode::UnrankedNode ( alphabet::Symbol symbol, std::vector < UnrankedNode * > children ) : symbol ( std::move ( symbol ) ), children ( std::move ( children ) ), alphabet ( NULL ) {
+UnrankedNode::UnrankedNode ( alphabet::Symbol symbol, std::vector < std::smart_ptr < UnrankedNode > > children ) : symbol ( std::move ( symbol ) ), children ( std::move ( children ) ), parent ( NULL ), alphabet ( NULL ) {
for ( auto & element : this->children )
element->parent = this;
this->attachAlphabet ( NULL );
}
-UnrankedNode::UnrankedNode ( const UnrankedNode & other ) : symbol ( other.symbol ), alphabet ( NULL ) {
- for ( const auto & element : other.children )
- children.push_back ( element->clone ( ) );
-
+UnrankedNode::UnrankedNode ( const UnrankedNode & other ) : symbol ( other.symbol ), children ( other.children ), parent ( NULL ), alphabet ( NULL ) {
for ( auto & element : this->children )
element->parent = this;
this->attachAlphabet ( NULL );
}
-UnrankedNode::UnrankedNode ( UnrankedNode && other ) noexcept : symbol ( std::move ( other.symbol ) ), children ( std::move ( other.children ) ), alphabet ( NULL ) {
+UnrankedNode::UnrankedNode ( UnrankedNode && other ) noexcept : symbol ( std::move ( other.symbol ) ), children ( std::move ( other.children ) ), parent ( NULL ), alphabet ( NULL ) {
other.children.clear ( );
for ( auto & element : this->children )
@@ -65,17 +62,13 @@ UnrankedNode & UnrankedNode::operator =( UnrankedNode && other ) noexcept {
}
UnrankedNode::~UnrankedNode ( ) noexcept {
- for ( auto element : children )
- delete element;
-
- children.clear ( );
}
-const std::vector < const UnrankedNode * > & UnrankedNode::getChildren ( ) const {
- return * reinterpret_cast < const std::vector < const UnrankedNode * > * > ( & children );
+const std::vector < std::smart_ptr < const UnrankedNode > > & UnrankedNode::getChildren ( ) const {
+ return reinterpret_cast < const std::vector < std::smart_ptr < const UnrankedNode > > & > ( children );
}
-const std::vector < UnrankedNode * > & UnrankedNode::getChildren ( ) {
+const std::vector < std::smart_ptr < UnrankedNode > > & UnrankedNode::getChildren ( ) {
return children;
}
@@ -93,11 +86,9 @@ void UnrankedNode::setSymbol ( alphabet::Symbol symbol ) {
if ( ( this->alphabet != NULL ) && ( this->alphabet->count ( this->symbol ) == 0 ) ) throw TreeException ( "Symbol is not in the alphabet" );
}
-void UnrankedNode::pushBackChild ( const UnrankedNode & node ) {
- UnrankedNode * tmp = node.clone ( );
-
- tmp->attachAlphabet ( this->alphabet );
- this->children.push_back ( tmp );
+void UnrankedNode::pushBackChild ( UnrankedNode node ) {
+ node.attachAlphabet ( this->alphabet );
+ this->children.emplace_back ( std::make_smart < UnrankedNode > ( node ) );
}
void UnrankedNode::swap ( UnrankedNode & other ) {
@@ -113,18 +104,10 @@ void UnrankedNode::swap ( UnrankedNode & other ) {
other.attachAlphabet ( otherParentTree );
}
-UnrankedNode * UnrankedNode::clone ( ) const {
- return new UnrankedNode ( * this );
-}
-
-UnrankedNode * UnrankedNode::plunder ( ) && {
- return new UnrankedNode ( std::move ( * this ) );
-}
-
RankedNode UnrankedNode::asRanked ( ) const {
std::vector < std::smart_ptr < RankedNode > > rankedChildren;
- for ( const UnrankedNode * child : this->children )
+ for ( const std::smart_ptr < const UnrankedNode > & child : this->getChildren() )
rankedChildren.emplace_back ( std::make_smart < RankedNode > ( child->asRanked ( ) ) );
primitive::Unsigned rank( rankedChildren.size ( ) );
@@ -132,28 +115,12 @@ RankedNode UnrankedNode::asRanked ( ) const {
}
int UnrankedNode::compare ( const UnrankedNode & other ) const {
- std::compare < alphabet::Symbol > comp;
- int res = comp ( this->symbol, other.symbol );
-
- if ( res != 0 ) return res;
+ auto first = std::tie ( symbol, getChildren() );
+ auto second = std::tie ( other.symbol, other.getChildren() );
- int thisSize = this->children.size ( );
- int otherSize = other.children.size ( );
+ std::compare < decltype ( first ) > comp;
- if ( thisSize < otherSize ) return -1;
-
- if ( thisSize > otherSize ) return 1;
-
- auto thisIter = this->children.begin ( );
- auto otherIter = other.children.begin ( );
-
- for ( ; thisIter != this->children.end ( ); ++thisIter, ++otherIter ) {
- int res = ( * thisIter )->compare ( * * otherIter );
-
- if ( res != 0 ) return res;
- }
-
- return 0;
+ return comp ( first, second );
}
void UnrankedNode::operator >>( std::ostream & out ) const {
@@ -168,7 +135,7 @@ std::ostream & operator <<( std::ostream & out, const UnrankedNode & node ) {
bool UnrankedNode::testSymbol ( const alphabet::Symbol & symbol ) const {
if ( symbol == this->symbol ) return true;
- for ( const auto & child : this->children )
+ for ( const std::smart_ptr < const UnrankedNode > & child : this->getChildren() )
if ( child->testSymbol ( symbol ) ) return true;
return false;
@@ -179,7 +146,7 @@ bool UnrankedNode::attachAlphabet ( const std::set < alphabet::Symbol > * alphab
this->alphabet = alphabet;
- for ( const auto & child : this->children )
+ for ( std::smart_ptr < UnrankedNode > & child : this->children )
if ( !child->attachAlphabet ( alphabet ) ) return false;
if ( ( this->alphabet != NULL ) && ( this->alphabet->count ( this->symbol ) == 0 ) ) return false;
@@ -190,7 +157,7 @@ bool UnrankedNode::attachAlphabet ( const std::set < alphabet::Symbol > * alphab
void UnrankedNode::computeMinimalAlphabet ( std::set < alphabet::Symbol > & alphabet ) const {
alphabet.insert ( this->symbol );
- for ( const auto & child : this->children )
+ for ( const std::smart_ptr < const UnrankedNode > & child : this->getChildren() )
child->computeMinimalAlphabet ( alphabet );
}
@@ -229,20 +196,16 @@ void UnrankedNode::nicePrint ( std::ostream & os, const std::string & prefix, co
namespace alib {
-tree::UnrankedNode * xmlApi < tree::UnrankedNode * >::parse ( std::deque < sax::Token >::iterator & input ) {
+tree::UnrankedNode xmlApi < tree::UnrankedNode >::parse ( std::deque < sax::Token >::iterator & input ) {
return tree::TreeFromXMLParser::parseUnrankedNode ( input );
}
-bool xmlApi < tree::UnrankedNode * >::first ( const std::deque < sax::Token >::const_iterator & ) {
+bool xmlApi < tree::UnrankedNode >::first ( const std::deque < sax::Token >::const_iterator & ) {
throw tree::TreeException ( "Unimplemented" );
}
-void xmlApi < tree::UnrankedNode * >::compose ( std::deque < sax::Token > & output, const tree::UnrankedNode * const & data ) {
- tree::TreeToXMLComposer::composeNode ( output, * data );
-}
-
-void xmlApi < const tree::UnrankedNode * >::compose ( std::deque < sax::Token > & output, const tree::UnrankedNode * const & data ) {
- tree::TreeToXMLComposer::composeNode ( output, * data );
+void xmlApi < tree::UnrankedNode >::compose ( std::deque < sax::Token > & output, const tree::UnrankedNode & data ) {
+ tree::TreeToXMLComposer::composeNode ( output, data );
}
} /* namespace alib */
diff --git a/alib2data/src/tree/unranked/UnrankedNode.h b/alib2data/src/tree/unranked/UnrankedNode.h
index 3e1653943f..30de24cb55 100644
--- a/alib2data/src/tree/unranked/UnrankedNode.h
+++ b/alib2data/src/tree/unranked/UnrankedNode.h
@@ -24,7 +24,7 @@ class UnrankedNode {
protected:
alphabet::Symbol symbol;
- std::vector < UnrankedNode * > children;
+ std::vector < std::smart_ptr < UnrankedNode > > children;
UnrankedNode * parent;
@@ -44,7 +44,7 @@ protected:
void computeMinimalAlphabet ( std::set < alphabet::Symbol > & alphabet ) const;
public:
- explicit UnrankedNode ( alphabet::Symbol symbol, std::vector < UnrankedNode * > children );
+ explicit UnrankedNode ( alphabet::Symbol symbol, std::vector < std::smart_ptr < UnrankedNode > > children );
UnrankedNode ( const UnrankedNode & other );
UnrankedNode ( UnrankedNode && other ) noexcept;
@@ -52,16 +52,6 @@ public:
UnrankedNode & operator =( UnrankedNode && other ) noexcept;
~UnrankedNode ( ) noexcept;
- /**
- * @copydoc UnrankedNode::clone() const
- */
- UnrankedNode * clone ( ) const;
-
- /**
- * @copydoc UnrankedNode::plunder() const
- */
- UnrankedNode * plunder ( ) &&;
-
/**
* @copydoc UnrankedNode::cloneAsUnranked() const
*/
@@ -75,12 +65,12 @@ public:
/**
* @return children
*/
- const std::vector < const UnrankedNode * > & getChildren ( ) const;
+ const std::vector < std::smart_ptr < const UnrankedNode > > & getChildren ( ) const;
/**
* @return children
*/
- const std::vector < UnrankedNode * > & getChildren ( );
+ const std::vector < std::smart_ptr < UnrankedNode > > & getChildren ( );
UnrankedNode * getParent ( );
@@ -88,7 +78,7 @@ public:
void setSymbol ( alphabet::Symbol symbol );
- void pushBackChild ( const UnrankedNode & node );
+ void pushBackChild ( UnrankedNode node );
void swap ( UnrankedNode & other );
@@ -113,7 +103,6 @@ public:
friend class UnrankedTree;
friend class UnrankedPattern;
friend class UnrankedNonlinearPattern;
-
friend class RankedTree;
friend class RankedPattern;
};
@@ -123,15 +112,10 @@ public:
namespace alib {
template < >
-struct xmlApi < tree::UnrankedNode * > {
- static tree::UnrankedNode * parse ( std::deque < sax::Token >::iterator & input );
+struct xmlApi < tree::UnrankedNode > {
+ static tree::UnrankedNode parse ( std::deque < sax::Token >::iterator & input );
static bool first ( const std::deque < sax::Token >::const_iterator & input );
- static void compose ( std::deque < sax::Token > & output, const tree::UnrankedNode * const & data );
-};
-
-template < >
-struct xmlApi < const tree::UnrankedNode * > {
- static void compose ( std::deque < sax::Token > & output, const tree::UnrankedNode * const & data );
+ static void compose ( std::deque < sax::Token > & output, const tree::UnrankedNode & data );
};
} /* namespace alib */
diff --git a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.cpp b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.cpp
index 5b33fe98ec..8732a8fcc8 100644
--- a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.cpp
+++ b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.cpp
@@ -25,11 +25,11 @@
namespace tree {
-UnrankedNonlinearPattern::UnrankedNonlinearPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > nonlinearVariables, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern ) : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( NULL ) {
+UnrankedNonlinearPattern::UnrankedNonlinearPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > nonlinearVariables, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern ) : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
setTree ( std::move ( pattern ) );
}
-UnrankedNonlinearPattern::UnrankedNonlinearPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > nonlinearVariables, UnrankedNode pattern ) : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( nonlinearVariables + std::set < alphabet::Symbol > { subtreeWildcard }, nonlinearVariables ), std::make_tuple ( subtreeWildcard ) ), pattern ( NULL ) {
+UnrankedNonlinearPattern::UnrankedNonlinearPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > nonlinearVariables, UnrankedNode pattern ) : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( nonlinearVariables + std::set < alphabet::Symbol > { subtreeWildcard }, nonlinearVariables ), std::make_tuple ( subtreeWildcard ) ), pattern ( nullptr ) {
pattern.computeMinimalAlphabet ( accessComponent < GeneralAlphabet > ( ).get ( ) );
setTree ( std::move ( pattern ) );
}
@@ -39,13 +39,12 @@ UnrankedNonlinearPattern::UnrankedNonlinearPattern ( alphabet::Symbol subtreeWil
setTree ( std::move ( pattern ) );
}
-UnrankedNonlinearPattern::UnrankedNonlinearPattern ( const UnrankedNonlinearPattern & other ) : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ), other.getNonlinearVariables ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern->clone ( ) ) {
+UnrankedNonlinearPattern::UnrankedNonlinearPattern ( const UnrankedNonlinearPattern & other ) : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ), other.getNonlinearVariables ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
}
-UnrankedNonlinearPattern::UnrankedNonlinearPattern ( UnrankedNonlinearPattern && other ) noexcept : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, 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 ) {
+UnrankedNonlinearPattern::UnrankedNonlinearPattern ( UnrankedNonlinearPattern && other ) noexcept : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, 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 ( std::move ( other.pattern ) ) {
this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
- other.pattern = NULL;
}
UnrankedTreeBase * UnrankedNonlinearPattern::clone ( ) const {
@@ -75,7 +74,6 @@ UnrankedNonlinearPattern & UnrankedNonlinearPattern::operator =( UnrankedNonline
}
UnrankedNonlinearPattern::~UnrankedNonlinearPattern ( ) noexcept {
- delete pattern;
}
const UnrankedNode & UnrankedNonlinearPattern::getRoot ( ) const {
@@ -87,13 +85,10 @@ UnrankedNode & UnrankedNonlinearPattern::getRoot ( ) {
}
void UnrankedNonlinearPattern::setTree ( UnrankedNode pattern ) {
- delete this->pattern;
- this->pattern = std::move ( pattern ).plunder ( );
+ this->pattern = std::make_smart < UnrankedNode > ( std::move ( pattern ) );
- if ( !this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) ) ) {
- delete this->pattern;
+ if ( !this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) ) )
throw TreeException ( "Input symbols not in the alphabet." );
- }
}
void UnrankedNonlinearPattern::operator >>( std::ostream & out ) const {
@@ -126,10 +121,9 @@ UnrankedNonlinearPattern UnrankedNonlinearPattern::parse ( std::deque < sax::Tok
alphabet::Symbol subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardSymbol ( input );
std::set < alphabet::Symbol > nonlinearVariables = TreeFromXMLParser::parseUnrankedNonlinearVariables ( input );
std::set < alphabet::Symbol > rankedAlphabet = TreeFromXMLParser::parseUnrankedAlphabet ( input );
- UnrankedNode * root = alib::xmlApi < UnrankedNode * >::parse ( input );
- UnrankedNonlinearPattern tree ( std::move ( subtreeWildcardSymbol ), std::move ( nonlinearVariables ), std::move ( rankedAlphabet ), std::move ( * root ) );
+ UnrankedNode root = alib::xmlApi < UnrankedNode >::parse ( input );
+ UnrankedNonlinearPattern tree ( std::move ( subtreeWildcardSymbol ), std::move ( nonlinearVariables ), std::move ( rankedAlphabet ), std::move ( root ) );
- delete root;
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, UnrankedNonlinearPattern::XML_TAG_NAME );
return tree;
}
@@ -139,7 +133,7 @@ void UnrankedNonlinearPattern::compose ( std::deque < sax::Token > & out ) const
TreeToXMLComposer::composeSubtreeWildcard ( out, getSubtreeWildcard ( ) );
TreeToXMLComposer::composeNonlinearVariables ( out, getNonlinearVariables ( ) );
TreeToXMLComposer::composeAlphabet ( out, getAlphabet ( ) );
- alib::xmlApi < UnrankedNode * >::compose ( out, pattern );
+ alib::xmlApi < UnrankedNode >::compose ( out, * pattern );
out.emplace_back ( UnrankedNonlinearPattern::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
}
diff --git a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
index 343e0c17bb..e0e5613756 100644
--- a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
@@ -29,7 +29,7 @@ class NonlinearAlphabet;
*/
class UnrankedNonlinearPattern : public UnrankedTreeBase, public std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
protected:
- UnrankedNode * pattern;
+ std::smart_ptr < UnrankedNode > pattern;
public:
/**
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.cpp b/alib2data/src/tree/unranked/UnrankedPattern.cpp
index 9d2dd97b27..bda841f24b 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.cpp
+++ b/alib2data/src/tree/unranked/UnrankedPattern.cpp
@@ -25,7 +25,7 @@
namespace tree {
-UnrankedPattern::UnrankedPattern ( const RankedPattern & other ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::set < alphabet::Symbol > { other.getSubtreeWildcard ( ).getSymbol ( ) } ), std::make_tuple ( other.getSubtreeWildcard ( ).getSymbol ( ) ) ), pattern ( new UnrankedNode ( other.getRoot ( ).asUnranked ( ) ) ) {
+UnrankedPattern::UnrankedPattern ( const RankedPattern & other ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::set < alphabet::Symbol > { other.getSubtreeWildcard ( ).getSymbol ( ) } ), std::make_tuple ( other.getSubtreeWildcard ( ).getSymbol ( ) ) ), pattern ( std::make_smart < UnrankedNode > ( other.getRoot ( ).asUnranked ( ) ) ) {
std::transform ( other.getAlphabet ( ).begin ( ), other.getAlphabet ( ).end ( ), std::inserter ( accessComponent < GeneralAlphabet > ( ).get ( ), getAlphabet ( ).begin ( ) ), [] ( const alphabet::RankedSymbol & symbol ) {
return symbol.getSymbol ( );
} );
@@ -33,22 +33,21 @@ UnrankedPattern::UnrankedPattern ( const RankedPattern & other ) : std::Componen
this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
}
-UnrankedPattern::UnrankedPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( NULL ) {
+UnrankedPattern::UnrankedPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
setTree ( std::move ( pattern ) );
}
-UnrankedPattern::UnrankedPattern ( alphabet::Symbol subtreeWildcard, UnrankedNode pattern ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::set < alphabet::Symbol > { subtreeWildcard } ), std::make_tuple ( subtreeWildcard ) ), pattern ( NULL ) {
+UnrankedPattern::UnrankedPattern ( alphabet::Symbol subtreeWildcard, UnrankedNode pattern ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::set < alphabet::Symbol > { subtreeWildcard } ), std::make_tuple ( subtreeWildcard ) ), pattern ( nullptr ) {
pattern.computeMinimalAlphabet ( accessComponent < GeneralAlphabet > ( ).get ( ) );
setTree ( std::move ( pattern ) );
}
-UnrankedPattern::UnrankedPattern ( const UnrankedPattern & other ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern->clone ( ) ) {
+UnrankedPattern::UnrankedPattern ( const UnrankedPattern & other ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
}
-UnrankedPattern::UnrankedPattern ( UnrankedPattern && other ) noexcept : std::Components < UnrankedPattern, alphabet::Symbol, 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 ) {
+UnrankedPattern::UnrankedPattern ( UnrankedPattern && other ) noexcept : std::Components < UnrankedPattern, alphabet::Symbol, 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 ( std::move ( other.pattern ) ) {
this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
- other.pattern = NULL;
}
UnrankedTreeBase * UnrankedPattern::clone ( ) const {
@@ -77,7 +76,6 @@ UnrankedPattern & UnrankedPattern::operator =( UnrankedPattern && other ) noexce
}
UnrankedPattern::~UnrankedPattern ( ) noexcept {
- delete pattern;
}
const UnrankedNode & UnrankedPattern::getRoot ( ) const {
@@ -89,13 +87,10 @@ UnrankedNode & UnrankedPattern::getRoot ( ) {
}
void UnrankedPattern::setTree ( UnrankedNode pattern ) {
- delete this->pattern;
- this->pattern = std::move ( pattern ).plunder ( );
+ this->pattern = std::make_smart < UnrankedNode > ( std::move ( pattern ) );
- if ( !this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) ) ) {
- delete this->pattern;
+ if ( !this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) ) )
throw TreeException ( "Input symbols not in the alphabet." );
- }
}
void UnrankedPattern::operator >>( std::ostream & out ) const {
@@ -127,10 +122,9 @@ UnrankedPattern UnrankedPattern::parse ( std::deque < sax::Token >::iterator & i
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, UnrankedPattern::XML_TAG_NAME );
alphabet::Symbol subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardSymbol ( input );
std::set < alphabet::Symbol > rankedAlphabet = TreeFromXMLParser::parseUnrankedAlphabet ( input );
- UnrankedNode * root = alib::xmlApi < UnrankedNode * >::parse ( input );
- UnrankedPattern tree ( std::move ( subtreeWildcardSymbol ), std::move ( rankedAlphabet ), std::move ( * root ) );
+ UnrankedNode root = alib::xmlApi < UnrankedNode >::parse ( input );
+ UnrankedPattern tree ( std::move ( subtreeWildcardSymbol ), std::move ( rankedAlphabet ), std::move ( root ) );
- delete root;
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, UnrankedPattern::XML_TAG_NAME );
return tree;
}
@@ -139,7 +133,7 @@ void UnrankedPattern::compose ( std::deque < sax::Token > & out ) const {
out.emplace_back ( UnrankedPattern::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
TreeToXMLComposer::composeSubtreeWildcard ( out, getSubtreeWildcard ( ) );
TreeToXMLComposer::composeAlphabet ( out, getAlphabet ( ) );
- alib::xmlApi < UnrankedNode * >::compose ( out, pattern );
+ alib::xmlApi < UnrankedNode >::compose ( out, * pattern );
out.emplace_back ( UnrankedPattern::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
}
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.h b/alib2data/src/tree/unranked/UnrankedPattern.h
index 1965315d37..f720a759c8 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedPattern.h
@@ -28,7 +28,7 @@ class SubtreeWildcard;
*/
class UnrankedPattern : public UnrankedTreeBase, public std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
protected:
- UnrankedNode * pattern;
+ std::smart_ptr < UnrankedNode > pattern;
public:
/**
diff --git a/alib2data/src/tree/unranked/UnrankedTree.cpp b/alib2data/src/tree/unranked/UnrankedTree.cpp
index 8c542527d5..5c1a0f75cb 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.cpp
+++ b/alib2data/src/tree/unranked/UnrankedTree.cpp
@@ -25,7 +25,7 @@
namespace tree {
-UnrankedTree::UnrankedTree ( const RankedTree & other ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::set < alphabet::Symbol > { } ), std::tuple < > ( ) ), tree ( new UnrankedNode ( other.getRoot ( ).asUnranked ( ) ) ) {
+UnrankedTree::UnrankedTree ( const RankedTree & other ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::set < alphabet::Symbol > { } ), std::tuple < > ( ) ), tree ( std::make_smart < UnrankedNode > ( other.getRoot ( ).asUnranked ( ) ) ) {
std::transform ( other.getAlphabet ( ).begin ( ), other.getAlphabet ( ).end ( ), std::inserter ( accessComponent < GeneralAlphabet > ( ).get ( ), getAlphabet ( ).begin ( ) ), [] ( const alphabet::RankedSymbol & symbol ) {
return symbol.getSymbol ( );
} );
@@ -33,22 +33,21 @@ UnrankedTree::UnrankedTree ( const RankedTree & other ) : std::Components < Unra
this->tree->attachAlphabet ( & ( this->getAlphabet ( ) ) );
}
-UnrankedTree::UnrankedTree ( std::set < alphabet::Symbol > alphabet, UnrankedNode tree ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), tree ( NULL ) {
+UnrankedTree::UnrankedTree ( std::set < alphabet::Symbol > alphabet, UnrankedNode tree ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), tree ( nullptr ) {
setTree ( std::move ( tree ) );
}
-UnrankedTree::UnrankedTree ( UnrankedNode tree ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::set < alphabet::Symbol > { } ), std::tuple < > ( ) ), tree ( NULL ) {
+UnrankedTree::UnrankedTree ( UnrankedNode tree ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::set < alphabet::Symbol > { } ), std::tuple < > ( ) ), tree ( nullptr ) {
tree.computeMinimalAlphabet ( accessComponent < GeneralAlphabet > ( ).get ( ) );
setTree ( std::move ( tree ) );
}
-UnrankedTree::UnrankedTree ( const UnrankedTree & other ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( other.getAlphabet ( ) ), std::tuple < > ( ) ), tree ( other.tree->clone ( ) ) {
+UnrankedTree::UnrankedTree ( const UnrankedTree & other ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( other.getAlphabet ( ) ), std::tuple < > ( ) ), tree ( other.tree ) {
this->tree->attachAlphabet ( & ( this->getAlphabet ( ) ) );
}
-UnrankedTree::UnrankedTree ( UnrankedTree && other ) noexcept : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::tuple < > ( ) ), tree ( other.tree ) {
+UnrankedTree::UnrankedTree ( UnrankedTree && other ) noexcept : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::tuple < > ( ) ), tree ( std::move ( other.tree ) ) {
this->tree->attachAlphabet ( & ( this->getAlphabet ( ) ) );
- other.tree = NULL;
}
UnrankedTreeBase * UnrankedTree::clone ( ) const {
@@ -76,7 +75,6 @@ UnrankedTree & UnrankedTree::operator =( UnrankedTree && other ) noexcept {
}
UnrankedTree::~UnrankedTree ( ) noexcept {
- delete tree;
}
const UnrankedNode & UnrankedTree::getRoot ( ) const {
@@ -88,13 +86,10 @@ UnrankedNode & UnrankedTree::getRoot ( ) {
}
void UnrankedTree::setTree ( UnrankedNode tree ) {
- delete this->tree;
- this->tree = std::move ( tree ).plunder ( );
+ this->tree = std::make_smart < UnrankedNode > ( std::move ( tree ) );
- if ( !this->tree->attachAlphabet ( & ( this->getAlphabet ( ) ) ) ) {
- delete this->tree;
+ if ( !this->tree->attachAlphabet ( & ( this->getAlphabet ( ) ) ) )
throw TreeException ( "Input symbols not in the alphabet." );
- }
}
void UnrankedTree::operator >>( std::ostream & out ) const {
@@ -125,10 +120,9 @@ const std::string UnrankedTree::XML_TAG_NAME = "UnrankedTree";
UnrankedTree UnrankedTree::parse ( std::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, UnrankedTree::XML_TAG_NAME );
std::set < alphabet::Symbol > rankedAlphabet = TreeFromXMLParser::parseUnrankedAlphabet ( input );
- UnrankedNode * root = alib::xmlApi < UnrankedNode * >::parse ( input );
- UnrankedTree tree ( std::move ( rankedAlphabet ), std::move ( * root ) );
+ UnrankedNode root = alib::xmlApi < UnrankedNode >::parse ( input );
+ UnrankedTree tree ( std::move ( rankedAlphabet ), std::move ( root ) );
- delete root;
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, UnrankedTree::XML_TAG_NAME );
return tree;
}
@@ -136,7 +130,7 @@ UnrankedTree UnrankedTree::parse ( std::deque < sax::Token >::iterator & input )
void UnrankedTree::compose ( std::deque < sax::Token > & out ) const {
out.emplace_back ( UnrankedTree::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
TreeToXMLComposer::composeAlphabet ( out, getAlphabet ( ) );
- alib::xmlApi < UnrankedNode * >::compose ( out, tree );
+ alib::xmlApi < UnrankedNode >::compose ( out, * tree );
out.emplace_back ( UnrankedTree::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
}
diff --git a/alib2data/src/tree/unranked/UnrankedTree.h b/alib2data/src/tree/unranked/UnrankedTree.h
index a0221eb3bb..12da03ddcb 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.h
+++ b/alib2data/src/tree/unranked/UnrankedTree.h
@@ -27,7 +27,7 @@ class GeneralAlphabet;
*/
class UnrankedTree : public UnrankedTreeBase, public std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > {
protected:
- UnrankedNode * tree;
+ std::smart_ptr < UnrankedNode > tree;
public:
/**
diff --git a/alib2raw/src/tree/TreeFromRawParser.cpp b/alib2raw/src/tree/TreeFromRawParser.cpp
index 83256aa29d..f3fed9e55c 100644
--- a/alib2raw/src/tree/TreeFromRawParser.cpp
+++ b/alib2raw/src/tree/TreeFromRawParser.cpp
@@ -20,17 +20,8 @@ Tree TreeFromRawParser::parseTree(std::deque<sax::Token>::iterator& input) const
}
Tree TreeFromRawParser::parseTree(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
- UnrankedNode* root = NULL;
- if (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
- root = this->parseContent(input);
- } else if(sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::CHARACTER)) {
- root = this->parseContentLeaf(input);
- } else {
- throw exception::CommonException("Invalid token stream");
- }
+ UnrankedTree tree(this->parseContent(input));
- UnrankedTree tree(std::move(*root));
- delete root;
if(features.count(FEATURES::UNRANKED_TREE)) return Tree{tree};
if(features.count(FEATURES::PREFIX_RANKED_TREE)) return Tree{PrefixRankedTree{RankedTree{tree}}};
@@ -42,24 +33,19 @@ Tree TreeFromRawParser::parseTree(std::deque<sax::Token>::iterator& input, const
throw exception::CommonException("Invalid input");
}
-UnrankedNode* TreeFromRawParser::parseContent(std::deque<sax::Token>::iterator& input) const {
- UnrankedNode* node = new UnrankedNode(alphabet::symbolFrom(sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::START_ELEMENT)), std::vector<UnrankedNode*> {});
- while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
- UnrankedNode* child = this->parseContent(input);
- node->pushBackChild(std::move(*child));
- delete child;
- }
- if(sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::CHARACTER)) {
- UnrankedNode* child = this->parseContentLeaf(input);
- node->pushBackChild(std::move(*child));
- delete child;
+UnrankedNode TreeFromRawParser::parseContent(std::deque<sax::Token>::iterator& input) const {
+ if (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+ UnrankedNode node(alphabet::symbolFrom(sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::START_ELEMENT)), std::vector<std::smart_ptr < UnrankedNode > > {});
+ while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT) || sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::CHARACTER)) {
+ node.pushBackChild(this->parseContent(input));
+ }
+ sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::END_ELEMENT);
+ return node;
+ } else if(sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::CHARACTER)) {
+ return UnrankedNode(alphabet::symbolFrom(sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::CHARACTER)), std::vector<std::smart_ptr<UnrankedNode>> {});
+ } else {
+ throw exception::CommonException("Invalid token stream");
}
- sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::END_ELEMENT);
- return node;
-}
-
-UnrankedNode* TreeFromRawParser::parseContentLeaf(std::deque<sax::Token>::iterator& input) const {
- return new UnrankedNode(alphabet::symbolFrom(sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::CHARACTER)), std::vector<UnrankedNode*> {});
}
} /* namespace tree */
diff --git a/alib2raw/src/tree/TreeFromRawParser.h b/alib2raw/src/tree/TreeFromRawParser.h
index c7ff68e6a1..b63658fb28 100644
--- a/alib2raw/src/tree/TreeFromRawParser.h
+++ b/alib2raw/src/tree/TreeFromRawParser.h
@@ -23,8 +23,7 @@ public:
Tree parseTree(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
private:
- UnrankedNode* parseContent(std::deque<sax::Token>::iterator& input) const;
- UnrankedNode* parseContentLeaf(std::deque<sax::Token>::iterator& input) const;
+ UnrankedNode parseContent(std::deque<sax::Token>::iterator& input) const;
};
} /* namespace tree */
diff --git a/alib2str/src/tree/TreeFromStringParser.cpp b/alib2str/src/tree/TreeFromStringParser.cpp
index 163fd15a6e..d6688a0f88 100644
--- a/alib2str/src/tree/TreeFromStringParser.cpp
+++ b/alib2str/src/tree/TreeFromStringParser.cpp
@@ -65,28 +65,28 @@ Tree TreeFromStringParser::parseTree ( std::istream & input, const std::set < FE
if ( isPattern && nonlinearVariables.size ( ) ) {
alphabet::RankedSymbol subtreeWildcard ( alphabet::Symbol ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD ), 0 );
- RankedNonlinearPattern tree ( std::move ( subtreeWildcard ), nonlinearVariables, RankedNode ( alphabet::RankedSymbol ( symbol, rank ), std::move ( childs ) ) );
+ RankedNonlinearPattern tree ( std::move ( subtreeWildcard ), std::move ( nonlinearVariables ), RankedNode ( alphabet::RankedSymbol ( std::move ( symbol ), rank ), std::move ( childs ) ) );
- if ( features.count ( FEATURES::RANKED_NONLINEAR_PATTERN ) ) return Tree ( tree );
+ if ( features.count ( FEATURES::RANKED_NONLINEAR_PATTERN ) ) return Tree ( std::move ( tree ) );
} else if ( isPattern ) {
alphabet::RankedSymbol subtreeWildcard ( alphabet::Symbol ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD ), 0 );
- RankedPattern tree ( std::move ( subtreeWildcard ), RankedNode ( alphabet::RankedSymbol ( symbol, rank ), std::move ( childs ) ) );
+ RankedPattern tree ( std::move ( subtreeWildcard ), RankedNode ( alphabet::RankedSymbol ( std::move ( symbol ), rank ), std::move ( childs ) ) );
- if ( features.count ( FEATURES::RANKED_PATTERN ) ) return Tree ( tree );
+ if ( features.count ( FEATURES::RANKED_PATTERN ) ) return Tree ( std::move ( tree ) );
} else {
- RankedTree tree ( RankedNode ( alphabet::RankedSymbol ( symbol, rank ), std::move ( childs ) ) );
+ RankedTree tree ( RankedNode ( alphabet::RankedSymbol ( std::move ( symbol ), rank ), std::move ( childs ) ) );
- if ( features.count ( FEATURES::RANKED_TREE ) ) return Tree ( tree );
+ if ( features.count ( FEATURES::RANKED_TREE ) ) return Tree ( std::move ( tree ) );
}
} else {
std::set < alphabet::Symbol > nonlinearVariables;
- std::vector < tree::UnrankedNode * > childs;
+ std::vector < std::smart_ptr < tree::UnrankedNode > > childs;
bool isPattern = false;
while ( token.type != TreeFromStringLexer::TokenType::BAR ) {
m_TreeLexer.putback ( input, token );
- childs.push_back ( parseUnrankedContent ( input, isPattern, nonlinearVariables ) );
+ childs.emplace_back ( std::make_smart < UnrankedNode > ( parseUnrankedContent ( input, isPattern, nonlinearVariables ) ) );
token = m_TreeLexer.next ( input );
}
@@ -95,18 +95,18 @@ Tree TreeFromStringParser::parseTree ( std::istream & input, const std::set < FE
if ( isPattern && nonlinearVariables.size ( ) ) {
alphabet::Symbol subtreeWildcard ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD );
- UnrankedNonlinearPattern tree ( std::move ( subtreeWildcard ), nonlinearVariables, UnrankedNode ( symbol, childs ) );
+ UnrankedNonlinearPattern tree ( std::move ( subtreeWildcard ), std::move ( nonlinearVariables ), UnrankedNode ( std::move ( symbol ), std::move ( childs ) ) );
- if ( features.count ( FEATURES::UNRANKED_NONLINEAR_PATTERN ) ) return Tree ( tree );
+ if ( features.count ( FEATURES::UNRANKED_NONLINEAR_PATTERN ) ) return Tree ( std::move ( tree ) );
} else if ( isPattern ) {
alphabet::Symbol subtreeWildcard ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD );
- UnrankedPattern tree ( std::move ( subtreeWildcard ), UnrankedNode ( symbol, childs ) );
+ UnrankedPattern tree ( std::move ( subtreeWildcard ), UnrankedNode ( std::move ( symbol ), std::move ( childs ) ) );
- if ( features.count ( FEATURES::UNRANKED_PATTERN ) ) return Tree ( tree );
+ if ( features.count ( FEATURES::UNRANKED_PATTERN ) ) return Tree ( std::move ( tree ) );
} else {
- UnrankedTree tree ( UnrankedNode ( symbol, childs ) );
+ UnrankedTree tree ( UnrankedNode ( std::move ( symbol ), std::move ( childs ) ) );
- if ( features.count ( FEATURES::UNRANKED_TREE ) ) return Tree ( tree );
+ if ( features.count ( FEATURES::UNRANKED_TREE ) ) return Tree ( std::move ( tree ) );
}
}
@@ -147,7 +147,7 @@ tree::RankedNode TreeFromStringParser::parseRankedContent ( std::istream & input
}
}
-tree::UnrankedNode * TreeFromStringParser::parseUnrankedContent ( std::istream & input, bool & isPattern, std::set < alphabet::Symbol > & nonlinearVariables ) const {
+tree::UnrankedNode TreeFromStringParser::parseUnrankedContent ( std::istream & input, bool & isPattern, std::set < alphabet::Symbol > & nonlinearVariables ) const {
TreeFromStringLexer::Token token = m_TreeLexer.next ( input );
if ( token.type == TreeFromStringLexer::TokenType::SUBTREE_WILDCARD ) {
@@ -158,7 +158,7 @@ tree::UnrankedNode * TreeFromStringParser::parseUnrankedContent ( std::istream &
isPattern = true;
alphabet::Symbol subtreeWildcard ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD );
- return new UnrankedNode ( std::move ( subtreeWildcard ), { } );
+ return UnrankedNode ( std::move ( subtreeWildcard ), { } );
} else if ( token.type == TreeFromStringLexer::TokenType::NONLINEAR_VARIABLE ) {
token = m_TreeLexer.next ( input );
@@ -168,25 +168,25 @@ tree::UnrankedNode * TreeFromStringParser::parseUnrankedContent ( std::istream &
isPattern = true;
alphabet::Symbol nonlinearVariable ( alphabet::NonlinearVariableSymbol ( alphabet::symbolFrom ( token.value ) ) );
nonlinearVariables.insert ( nonlinearVariable );
- return new UnrankedNode ( std::move ( nonlinearVariable ), { } );
+ return UnrankedNode ( std::move ( nonlinearVariable ), { } );
} else {
m_TreeLexer.putback ( input, token );
alphabet::Symbol symbol = alib::stringApi < alphabet::Symbol >::parse ( input );
- std::vector < tree::UnrankedNode * > childs;
+ std::vector < std::smart_ptr < tree::UnrankedNode > > childs;
TreeFromStringLexer::Token token = m_TreeLexer.next ( input );
while ( token.type != TreeFromStringLexer::TokenType::BAR ) {
m_TreeLexer.putback ( input, token );
- childs.push_back ( parseUnrankedContent ( input, isPattern, nonlinearVariables ) );
+ childs.emplace_back ( std::make_smart < UnrankedNode > ( parseUnrankedContent ( input, isPattern, nonlinearVariables ) ) );
token = m_TreeLexer.next ( input );
}
if ( token.type != TreeFromStringLexer::TokenType::BAR )
throw exception::CommonException ( "Missing bar" );
- return new UnrankedNode ( std::move ( symbol ), std::move ( childs ) );
+ return UnrankedNode ( std::move ( symbol ), std::move ( childs ) );
}
}
diff --git a/alib2str/src/tree/TreeFromStringParser.h b/alib2str/src/tree/TreeFromStringParser.h
index 5d17877ee1..3759dccd77 100644
--- a/alib2str/src/tree/TreeFromStringParser.h
+++ b/alib2str/src/tree/TreeFromStringParser.h
@@ -30,7 +30,7 @@ public:
private:
tree::RankedNode parseRankedContent ( std::istream &, bool &, std::set < alphabet::RankedSymbol > & ) const;
- tree::UnrankedNode * parseUnrankedContent ( std::istream &, bool &, std::set < alphabet::Symbol > & ) const;
+ tree::UnrankedNode parseUnrankedContent ( std::istream &, bool &, std::set < alphabet::Symbol > & ) const;
TreeFromStringLexer m_TreeLexer;
diff --git a/alib2str/src/tree/TreeToStringComposer.cpp b/alib2str/src/tree/TreeToStringComposer.cpp
index d4fce18151..c496990673 100644
--- a/alib2str/src/tree/TreeToStringComposer.cpp
+++ b/alib2str/src/tree/TreeToStringComposer.cpp
@@ -62,7 +62,7 @@ TreeToStringComposer::RegistratorWrapper < void, UnrankedTree > StringToStringCo
void TreeToStringComposer::compose ( std::ostream & out, const UnrankedNode & node ) {
alib::stringApi < alphabet::Symbol >::compose ( out, node.getSymbol ( ) );
- for ( const UnrankedNode * child : node.getChildren ( ) ) {
+ for ( const std::smart_ptr < const UnrankedNode > & child : node.getChildren ( ) ) {
out << " ";
compose ( out, * child );
}
@@ -82,7 +82,7 @@ void TreeToStringComposer::compose ( std::ostream & out, const alphabet::Symbol
} else {
alib::stringApi < alphabet::Symbol >::compose ( out, node.getSymbol ( ) );
- for ( const UnrankedNode * child : node.getChildren ( ) ) {
+ for ( const std::smart_ptr < const UnrankedNode > & child : node.getChildren ( ) ) {
out << " ";
compose ( out, subtreeWildcard, * child );
}
diff --git a/astat2/src/TreeStat.cpp b/astat2/src/TreeStat.cpp
index 69be052ead..f07baf713c 100644
--- a/astat2/src/TreeStat.cpp
+++ b/astat2/src/TreeStat.cpp
@@ -70,7 +70,7 @@ auto TreeStatFormalTree = TreeStat::RegistratorWrapper < void, tree::RankedTree
unsigned TreeStat::countNodes ( const tree::UnrankedNode & node ) {
unsigned res = 1;
- for ( const tree::UnrankedNode * child : node.getChildren ( ) )
+ for ( const std::smart_ptr < const tree::UnrankedNode > & child : node.getChildren ( ) )
res += countNodes ( * child );
return res;
@@ -97,7 +97,7 @@ void TreeStat::stat ( const tree::UnrankedTree & tree, const TreeSettings & sett
switch ( settings.nodes ) {
case PrintingOptions::PRINT:
- alib::XmlDataFactory::toStdout ( & tree.getRoot ( ) );
+ alib::XmlDataFactory::toStdout ( tree.getRoot ( ) );
break;
case PrintingOptions::SIZE:
@@ -105,7 +105,7 @@ void TreeStat::stat ( const tree::UnrankedTree & tree, const TreeSettings & sett
break;
case PrintingOptions::BOTH:
- alib::XmlDataFactory::toStdout ( & tree.getRoot ( ) );
+ alib::XmlDataFactory::toStdout ( tree.getRoot ( ) );
std::cout << countNodes ( tree.getRoot ( ) ) << std::endl;
break;
--
GitLab