From fea1cbe516e5d67debef673c7a02d044b7d1277b Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Mon, 16 Jul 2018 07:50:36 +0200
Subject: [PATCH] continue tuning and documenting alib2std
---
.../simplify/RegExpOptimizeUnboundedPart.hpp | 50 +-
.../unbounded/UnboundedRegExpAlternation.h | 4 +-
.../unbounded/UnboundedRegExpConcatenation.h | 4 +-
.../src/rte/formal/FormalRTESymbolAlphabet.h | 4 +-
alib2std/src/extensions/forward_tree.hpp | 24 +-
alib2std/src/extensions/tree.hpp | 749 +++++++++++++-
alib2std/src/extensions/tree_base.hpp | 940 +++++++++++++++---
alib2std/test-src/extensions/TreeBaseTest.cpp | 2 +-
8 files changed, 1623 insertions(+), 154 deletions(-)
diff --git a/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.hpp b/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.hpp
index 7c70103e14..81004ed6a2 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.hpp
+++ b/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.hpp
@@ -141,12 +141,12 @@ template < class SymbolType >
bool RegExpOptimize::A1( UnboundedRegExpAlternation < SymbolType > & node ) {
bool optimized = false;
- for( auto it = node.getChildren ( ).begin( ); it != node.getChildren ( ).end( ); ) {
+ for( auto it = node.begin( ); it != node.end( ); ) {
if( dynamic_cast < UnboundedRegExpAlternation < SymbolType > * > ( & * it ) ) {
UnboundedRegExpAlternation < SymbolType > childAlt ( static_cast < UnboundedRegExpAlternation < SymbolType > && > ( std::move ( * it ) ) );
- it = node.getChildren ( ).erase( it );
+ it = node.erase( it );
- it = node.insert ( it, std::make_move_iterator ( childAlt.getChildren ( ).begin ( ) ), std::make_move_iterator ( childAlt.getChildren ( ).end ( ) ) );
+ it = node.insert ( it, std::make_move_iterator ( childAlt.begin ( ) ), std::make_move_iterator ( childAlt.end ( ) ) );
optimized = true;
} else
@@ -166,10 +166,10 @@ bool RegExpOptimize::A2( UnboundedRegExpAlternation < SymbolType > & node ) {
auto cmp = [ ]( const UnboundedRegExpElement < SymbolType > * a, const UnboundedRegExpElement < SymbolType > * b ) -> bool { return * a < * b; };
- if ( std::is_sorted ( node.getChildren ( ).begin( ).base ( ), node.getChildren ( ).end( ).base ( ), cmp ) )
+ if ( std::is_sorted ( node.begin( ).base ( ), node.end( ).base ( ), cmp ) )
return false;
- std::sort ( node.getChildren ( ).begin ( ).base ( ), node.getChildren ( ).end ( ).base ( ), cmp );
+ std::sort ( node.begin ( ).base ( ), node.end ( ).base ( ), cmp );
return true;
}
@@ -184,9 +184,9 @@ bool RegExpOptimize::A3( UnboundedRegExpAlternation < SymbolType > & node ) {
// alternation with no children is efectively \0
- for( auto it = node.getChildren ( ).begin ( ); it != node.getChildren ( ).end ( ); ) {
+ for( auto it = node.begin ( ); it != node.end ( ); ) {
if( dynamic_cast < UnboundedRegExpEmpty < SymbolType > * >( & * it ) ) {
- it = node.getChildren ( ).erase ( it );
+ it = node.erase ( it );
optimized = true;
} else
@@ -214,7 +214,7 @@ bool RegExpOptimize::A4( UnboundedRegExpAlternation < SymbolType > & node ) {
auto cmp = [ ]( const UnboundedRegExpElement < SymbolType > * a, const UnboundedRegExpElement < SymbolType > * b ) -> bool { return * a == * b; };
size_t size = node.getChildren ( ).size ( );
- node.getChildren ( ).erase ( dereferencer ( ext::unique ( node.getChildren ( ).begin ( ).base ( ), node.getChildren ( ).end ( ).base ( ), cmp ) ), node.getChildren ( ).end( ) );
+ node.erase ( dereferencer ( ext::unique ( node.begin ( ).base ( ), node.end ( ).base ( ), cmp ) ), node.end( ) );
return size != node.getChildren ( ).size ( );
}
@@ -228,13 +228,13 @@ template < class SymbolType >
bool RegExpOptimize::A5( UnboundedRegExpConcatenation < SymbolType > & node ) {
bool optimized = false;
- for( auto it = node.getChildren ( ).begin( ); it != node.getChildren ( ).end( ); ) {
+ for( auto it = node.begin( ); it != node.end( ); ) {
if( dynamic_cast < UnboundedRegExpConcatenation < SymbolType > * > ( & * it ) ) {
UnboundedRegExpConcatenation < SymbolType > childConcat = static_cast < UnboundedRegExpConcatenation < SymbolType > && > ( std::move ( * it ) );
- it = node.getChildren ( ).erase ( it );
+ it = node.erase ( it );
- it = node.insert ( it, std::make_move_iterator ( childConcat.getChildren ( ).begin( ) ), std::make_move_iterator ( childConcat.getChildren ( ).end( ) ) );
+ it = node.insert ( it, std::make_move_iterator ( childConcat.begin( ) ), std::make_move_iterator ( childConcat.end( ) ) );
optimized = true;
} else
@@ -255,9 +255,9 @@ bool RegExpOptimize::A6( UnboundedRegExpConcatenation < SymbolType > & node ) {
// concatenation with no children is efectively \e
- for( auto it = node.getChildren ( ).begin( ); it != node.getChildren ( ).end( ); ) {
+ for( auto it = node.begin( ); it != node.end( ); ) {
if ( dynamic_cast < UnboundedRegExpEpsilon < SymbolType > * > ( & * it ) ) {
- it = node.getChildren ( ).erase ( it );
+ it = node.erase ( it );
optimized = true;
} else
@@ -277,8 +277,8 @@ bool RegExpOptimize::A7( UnboundedRegExpConcatenation < SymbolType > & node ) {
if(node.getChildren ( ).size() == 1) return false;
- if( std::any_of ( node.getChildren ( ).begin( ), node.getChildren ( ).end( ), [ ] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpEmpty < SymbolType > * > ( & a ); } ) ) {
- node.getChildren ( ).clear( );
+ if( std::any_of ( node.begin( ), node.end( ), [ ] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpEmpty < SymbolType > * > ( & a ); } ) ) {
+ node.clear( );
node.pushBackChild ( UnboundedRegExpEmpty < SymbolType > ( ) );
return true;
@@ -447,16 +447,16 @@ bool RegExpOptimize::A11( UnboundedRegExpIteration < SymbolType > & node ) {
if( childAlt ) {
// check if eps inside iteration's alternation
- auto eps = find_if ( childAlt->getChildren ( ).begin( ), childAlt->getChildren ( ).end( ), [ ] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool {
+ auto eps = find_if ( childAlt->begin( ), childAlt->end( ), [ ] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool {
return dynamic_cast < const UnboundedRegExpEpsilon < SymbolType > * > ( & a );
});
// if no eps
- if ( eps == childAlt->getChildren ( ).end( ) )
+ if ( eps == childAlt->end( ) )
return false;
// remove eps from alternation
- childAlt->getChildren ( ).erase ( eps );
+ childAlt->erase ( eps );
return true;
}
@@ -548,7 +548,7 @@ bool RegExpOptimize::V4( UnboundedRegExpIteration < SymbolType > & node ) {
// interpretation: if iteration's element is concat and every concat's element is iteration
UnboundedRegExpConcatenation < SymbolType > * cont = dynamic_cast < UnboundedRegExpConcatenation < SymbolType > * > ( & node.getChild ( ) );
- if ( ! cont || ! all_of ( cont->getChildren ( ).begin( ), cont->getChildren ( ).end ( ), [ ] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpIteration < SymbolType > * > ( & a ); } ) )
+ if ( ! cont || ! all_of ( cont->begin( ), cont->end ( ), [ ] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpIteration < SymbolType > * > ( & a ); } ) )
return false;
UnboundedRegExpAlternation < SymbolType > newAlt;
@@ -894,10 +894,10 @@ bool RegExpOptimize::V10( UnboundedRegExpIteration < SymbolType > & node ) {
// interpretation: if iter's child is alternation where some of its children are iteration, then they do not have to be iterations
UnboundedRegExpAlternation < SymbolType > * alt = dynamic_cast < UnboundedRegExpAlternation < SymbolType > * > ( & node.getChild ( ) );
- if ( ! alt || ! any_of ( alt->getChildren ( ).begin( ), alt->getChildren ( ).end( ), [] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpIteration < SymbolType > * > ( & a ); } ) )
+ if ( ! alt || ! any_of ( alt->begin( ), alt->end( ), [] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpIteration < SymbolType > * > ( & a ); } ) )
return false;
- for ( auto it = alt->getChildren ( ).begin( ); it != alt->getChildren ( ).end ( ); ++ it ) {
+ for ( auto it = alt->begin( ); it != alt->end ( ); ++ it ) {
if ( dynamic_cast < UnboundedRegExpIteration < SymbolType > * > ( & * it ) )
alt->setChild ( std::move ( static_cast < UnboundedRegExpIteration < SymbolType > & > ( * it ).getChild ( ) ), it );
}
@@ -916,11 +916,11 @@ bool RegExpOptimize::X1( UnboundedRegExpAlternation < SymbolType > & node ) {
// theorem: In regexp like a* + \e, \e is described twice, first in a*, second in \e.
// therefore we can delete the \e as it is redundant
- auto iter = find_if ( node.getChildren ( ).begin( ), node.getChildren ( ).end( ), [] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpIteration < SymbolType > * > ( & a );} );
- auto eps = find_if ( node.getChildren ( ).begin( ), node.getChildren ( ).end( ), [] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpEpsilon < SymbolType > * > ( & a );} );
+ auto iter = find_if ( node.begin( ), node.end( ), [] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpIteration < SymbolType > * > ( & a );} );
+ auto eps = find_if ( node.begin( ), node.end( ), [] ( const UnboundedRegExpElement < SymbolType > & a ) -> bool { return dynamic_cast < const UnboundedRegExpEpsilon < SymbolType > * > ( & a );} );
- if( iter != node.getChildren ( ).end( ) && eps != node.getChildren ( ).end( ) ) {
- node.getChildren ( ).erase( eps );
+ if( iter != node.end( ) && eps != node.end( ) ) {
+ node.erase( eps );
return true;
}
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h b/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h
index 1224cb2d42..de8e0611e4 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h
@@ -99,7 +99,7 @@ public:
*
* \return child nodes
*/
- ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & getElements ( );
+ const ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & getElements ( );
/**
* Node appending method. The node is added to the current list of nodes.
@@ -173,7 +173,7 @@ const ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & UnboundedRegEx
}
template < class SymbolType >
-ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & UnboundedRegExpAlternation < SymbolType >::getElements ( ) {
+const ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & UnboundedRegExpAlternation < SymbolType >::getElements ( ) {
return this->getChildren();
}
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h b/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h
index 3cfeaede0b..530b8de66c 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h
@@ -99,7 +99,7 @@ public:
*
* \return child nodes
*/
- ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & getElements ( );
+ const ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & getElements ( );
/**
* Node appending method. The node is added to the current list of nodes.
@@ -173,7 +173,7 @@ const ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & UnboundedRegEx
}
template < class SymbolType >
-ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & UnboundedRegExpConcatenation < SymbolType >::getElements ( ) {
+const ext::ptr_vector < UnboundedRegExpElement < SymbolType > > & UnboundedRegExpConcatenation < SymbolType >::getElements ( ) {
return this->getChildren();
}
diff --git a/alib2data/src/rte/formal/FormalRTESymbolAlphabet.h b/alib2data/src/rte/formal/FormalRTESymbolAlphabet.h
index ae0fee2e9b..0e7965b478 100644
--- a/alib2data/src/rte/formal/FormalRTESymbolAlphabet.h
+++ b/alib2data/src/rte/formal/FormalRTESymbolAlphabet.h
@@ -97,7 +97,7 @@ public:
*
* \return child nodes
*/
- ext::ptr_vector < FormalRTEElement < SymbolType, RankType > > & getElements ( );
+ const ext::ptr_vector < FormalRTEElement < SymbolType, RankType > > & getElements ( );
/**
* @copydoc base::CommonBase < FormalRTEElement < SymbolType, RankType > >::compare ( const FormalRTEElement < SymbolType, RankType > & ) const
@@ -162,7 +162,7 @@ const ext::ptr_vector < FormalRTEElement < SymbolType, RankType > > & FormalRTES
}
template < class SymbolType, class RankType >
-ext::ptr_vector < FormalRTEElement < SymbolType, RankType > > & FormalRTESymbolAlphabet < SymbolType, RankType >::getElements ( ) {
+const ext::ptr_vector < FormalRTEElement < SymbolType, RankType > > & FormalRTESymbolAlphabet < SymbolType, RankType >::getElements ( ) {
return this->getChildren ( );
}
diff --git a/alib2std/src/extensions/forward_tree.hpp b/alib2std/src/extensions/forward_tree.hpp
index 12cdddbecf..41431387e4 100644
--- a/alib2std/src/extensions/forward_tree.hpp
+++ b/alib2std/src/extensions/forward_tree.hpp
@@ -40,6 +40,10 @@ namespace ext {
* \brief
* Class introducing a forward_tree with interface trying to be close to the interface of standard library containers.
*
+ * The tree is a hierarchical structure of nodes with parent child relationship, where the children are ordered and indexed by integers.
+ *
+ * Nodes of the forward tree do not store pointers to their parent node.
+ *
* \tparam T the type of values inside nodes of the forward_tree
*/
template < class T >
@@ -54,7 +58,7 @@ class forward_tree {
* \brief
* Container of children of the root node of the tree.
*
- * The children are forward_trees themselves, imitating the notion of a subtree of a tree is itself a tree
+ * The children are trees themselves, hence the subtree of a tree is itself a tree.
*/
ext::vector < forward_tree > m_children;
@@ -252,7 +256,7 @@ public:
* \brief
* Compare the iterators for equality.
*
- * \brief other the other instance
+ * \param other the other instance
*
* \return true if the two iterators are the same, false othervise
*/
@@ -264,7 +268,7 @@ public:
* \brief
* Compare the iterators for nonequality.
*
- * \brief other the other instance
+ * \param other the other instance
*
* \return true if the two iterators are not the same, false othervise
*/
@@ -304,7 +308,7 @@ public:
/**
* \brief
- * Allows to distinguis entry or leave visit of a pointed to node.
+ * Allows to distinguish entry or leave visit of a pointed to node.
*
* \return true if the iterator is pointing to a tree node in the first visit, false in the second (leaving case).
*/
@@ -393,7 +397,7 @@ public:
* \brief
* Compare the iterators for equality.
*
- * \brief other the other instance
+ * \param other the other instance
*
* \return true if the two iterators are the same, false othervise
*/
@@ -405,7 +409,7 @@ public:
* \brief
* Compare the iterators for nonequality.
*
- * \brief other the other instance
+ * \param other the other instance
*
* \return true if the two iterators are not the same, false othervise
*/
@@ -583,7 +587,7 @@ public:
private:
/**
* \brief
- * Forward tree vector construction helper. Trees are nullary nodes having value given by values in the range begin to end.
+ * Vector of forward trees construction helper. Trees are nullary nodes having value given by values in the range begin to end.
*
* \tparam Iterator the type of iterators forming the range
*
@@ -696,6 +700,8 @@ public:
* \brief
* Constructor of the forward_tree from value to be stored in the root node and pack of children trees.
*
+ * \tparam Types ... pack of types convertible to forward_trees
+ *
* \param data the value to be stored in the root
* \param subtrees ... pack of subtrees
*/
@@ -707,6 +713,8 @@ public:
* \brief
* Constructor of the forward_tree from value to be stored in the root node and pack of children trees.
*
+ * \tparam Types ... pack of types convertible to forward_trees
+ *
* \param data the value to be stored in the root
* \param subtrees ... pack of subtrees
*/
@@ -741,7 +749,7 @@ public:
/**
* \brief
- * Getter of a children iterator to the root of the tree
+ * Getter of a children iterator to the root node of the tree
*
* \return iterator to the root
*/
diff --git a/alib2std/src/extensions/tree.hpp b/alib2std/src/extensions/tree.hpp
index fd6324f1de..c638b5c560 100644
--- a/alib2std/src/extensions/tree.hpp
+++ b/alib2std/src/extensions/tree.hpp
@@ -1,5 +1,21 @@
/*
- * bidirectional_tree.hpp
+ * tree.hpp
+ *
+ * This file is part of Algorithms library toolkit.
+ * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
+
+ * Algorithms library toolkit is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * Algorithms library toolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with Algorithms library toolkit. If not, see <http://www.gnu.org/licenses/>.
*
* Created on: Jul 2, 2016
* Author: Jan Travnicek
@@ -19,51 +35,150 @@
namespace ext {
+/**
+ * \brief
+ * Class introducing a tree with interface trying to be close to the interface of standard library containers.
+ *
+ * The tree is a hierarchical structure of nodes with parent child relationship, where the children are ordered and indexed by integers.
+ *
+ * \tparam T the type of values inside nodes of the tree
+ */
template < class T >
class tree {
+ /**
+ * \brief
+ * The value in the root node of the tree
+ */
T m_data;
+ /**
+ * \brief
+ * Pointer to the parent of the node. Null pointer for root of a tree.
+ */
tree * m_parent;
+
+ /**
+ * \brief
+ * Container of children of the root node of the tree.
+ *
+ * The children are trees themselves, hence the subtree of a tree is itself a tree.
+ */
ext::vector < tree > m_children;
public:
+ /**
+ * \brief
+ * Getter of the parent node. Null if the node is root.
+ *
+ * \return pointer to the parent node
+ */
tree * getParent ( ) {
return m_parent;
}
+ /**
+ * \brief
+ * Getter of the parent node. Null if the node is root.
+ *
+ * \return pointer to the parent node
+ */
const tree * getParent ( ) const {
return m_parent;
}
+ /**
+ * \brief
+ * Getter of the value in the root node.
+ *
+ * \return the value in the root node
+ */
T & getData ( ) {
return m_data;
}
+ /**
+ * \brief
+ * Getter of the value in the root node.
+ *
+ * \return the value in the root node
+ */
const T & getData ( ) const {
return m_data;
}
+ /**
+ * \brief
+ * Getter of children of the root node.
+ *
+ * \return children of the root node
+ */
ext::vector < tree > & getChildren ( ) {
return m_children;
}
+ /**
+ * \brief
+ * Getter of children of the root node.
+ *
+ * \return children of the root node
+ */
const ext::vector < tree > & getChildren ( ) const {
return m_children;
}
+ /**
+ * \brief
+ * The iterator type over children of the node
+ */
typedef typename ext::vector < tree >::const_iterator const_children_iterator;
+ /**
+ * \brief
+ * The iterator type over structure of the tree representing nodes and node_ends
+ *
+ * The iterator performs a top to bottom, left to right or depth first travrsal stopping at each node twice. Once as it enters it the first time and second time when it leaves it (on the way to its parent).
+ */
class const_structure_iterator : public std::iterator < std::bidirectional_iterator_tag, T > {
+ /**
+ * \brief
+ * The underlying iterator within some list of children.
+ */
typename ext::vector < tree >::const_iterator node;
+
+ /**
+ * \brief
+ * The depth of the current pointed to node.
+ */
unsigned level;
+ /**
+ * \brief
+ * True if the iterator is pointing to a tree node in the first visit, false in the second (leaving case).
+ */
bool virtual_node;
+
+ /**
+ * \brief
+ * True if the iterator is one position after the last valid iterator value.
+ */
bool isEnd;
public:
+ /**
+ * \brief
+ * Constructor of the iterator based on the iterator to child list
+ *
+ * \param n the iterator to child list
+ */
const_structure_iterator ( typename ext::vector < tree >::const_iterator n ) : node ( n ), level ( 0 ), virtual_node ( false ), isEnd ( false ) {
}
+ /**
+ * \brief
+ * Advance the iterator.
+ *
+ * \return the updated iterator
+ */
const_structure_iterator & operator ++( ) {
if ( virtual_node ) {
const tree * parent = node->getParent ( );
@@ -94,6 +209,12 @@ public:
return * this;
}
+ /**
+ * \brief
+ * Advance the iterator.
+ *
+ * \return the original iterator
+ */
const_structure_iterator operator ++( int ) {
const_structure_iterator tmp ( * this );
@@ -101,6 +222,12 @@ public:
return tmp;
}
+ /**
+ * \brief
+ * Retract the iterator.
+ *
+ * \return the updated iterator
+ */
const_structure_iterator & operator --( ) {
if ( isEnd ) {
--node;
@@ -133,6 +260,12 @@ public:
return * this;
}
+ /**
+ * \brief
+ * Retract the iterator.
+ *
+ * \return the original iterator
+ */
const_structure_iterator operator --( int ) {
const_structure_iterator tmp ( * this );
@@ -140,26 +273,66 @@ public:
return tmp;
}
+ /**
+ * \brief
+ * Compare the iterators for equality.
+ *
+ * \param other the other instance
+ *
+ * \return true if the two iterators are the same, false othervise
+ */
bool operator ==( const const_structure_iterator & other ) {
return node == other.node && virtual_node == other.virtual_node;
}
+ /**
+ * \brief
+ * Compare the iterators for nonequality.
+ *
+ * \param other the other instance
+ *
+ * \return true if the two iterators are not the same, false othervise
+ */
bool operator !=( const const_structure_iterator & other ) {
return !( * this == other );
}
+ /**
+ * \brief
+ * Dereference the iterator by accessing the pointed node value.
+ *
+ * \return the value of node pointed to
+ */
const T & operator *( ) const {
return node->getData ( );
}
+ /**
+ * \brief
+ * Dereference the iterator by accessing the pointed node value.
+ *
+ * \return the value of node pointed to
+ */
const T * operator ->( ) const {
return & node->getData ( );
}
+ /**
+ * \brief
+ * Retrieves what is the depth of node the iterator is pointing to.
+ *
+ * \return the depth of node pointed to
+ */
unsigned getLevel ( ) const {
return level;
}
+ /**
+ * \brief
+ * Allows to distinguish entry or leave visit of a pointed to node.
+ *
+ * \return true if the iterator is pointing to a tree node in the first visit, false in the second (leaving case).
+ */
bool getVirtual ( ) const {
return virtual_node;
}
@@ -168,19 +341,47 @@ public:
friend class tree;
};
+ /**
+ * \brief
+ * The iterator type over structure of the tree following preorder traversal.
+ *
+ * The prefix iterator is constructed as a wrapper over structure iterator, it selects only non-virtual nodes.
+ */
class const_prefix_iterator : public std::iterator < std::bidirectional_iterator_tag, T > {
+ /**
+ * \brief
+ * The underlying structure iterator.
+ */
const_structure_iterator node;
public:
+ /**
+ * \brief
+ * Constructor of the iterator based on the iterator to child list
+ *
+ * \param n the iterator to child list
+ */
const_prefix_iterator ( typename ext::vector < tree >::const_iterator n ) : node ( n ) {
}
+ /**
+ * \brief
+ * Advance the iterator.
+ *
+ * \return the updated iterator
+ */
const_prefix_iterator & operator ++( ) {
while ( ( ++node ).getVirtual ( ) );
return * this;
}
+ /**
+ * \brief
+ * Advance the iterator.
+ *
+ * \return the original iterator
+ */
const_prefix_iterator operator ++( int ) {
const_prefix_iterator tmp ( * this );
@@ -188,12 +389,24 @@ public:
return tmp;
}
+ /**
+ * \brief
+ * Retract the iterator.
+ *
+ * \return the updated iterator
+ */
const_prefix_iterator & operator --( ) {
while ( ( --node ).getVirtual ( ) );
return * this;
}
+ /**
+ * \brief
+ * Retract the iterator.
+ *
+ * \return the original iterator
+ */
const_prefix_iterator operator --( int ) {
const_prefix_iterator tmp ( * this );
@@ -201,22 +414,56 @@ public:
return tmp;
}
+ /**
+ * \brief
+ * Compare the iterators for equality.
+ *
+ * \param other the other instance
+ *
+ * \return true if the two iterators are the same, false othervise
+ */
bool operator ==( const const_prefix_iterator & other ) {
return node == other.node;
}
+ /**
+ * \brief
+ * Compare the iterators for nonequality.
+ *
+ * \param other the other instance
+ *
+ * \return true if the two iterators are not the same, false othervise
+ */
bool operator !=( const const_prefix_iterator & other ) {
return !( * this == other );
}
+ /**
+ * \brief
+ * Dereference the iterator by accessing the pointed node value.
+ *
+ * \return the value of node pointed to
+ */
const T & operator *( ) const {
return * node;
}
+ /**
+ * \brief
+ * Dereference the iterator by accessing the pointed node value.
+ *
+ * \return the value of node pointed to
+ */
const T * operator ->( ) const {
return & node->getData ( );
}
+ /**
+ * \brief
+ * Retrieves what is the depth of node the iterator is pointing to.
+ *
+ * \return the depth of node pointed to
+ */
unsigned getLevel ( ) const {
return node.getLevel ( );
}
@@ -225,19 +472,47 @@ public:
friend class tree;
};
+ /**
+ * \brief
+ * The iterator type over structure of the tree following postorder traversal
+ *
+ * The prefix iterator is constructed as a wrapper over structure iterator, it selects only virtual nodes.
+ */
class const_postfix_iterator : public std::iterator < std::bidirectional_iterator_tag, T > {
+ /**
+ * \brief
+ * The underlying structure iterator.
+ */
const_structure_iterator node;
public:
+ /**
+ * \brief
+ * Constructor of the iterator based on the iterator to child list
+ *
+ * \param n the iterator to child list
+ */
const_postfix_iterator ( typename ext::vector < tree >::const_iterator n ) : node ( n ) {
}
+ /**
+ * \brief
+ * Advances the iterator.
+ *
+ * \return the updated iterator
+ */
const_postfix_iterator & operator ++( ) {
while ( !( ++node ).getVirtual ( ) && !node.isEnd );
return * this;
}
+ /**
+ * \brief
+ * Advances the iterator.
+ *
+ * \return the original iterator
+ */
const_postfix_iterator operator ++( int ) {
const_postfix_iterator tmp ( * this );
@@ -245,12 +520,24 @@ public:
return tmp;
}
+ /**
+ * \brief
+ * Retract the iterator.
+ *
+ * \return the updated iterator
+ */
const_postfix_iterator & operator --( ) {
while ( !( --node ).getVirtual ( ) );
return * this;
}
+ /**
+ * \brief
+ * Retract the iterator.
+ *
+ * \return the original iterator
+ */
const_postfix_iterator operator --( int ) {
const_postfix_iterator tmp ( * this );
@@ -258,22 +545,56 @@ public:
return tmp;
}
+ /**
+ * \brief
+ * Compare the iterators for equality.
+ *
+ * \brief other the other instance
+ *
+ * \return true if the two iterators are the same, false othervise
+ */
bool operator ==( const const_postfix_iterator & other ) {
return node == other.node;
}
+ /**
+ * \brief
+ * Compare the iterators for nonequality.
+ *
+ * \brief other the other instance
+ *
+ * \return true if the two iterators are not the same, false othervise
+ */
bool operator !=( const const_postfix_iterator & other ) {
return !( * this == other );
}
+ /**
+ * \brief
+ * Dereference the iterator by accessing the pointed node value.
+ *
+ * \return the value of node pointed to
+ */
const T & operator *( ) const {
return * node;
}
+ /**
+ * \brief
+ * Dereference the iterator by accessing the pointed node value.
+ *
+ * \return the value of node pointed to
+ */
const T * operator ->( ) const {
return & node->getData ( );
}
+ /**
+ * \brief
+ * Retrieves what is the depth of node the iterator is pointing to.
+ *
+ * \return the depth of node pointed to
+ */
unsigned getLevel ( ) const {
return node.getLevel ( );
}
@@ -285,6 +606,17 @@ public:
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
private:
+ /**
+ * \brief
+ * vector of trees construction helper. Trees are nullary nodes having value given by values in the range begin to end.
+ *
+ * \tparam Iterator the type of iterators forming the range
+ *
+ * \param begin the start of the range of values
+ * \param end the end of the range of values
+ *
+ * \return vector of unary nodes constructed from the begin and end range
+ */
template < typename Iterator >
ext::vector < tree > fromIterator ( Iterator begin, Iterator end ) {
ext::vector < tree > res;
@@ -296,6 +628,16 @@ private:
}
public:
+ /**
+ * \brief
+ * Inserts a subtree into a tree.
+ *
+ * \param under the node under which to add the subtree
+ * \param position the specification of position in children of the node where to add subtrees
+ * \param value a subtree to insert
+ *
+ * \return updated position iterator pointing to the first node inserted
+ */
const_children_iterator insert ( const_children_iterator under, const_children_iterator position, tree < T > && value ) {
ext::vector < tree > & children = const_cast < ext::vector < tree > & > ( under->getChildren ( ) );
@@ -304,10 +646,31 @@ public:
return iter;
}
+ /**
+ * \brief
+ * Inserts a subtree into a tree.
+ *
+ * \param under the node under which to add the subtree
+ * \param position the specification of position in children of the node where to add subtrees
+ * \param value a subtree to insert
+ *
+ * \return updated position iterator pointing to the first node inserted
+ */
const_children_iterator insert ( const_children_iterator under, const_children_iterator position, const tree < T > & value ) {
return insert ( under, position, tree < T > ( value ) );
}
+ /**
+ * \brief
+ * Insert helper for insertion specified by position in children and inserted subtrees given by range of iterators.
+ *
+ * \param under the node under which to add subtrees
+ * \param position the specification of position in children of the node where to add subtrees
+ * \param begin the start of the range of subtrees
+ * \param end the end of the range of subtrees
+ *
+ * \return updated position iterator pointing to the first node inserted
+ */
const_children_iterator insert ( const_children_iterator under, const_children_iterator position, const_children_iterator begin, const_children_iterator end ) {
ext::vector < tree > & children = const_cast < ext::vector < tree > & > ( under->getChildren ( ) );
@@ -319,6 +682,19 @@ public:
return iter;
}
+ /**
+ * \brief
+ * Inserts a subtrees into a tree. The subtrees are nullary nodes having value given by values in the range begin to end.
+ *
+ * \tparam Iterator the type of iterators forming the range
+ *
+ * \param under the node under which to add the subtree
+ * \param position the specification of position in children of the node where to add subtrees
+ * \param begin the start of the range of values
+ * \param end the end of the range of values
+ *
+ * \return updated position iterator pointing to the first node inserted
+ */
template < class Iterator >
const_children_iterator insert ( const_children_iterator under, const_children_iterator position, Iterator begin, Iterator end ) {
ext::vector < tree > children = fromIterator ( begin, end );
@@ -329,46 +705,126 @@ public:
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public:
+ /**
+ * \brief
+ * Constructor of the tree from value to be stored in the root node and children trees.
+ *
+ * \param data the value to be stored in the root
+ * \param children list of subtrees
+ */
tree ( T && data, ext::vector < tree > && children ) : m_data ( std::move ( data ) ), m_parent ( nullptr ), m_children ( std::move ( children ) ) {
for ( tree & child : m_children )
child.m_parent = this;
}
+ /**
+ * \brief
+ * Constructor of the tree from value to be stored in the root node and children trees.
+ *
+ * \param data the value to be stored in the root
+ * \param children list of subtrees
+ */
tree ( const T & data, const ext::vector < tree > & subtrees ) : tree ( T ( data ), ext::vector < tree > ( subtrees ) ) {
}
+ /**
+ * \brief
+ * Constructor of the tree from value to be stored in the root node and pack of children trees.
+ *
+ * \tparam Types ... pack of types convertible to tree
+ *
+ * \param data the value to be stored in the root
+ * \param subtrees ... pack of subtrees
+ */
template < typename ... Types >
tree ( const T & data, Types ... subtrees ) : tree ( data, ext::vector < tree > { subtrees ... } ) {
}
+ /**
+ * \brief
+ * Constructor of the tree from value to be stored in the root node and pack of children trees.
+ *
+ * \tparam Types ... pack of types convertible to tree
+ *
+ * \param data the value to be stored in the root
+ * \param subtrees ... pack of subtrees
+ */
template < typename ... Types >
tree ( T && data, Types ... subtrees ) : tree ( std::move ( data ), ext::vector < tree > { subtrees ... } ) {
}
+ /**
+ * \brief
+ * Constructor of the tree from value to be stored in the root node and range of values to construct nullary nodes from range of values.
+ *
+ * \param data the value to be stored in the root
+ * \param begin the iterator to the begining of values range
+ * \param end the iterator to the end of values range
+ */
template < typename Iterator, typename std::enable_if < ext::is_iterator < Iterator >::value >::type >
tree ( const T & data, Iterator begin, Iterator end ) : tree ( data, fromIterator ( begin, end ) ) {
}
+ /**
+ * \brief
+ * Constructor of the tree from value to be stored in the root node and range of subtrees.
+ *
+ * \param data the value to be stored in the root
+ * \param begin the iterator to the begining of subtree range
+ * \param end the iterator to the end of subtree range
+ */
tree ( const T & data, const_children_iterator begin, const_children_iterator end ) : tree ( data, ext::vector < tree > ( begin, end ) ) {
}
+ /**
+ * \brief
+ * Dectructor of the tree
+ */
~tree ( ) noexcept {
}
+ /**
+ * \brief
+ * Copy constructor of the tree.
+ *
+ * \param other the other instace of the tree
+ */
tree ( const tree & other ) : m_data ( other.m_data ), m_parent ( other.m_parent ), m_children ( other.m_children ) {
for ( tree & child : m_children )
child.m_parent = this;
}
+ /**
+ * \brief
+ * Move constructor of the tree.
+ *
+ * \param other the other instace of the tree
+ */
tree ( tree && other ) noexcept : m_data ( std::move ( other.m_data ) ), m_parent ( other.m_parent ), m_children ( std::move ( other.m_children ) ) {
for ( tree & child : m_children )
child.m_parent = this;
}
+ /**
+ * \brief
+ * Copy operator of assignment of the tree.
+ *
+ * \param other the other instace of the tree
+ *
+ * \return the assigned to instance
+ */
tree & operator =( const tree & node ) {
return this->operator =( tree ( node ) );
}
+ /**
+ * \brief
+ * Move operator of assignment of the tree.
+ *
+ * \param other the other instace of the tree
+ *
+ * \return the assigned to instance
+ */
tree & operator =( tree && node ) noexcept {
m_data = std::move ( node.m_data );
m_children = std::move ( node.m_children );
@@ -381,28 +837,62 @@ public:
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Getter of a children iterator to the root node of the tree
+ *
+ * \return iterator to the root
+ */
const_children_iterator root ( ) const {
return typename ext::vector < tree >::const_iterator ( this );
}
+ /**
+ * \brief
+ * Getter of a children iterator to the parent node of the tree
+ */
const_children_iterator parent ( ) const {
return typename ext::vector < tree >::const_iterator ( this->getParent ( ) );
}
+ /**
+ * \brief
+ * Getter of a children iterator to the begining of children
+ *
+ * \return iterator to the first child
+ */
const_children_iterator begin ( ) const {
return m_children.begin ( );
}
+ /**
+ * \brief
+ * Getter of a children iterator one after the last child
+ *
+ * \return iterator one after the last child
+ */
const_children_iterator end ( ) const {
return m_children.end ( );
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Getter of the prefix iterator to the root node
+ *
+ * \return prefix iterator to the root
+ */
const_prefix_iterator prefix_begin ( ) const {
return typename ext::vector < tree >::const_iterator ( this );
}
+ /**
+ * \brief
+ * Getter of the prefix iterator one after the last node in the prefix traversal
+ *
+ * \return prefix iterator one after the last node in the prefix traversal
+ */
const_prefix_iterator prefix_end ( ) const {
const_prefix_iterator res ( typename ext::vector < tree >::const_iterator ( this + 1 ) );
@@ -412,6 +902,12 @@ public:
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Getter of the postfix iterator to the first node in the postfix traversal
+ *
+ * \return prefix iterator to the first node in the postfix traversal
+ */
const_postfix_iterator postfix_begin ( ) const {
const_postfix_iterator res { typename ext::vector < tree >::const_iterator ( this ) };
@@ -420,6 +916,12 @@ public:
return res;
}
+ /**
+ * \brief
+ * Getter of the postfix iterator one after the last node in the postfix traversal
+ *
+ * \return prefix iterator one after the last node in the postfix traversal
+ */
const_postfix_iterator postfix_end ( ) const {
const_postfix_iterator res ( typename ext::vector < tree >::const_iterator ( this + 1 ) );
@@ -429,10 +931,22 @@ public:
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Getter of the structure iterator to the first node in the traversal
+ *
+ * \return prefix iterator to the first node in the traversal
+ */
const_structure_iterator structure_begin ( ) const {
return typename ext::vector < tree >::const_iterator ( this );
}
+ /**
+ * \brief
+ * Getter of the structure iterator to one after the last node in the traversal
+ *
+ * \return prefix iterator to one after the last node in the traversal
+ */
const_structure_iterator structure_end ( ) const {
const_structure_iterator res ( typename ext::vector < tree >::const_iterator ( this + 1 ) );
@@ -442,6 +956,13 @@ public:
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Pushbacks a subtree after last child of a node specified by an interator given by \p under.
+ *
+ * \param under the node under which to add the subtree
+ * \param value a subtree to pushback to child list
+ */
void push_back ( const_children_iterator under, ext::tree < T > && value ) {
ext::vector < tree > & children = const_cast < ext::vector < tree > & > ( under->getChildren ( ) );
@@ -449,20 +970,48 @@ public:
children.back ( ).m_parent = const_cast < tree * > ( & * under );
}
+ /**
+ * \brief
+ * Pushbacks a subtree after last child of a node specified by an interator given by \p under.
+ *
+ * \param under the node under which to add the subtree
+ * \param value a subtree to pushback to child list
+ */
void push_back ( const_children_iterator under, const ext::tree < T > & value ) {
push_back ( under, tree ( value ) );
}
+ /**
+ * \brief
+ * Pushbacks a nullary node after last child of a node specified by an interator given by \p under.
+ *
+ * \param under the node under which to add the subtree
+ * \param value a value to store in nullary node push-backed to the child list
+ */
void push_back ( const_children_iterator under, T && value ) {
push_back ( under, tree ( std::move ( value ) ) );
}
+ /**
+ * \brief
+ * Pushbacks a nullary node after last child of a node specified by an interator given by \p under.
+ *
+ * \param under the node under which to add the subtree
+ * \param value a value to store in nullary node push-backed to the child list
+ */
void push_back ( const_children_iterator under, const T & value ) {
push_back ( under, T ( value ) );
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Erases a subtree from a tree on given by \p position under a node from \p under
+ *
+ * \param under the node under which to perform the erase
+ * \param position the specification of position in children where to erase the subtree
+ */
const_children_iterator erase ( const_children_iterator under, const_children_iterator position ) {
ext::vector < tree > & children = const_cast < ext::vector < tree > & > ( under->getChildren ( ) );
@@ -471,11 +1020,29 @@ public:
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Access value given indexes of chindren allong the selection path
+ *
+ * \tparam Indexes ... types of child indexes
+ *
+ * \param indexes actual values of child indexes
+ *
+ * \return the value in the selected node
+ */
template < class ... Indexes >
const T & operator ()( Indexes ... indexes ) const {
return this->operator ()( { ( unsigned ) indexes ... } );
}
+ /**
+ * \brief
+ * Access value given indexes of chindren allong the selection path
+ *
+ * \param indexes actual values of child indexes
+ *
+ * \return the value in the selected node
+ */
const T & operator ()( std::initializer_list < unsigned > indexes ) const {
const tree * node = this;
@@ -486,11 +1053,29 @@ public:
return node->getData ( );
}
+ /**
+ * \brief
+ * Access value given indexes of chindren allong the selection path
+ *
+ * \tparam Indexes ... types of child indexes
+ *
+ * \param indexes actual values of child indexes
+ *
+ * \return the value in the selected node
+ */
template < class ... Indexes >
T & operator ()( Indexes ... indexes ) {
return this->operator ()( { ( unsigned ) indexes ... } );
}
+ /**
+ * \brief
+ * Access value given indexes of chindren allong the selection path
+ *
+ * \param indexes actual values of child indexes
+ *
+ * \return the value in the selected node
+ */
T & operator ()( std::initializer_list < unsigned > indexes ) {
tree * node = this;
@@ -503,6 +1088,14 @@ public:
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Helper method to traverse the tree and check all parent references are set correctly.
+ *
+ * \param node the node to test
+ *
+ * \return true if the parent child relationship of nodes is sound
+ */
bool checkStructure ( const tree & node ) const {
bool sign = true;
@@ -512,12 +1105,27 @@ public:
return sign;
}
+ /**
+ * \brief
+ * Helper method to traverse the tree and check all parent references are set correctly. Starts at root node and recursively tests all its child nodes.
+ *
+ * \param node the node to test
+ *
+ * \return true if the parent child relationship of nodes is sound
+ */
bool checkStructure ( ) const {
return m_parent == nullptr && checkStructure ( * this );
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Swap method of two forward trees
+ *
+ * \param first the first forward tree to swap
+ * \param second the second forward tree to swap
+ */
friend void swap ( tree & first, tree & second ) {
using std::swap;
@@ -528,6 +1136,16 @@ public:
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Three-way comparison method of forward trees.
+ *
+ * \param other the other instance to compare against
+ *
+ * \return negative if this instance is smaller than \p other instance
+ * zero if this is equal to \p other instance
+ * positive if this instance is bigger than \p other instance
+ */
int compare ( const tree & other ) const {
static ext::compare < typename std::decay < T >::type > comp;
auto iterF = this->prefix_begin ( );
@@ -546,38 +1164,130 @@ public:
return 0;
}
+ /**
+ * \brief
+ * Equality comparison operator.
+ *
+ * \param other the other instance to compare with
+ *
+ * \return true if this instance is equal to other instance, false othervise
+ */
bool operator ==( const tree & other ) {
return compare ( other ) == 0;
}
+ /**
+ * \brief
+ * Non-equality comparison operator.
+ *
+ * \param other the other instance to compare with
+ *
+ * \return true if this instance is not equal to other instance, false othervise
+ */
bool operator !=( const tree & other ) {
return compare ( other ) != 0;
}
+ /**
+ * \brief
+ * Less comparison operator.
+ *
+ * \param other the other instance to compare with
+ *
+ * \return true if this instance is smaller than other instance, false othervise
+ */
bool operator <( const tree & other ) {
return compare ( other ) < 0;
}
+ /**
+ * \brief
+ * Less or equal comparison operator.
+ *
+ * \param other the other instance to compare with
+ *
+ * \return true if this instance is smaller or equal than other instance, false othervise
+ */
bool operator <=( const tree & other ) {
return compare ( other ) <= 0;
}
+ /**
+ * \brief
+ * Greater comparison operator.
+ *
+ * \param other the other instance to compare with
+ *
+ * \return true if this instance is greater than other instance, false othervise
+ */
bool operator >( const tree & other ) {
return compare ( other ) > 0;
}
+ /**
+ * \brief
+ * Greater or equal comparison operator.
+ *
+ * \param other the other instance to compare with
+ *
+ * \return true if this instance is greater or equal than other instance, false othervise
+ */
bool operator >=( const tree & other ) {
return compare ( other ) >= 0;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ /**
+ * \brief
+ * Internal method of printing a tree into a stream
+ *
+ * The tree is printed hierarchically.
+ *
+ * Example tree a ( b ( c ), b ( c ) ) would be printed like
+ *
+ * \-a
+ * |
+ * |-b
+ * | |
+ * | \-c
+ * |
+ * \-b
+ * |
+ * \-c
+ *
+ * \param os the stream to print to
+ *
+ * \return the changed output stream
+ */
std::ostream & nicePrint ( std::ostream & os ) const {
nicePrint ( os, "", true );
return os;
}
private:
+ /**
+ * \brief
+ * Internal method of printing a tree into a stream
+ *
+ * The tree is printed hierarchically.
+ *
+ * Example tree a ( b ( c ), b ( c ) ) would be printed like
+ *
+ * \-a
+ * |
+ * |-b
+ * | |
+ * | \-c
+ * |
+ * \-b
+ * |
+ * \-c
+ *
+ * \param os the stream to print to
+ * \param prefix the auxiliary parameter representing string of paths in the print
+ * \param last flag indicating this tree is the last subtree of its parent
+ */
void nicePrint ( std::ostream & os, std::string prefix, const bool last ) const {
os << prefix;
@@ -599,6 +1309,17 @@ private:
};
+/**
+ * \brief
+ * Operator to print the tree to the output stream.
+ *
+ * \param out the output stream
+ * \param tree the tree to print
+ *
+ * \tparam T the type of values inside the tree
+ *
+ * \return the output stream from the \p out
+ */
template < class T >
std::ostream & operator <<( std::ostream & out, const tree < T > & t ) {
out << "[";
@@ -630,14 +1351,40 @@ std::ostream & operator <<( std::ostream & out, const tree < T > & t ) {
return out;
}
+/**
+ * \brief
+ * Specialisation of the compare structure implementing the three-way comparison.
+ *
+ * \tparam T the type of values inside the tree
+ */
template < class T >
struct compare < ext::tree < T > > {
+
+ /**
+ * \brief
+ * Implementation of the three-way comparison.
+ *
+ * \param first the left operand of the comparison
+ * \param second the right operand of the comparison
+ *
+ * \return negative value of left < right, positive value if left > right, zero if left == right
+ */
int operator ()( const ext::tree < T > & first, const ext::tree < T > & second ) const {
return first.compare ( second );
}
};
+/**
+ * \brief
+ * Overload of to_string function.
+ *
+ * \param value the tree to be converted to string
+ *
+ * \tparam T the type of values inside the tree
+ *
+ * \return string representation
+ */
template < class T >
std::string to_string ( const ext::tree < T > & value ) {
std::stringstream ss;
diff --git a/alib2std/src/extensions/tree_base.hpp b/alib2std/src/extensions/tree_base.hpp
index 8f22a8d7cd..c4ae325cd3 100644
--- a/alib2std/src/extensions/tree_base.hpp
+++ b/alib2std/src/extensions/tree_base.hpp
@@ -13,8 +13,18 @@
namespace ext {
+/**
+ * \brief
+ * Base class for hierarchy of tree node types. The tree node types can be used to construct tree structures of different types of nodes.
+ *
+ * \tparam Data the base class of the actual tree nodes hierarchy on top of this one
+ */
template < class Data >
class BaseNode {
+ /**
+ * \brief
+ * Pointer to the parent object of this node.
+ */
Data * parent;
template < class D, class C >
@@ -32,72 +42,162 @@ class BaseNode {
template < class D, class C >
friend class VararyNode;
+ /**
+ * \brief
+ * Arrow operator to access fields and methods of the object implementing the actual node of the tree.
+ *
+ * \return pointer to the actual node of the hierarchy
+ */
Data * operator ->( ) {
return static_cast < Data * > ( this );
}
+ /**
+ * \brief
+ * Arrow operator to access fields and methods of the object implementing the actual node of the tree.
+ *
+ * \return pointer to the actual node of the hierarchy
+ */
const Data * operator ->( ) const {
return static_cast < const Data * > ( this );
}
public:
+ /**
+ * \brief
+ * Constructor of the tree hierarchy base class.
+ */
BaseNode ( ) : parent ( nullptr ) {
}
+ /**
+ * \brief
+ * Destructor of the tree hierarchy base class.
+ */
virtual ~BaseNode ( ) noexcept {
}
+ /**
+ * \brief
+ * Copy construction does not copy the parent pointer.
+ */
BaseNode ( const BaseNode & ) : parent ( nullptr ) {
}
+ /**
+ * \brief
+ * Move construction does not copy the parent pointer.
+ */
BaseNode ( BaseNode && ) noexcept : parent ( nullptr ) {
}
+ /**
+ * \brief
+ * Copy assignment does not change the parent pointer.
+ */
BaseNode & operator =( const BaseNode & ) {
return * this;
}
+ /**
+ * \brief
+ * Move assignment does not change the parent pointer.
+ */
BaseNode & operator =( BaseNode && ) noexcept {
return * this;
}
+ /**
+ * \brief
+ * Getter of the parent of the node
+ *
+ * \return parent of the node
+ */
Data * getParent ( ) {
return parent;
}
+ /**
+ * \brief
+ * Getter of the parent of the node
+ *
+ * \return parent of the node
+ */
const Data * getParent ( ) const {
return parent;
}
};
+/**
+ * \brief
+ * Tree node with any but fixed number of children.
+ *
+ * \tparam Data the base class of the actual tree nodes hierarchy on top of this one
+ * \tparam arity the number of child nodes
+ * \tparam Cast the actual class from the actual tree nodes hierarchy
+ */
template < class Data, std::size_t arity, class Cast = Data >
class AnyaryNode {
+ /**
+ * \brief
+ * Representation of child nodes
+ */
ext::ptr_array < Data, arity > m_children;
+ /**
+ * \brief
+ * Helper method to push this instance as parent to this instance's children.
+ */
void setParents ( ) {
for ( Data & child : m_children )
child->parent = static_cast < Cast * > ( this );
}
public:
+ /**
+ * \brief
+ * Constructor based on array of child nodes.
+ *
+ * \param c the array of child nodes
+ */
AnyaryNode ( ext::ptr_array < Data, arity > c ) : m_children ( std::move ( c ) ) {
setParents ( );
}
+ /**
+ * \brief
+ * Destructor of the class.
+ */
virtual ~AnyaryNode ( ) noexcept {
}
+ /**
+ * \brief
+ * Copy constructor.
+ */
AnyaryNode ( const AnyaryNode & other ) : AnyaryNode ( other.m_children ) {
}
+ /**
+ * \brief
+ * Move constructor.
+ */
AnyaryNode ( AnyaryNode && other ) noexcept : AnyaryNode ( std::move ( other.m_children ) ) {
}
+ /**
+ * \brief
+ * Copy operator of assignment.
+ */
AnyaryNode & operator =( const AnyaryNode & other ) {
return * this = AnyaryNode ( other );
}
+ /**
+ * \brief
+ * move operator of assignment.
+ */
AnyaryNode & operator =( AnyaryNode && other ) noexcept {
using std::swap;
@@ -108,214 +208,580 @@ public:
return * this;
}
- const ext::ptr_array < Data, arity > & getElements ( ) {
+ /**
+ * \brief
+ * Getter of the child nodes.
+ *
+ * \return child nodes
+ */
+ const ext::ptr_array < Data, arity > & getChildren ( ) {
return m_children;
}
- const ext::ptr_array < Data, arity > & getElements ( ) const {
+ /**
+ * \brief
+ * Getter of the child nodes.
+ *
+ * \return child nodes
+ */
+ const ext::ptr_array < Data, arity > & getChildren ( ) const {
return m_children;
}
+ /**
+ * \brief
+ * Getter of the child node based on compile time index.
+ *
+ * \tparam N the index of the node
+ *
+ * \return child node at given index
+ */
template < int N >
- const Data & getElement ( ) const {
+ const Data & getChild ( ) const {
return std::get < N > ( m_children );
}
+ /**
+ * \brief
+ * Getter of the child node based on compile time index.
+ *
+ * \tparam N the index of the node
+ *
+ * \return child node at given index
+ */
template < int N >
- Data & getElement ( ) {
+ Data & getChild ( ) {
return std::get < N > ( m_children );
}
- void setElements ( ext::ptr_array < Data, arity > c ) {
+ /**
+ * \brief
+ * Setter of the child nodes.
+ *
+ * \param c child nodes
+ */
+ void setChildren ( ext::ptr_array < Data, arity > c ) {
m_children = std::move ( c );
setParents ( );
}
+ /**
+ * \brief
+ * Setter of the child node based on compile time index.
+ *
+ * \tparam N the index of the node
+ *
+ * \return child node at given index
+ */
template < int N >
- void setElement ( const Data & d ) {
+ void setChild ( const Data & d ) {
m_children.set ( m_children.cbegin ( ) + N, d );
std::get < N > ( m_children )->parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Setter of the child node based on compile time index.
+ *
+ * \tparam N the index of the node
+ *
+ * \return child node at given index
+ */
template < int N >
- void setElement ( Data && d ) {
+ void setChild ( Data && d ) {
m_children.set ( m_children.cbegin ( ) + N, std::move ( d ) );
std::get < N > ( m_children )->parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Getter of an iterator to the begining of children array
+ *
+ * \return begin iterator
+ */
+ typename ext::ptr_array < Data, arity >::iterator begin ( ) {
+ return m_children.begin ( );
+ }
+
+ /**
+ * \brief
+ * Getter of an iterator to the begining of children array
+ *
+ * \return begin iterator
+ */
+ typename ext::ptr_array < Data, arity >::const_iterator begin ( ) const {
+ return m_children.begin ( );
+ }
+
+ /**
+ * \brief
+ * Getter of an iterator to the end of children array
+ *
+ * \return end iterator
+ */
+ typename ext::ptr_array < Data, arity >::iterator end ( ) {
+ return m_children.end ( );
+ }
+
+ /**
+ * \brief
+ * Getter of an iterator to the end of children array
+ *
+ * \return end iterator
+ */
+ typename ext::ptr_array < Data, arity >::const_iterator end ( ) const {
+ return m_children.end ( );
+ }
+
};
+/**
+ * \brief
+ * Nullary node is specialisation of Anyary node to no children.
+ *
+ * \tparam Data the base class of the actual tree nodes hierarchy on top of this one
+ * \tparam Cast the actual class from the actual tree nodes hierarchy
+ */
template < class Data, class Cast = Data >
class NullaryNode : public AnyaryNode < Data, 0, Cast > {
public:
+ /**
+ * \brief
+ * The default constructor of the class.
+ */
NullaryNode ( ) : AnyaryNode < Data, 0, Cast > ( ext::make_ptr_array < Data > ( ) ) {
}
};
+/**
+ * \brief
+ * Unary node is specialisation of Anyary node to one child.
+ *
+ * \tparam Data the base class of the actual tree nodes hierarchy on top of this one
+ * \tparam Cast the actual class from the actual tree nodes hierarchy
+ */
template < class Data, class Cast = Data >
class UnaryNode : public AnyaryNode < Data, 1, Cast > {
public:
+ /**
+ * \brief
+ * Constructor of the class accepting the child node.
+ *
+ * \param c the to be child node of the new node
+ */
UnaryNode ( const Data & c ) : AnyaryNode < Data, 1, Cast > ( ext::make_ptr_array ( c ) ) {
}
+ /**
+ * \brief
+ * Constructor of the class accepting the child node.
+ *
+ * \param c the to be child node of the new node
+ */
UnaryNode ( Data && c ) : AnyaryNode < Data, 1, Cast > ( ext::make_ptr_array ( std::move ( c ) ) ) {
}
+ /**
+ * \brief
+ * Getter of the child of the node.
+ *
+ * \return the child of the node
+ */
Data & getChild ( ) {
- return this->template getElement < 0 > ( );
+ return this->template getChild < 0 > ( );
}
+ /**
+ * \brief
+ * Getter of the child of the node.
+ *
+ * \return the child of the node
+ */
const Data & getChild ( ) const {
- return this->template getElement < 0 > ( );
+ return this->template getChild < 0 > ( );
}
+ /**
+ * \brief
+ * Inherit getChild to this class to distable shadowing.
+ */
+ using AnyaryNode < Data, 1, Cast >::getChild;
+
+ /**
+ * \brief
+ * Setter of the child of the node.
+ *
+ * \param c the child of the node
+ */
void setChild ( const Data & c ) {
- this->template setElement < 0 > ( c );
+ this->template setChild < 0 > ( c );
}
+ /**
+ * \brief
+ * Setter of the child of the node.
+ *
+ * \param c the child of the node
+ */
void setChild ( Data && c ) {
- this->template setElement < 0 > ( std::move ( c ) );
+ this->template setChild < 0 > ( std::move ( c ) );
}
+ /**
+ * \brief
+ * Inherit setChild to this class to distable shadowing.
+ */
+ using AnyaryNode < Data, 1, Cast >::setChild;
+
};
+/**
+ * \brief
+ * Binary node is specialisation of Anyary node to two children.
+ *
+ * \tparam Data the base class of the actual tree nodes hierarchy on top of this one
+ * \tparam Cast the actual class from the actual tree nodes hierarchy
+ */
template < class Data, class Cast = Data >
class BinaryNode : public AnyaryNode < Data, 2, Cast > {
public:
+ /**
+ * \brief
+ * Constructor of the class accepting the two child nodes.
+ *
+ * \param l the first child node of the new node
+ * \param r the second child node of the new node
+ */
BinaryNode ( const Data & l, const Data & r ) : AnyaryNode < Data, 2, Cast > ( ext::make_ptr_array ( l, r ) ) {
}
+ /**
+ * \brief
+ * Constructor of the class accepting the two child nodes.
+ *
+ * \param l the first child node of the new node
+ * \param r the second child node of the new node
+ */
BinaryNode ( Data && l, Data && r ) : AnyaryNode < Data, 2, Cast > ( ext::make_ptr_array ( std::move ( l ), std::move ( r ) ) ) {
}
+ /**
+ * \brief
+ * Getter of the first child of the node.
+ *
+ * \return the first child of the node
+ */
Data & getLeft ( ) {
- return this->template getElement < 0 > ( );
+ return this->template getChild < 0 > ( );
}
+ /**
+ * \brief
+ * Getter of the first child of the node.
+ *
+ * \return the first child of the node
+ */
const Data & getLeft ( ) const {
- return this->template getElement < 0 > ( );
+ return this->template getChild < 0 > ( );
}
+ /**
+ * \brief
+ * Setter of the first child of the node.
+ *
+ * \param l the first child of the node
+ */
void setLeft ( const Data & l ) {
- this->template setElement < 0 > ( l );
+ this->template setChild < 0 > ( l );
}
+ /**
+ * \brief
+ * Setter of the first child of the node.
+ *
+ * \param l the first child of the node
+ */
void setLeft ( Data && l ) {
- this->template setElement < 0 > ( std::move ( l ) );
+ this->template setChild < 0 > ( std::move ( l ) );
}
+ /**
+ * \brief
+ * Getter of the second child of the node.
+ *
+ * \return the second child of the node
+ */
Data & getRight ( ) {
- return this->template getElement < 1 > ( );
+ return this->template getChild < 1 > ( );
}
+ /**
+ * \brief
+ * Getter of the second child of the node.
+ *
+ * \return the second child of the node
+ */
const Data & getRight ( ) const {
- return this->template getElement < 1 > ( );
+ return this->template getChild < 1 > ( );
}
+ /**
+ * \brief
+ * Setter of the second child of the node.
+ *
+ * \param r the second child of the node
+ */
void setRight ( const Data & r ) {
- this->template setElement < 1 > ( r );
+ this->template setChild < 1 > ( r );
}
+ /**
+ * \brief
+ * Setter of the second child of the node.
+ *
+ * \param r the second child of the node
+ */
void setRight ( Data && r ) {
- this->template setElement < 1 > ( std::move ( r ) );
+ this->template setChild < 1 > ( std::move ( r ) );
}
};
+/**
+ * \brief
+ * Ternany node is specialisation of Anyary node to three children.
+ *
+ * \tparam Data the base class of the actual tree nodes hierarchy on top of this one
+ * \tparam Cast the actual class from the actual tree nodes hierarchy
+ */
template < class Data, class Cast = Data >
class TernaryNode : public AnyaryNode < Data, 3, Cast > {
public:
+ /**
+ * \brief
+ * Constructor of the class accepting the three child nodes.
+ *
+ * \param f the first child node of the new node
+ * \param s the second child node of the new node
+ * \param t the third child node of the new node
+ */
TernaryNode ( const Data & f, const Data & s, const Data & t ) : AnyaryNode < Data, 3, Cast > ( ext::make_ptr_array ( f, s, t ) ) {
}
+ /**
+ * \brief
+ * Constructor of the class accepting the three child nodes.
+ *
+ * \param f the first child node of the new node
+ * \param s the second child node of the new node
+ * \param t the third child node of the new node
+ */
TernaryNode ( Data && f, Data && s, Data && t ) : AnyaryNode < Data, 3, Cast > ( ext::make_ptr_array ( std::move ( f ), std::move ( s ), std::move ( t ) ) ) {
}
+ /**
+ * \brief
+ * Getter of the first child of the node.
+ *
+ * \return the first child of the node
+ */
Data & getFirst ( ) {
- return this->template getElement < 0 > ( );
+ return this->template getChild < 0 > ( );
}
+ /**
+ * \brief
+ * Getter of the first child of the node.
+ *
+ * \return the first child of the node
+ */
const Data & getFirst ( ) const {
- return this->template getElement < 0 > ( );
+ return this->template getChild < 0 > ( );
}
+ /**
+ * \brief
+ * Setter of the first child of the node.
+ *
+ * \param f the first child of the node
+ */
void setFirst ( const Data & f ) {
- this->template setElement < 0 > ( f );
+ this->template setChild < 0 > ( f );
}
+ /**
+ * \brief
+ * Setter of the first child of the node.
+ *
+ * \param f the first child of the node
+ */
void setFirst ( Data && f ) {
- this->template setElement < 0 > ( std::move ( f ) );
+ this->template setChild < 0 > ( std::move ( f ) );
}
+ /**
+ * \brief
+ * Getter of the second child of the node.
+ *
+ * \return the second child of the node
+ */
Data & getSecond ( ) {
- return this->template getElement < 1 > ( );
+ return this->template getChild < 1 > ( );
}
+ /**
+ * \brief
+ * Getter of the second child of the node.
+ *
+ * \return the second child of the node
+ */
const Data & getSecond ( ) const {
- return this->template getElement < 1 > ( );
+ return this->template getChild < 1 > ( );
}
+ /**
+ * \brief
+ * Setter of the second child of the node.
+ *
+ * \param s the child of the node
+ */
void setSecond ( const Data & s ) {
- this->template setElement < 1 > ( s );
+ this->template setChild < 1 > ( s );
}
+ /**
+ * \brief
+ * Setter of the second child of the node.
+ *
+ * \param s the child of the node
+ */
void setSecond ( Data && s ) {
- this->template setElement < 1 > ( std::move ( s ) );
+ this->template setChild < 1 > ( std::move ( s ) );
}
+ /**
+ * \brief
+ * Getter of the third child of the node.
+ *
+ * \return the third child of the node
+ */
Data & getThird ( ) {
- return this->template getElement < 2 > ( );
+ return this->template getChild < 2 > ( );
}
+ /**
+ * \brief
+ * Getter of the third child of the node.
+ *
+ * \return the third child of the node
+ */
const Data & getThird ( ) const {
- return this->template getElement < 2 > ( );
+ return this->template getChild < 2 > ( );
}
+ /**
+ * \brief
+ * Setter of the third child of the node.
+ *
+ * \param t the third child of the node
+ */
void setThird ( const Data & t ) {
- this->template setElement < 2 > ( t );
+ this->template setChild < 2 > ( t );
}
+ /**
+ * \brief
+ * Setter of the third child of the node.
+ *
+ * \param t the third child of the node
+ */
void setThird ( Data && t ) {
- this->template setElement < 2 > ( std::move ( t ) );
+ this->template setChild < 2 > ( std::move ( t ) );
}
};
+/**
+ * \brief
+ * Fixedary node is tree node that when initialized does not permit change of the number of its children.
+ *
+ * \tparam Data the base class of the actual tree nodes hierarchy on top of this one
+ * \tparam Cast the actual class from the actual tree nodes hierarchy
+ */
template < class Data, class Cast = Data >
class FixedaryNode {
+ /**
+ * \brief
+ * Representation of child nodes
+ */
ext::ptr_vector < Data > m_children;
public:
- template < typename ... Types >
- FixedaryNode ( Types ... data ) {
- Data args[] { std::move ( data ) ... };
-
- for ( Data & child : args )
- m_children.push_back ( std::move ( child ) );
-
+ /**
+ * \brief
+ * Constructor of the node from vector of children.
+ *
+ * \param c the child nodes
+ */
+ FixedaryNode ( ext::ptr_vector < Data > c ) : m_children ( std::move ( c ) ) {
for ( Data & child : m_children )
child.parent = static_cast < Cast * > ( this );
}
- FixedaryNode ( ext::ptr_vector < Data > c ) : m_children ( std::move ( c ) ) {
- for ( Data & child : m_children )
- child.parent = static_cast < Cast * > ( this );
+ /**
+ * \brief
+ * Constructor of the node from pack of children
+ *
+ * \tparam Types ... the types of children
+ *
+ * \param data ... the actual children
+ */
+ template < typename ... Types >
+ FixedaryNode ( Types && ... data ) : FixedaryNode ( ext::ptr_vector < Data > ( { std::forward < Types > ( data ) ... } ) ) {
}
+ /**
+ * \brief
+ * Destructor of the class.
+ */
virtual ~FixedaryNode ( ) noexcept {
}
+ /**
+ * \brief
+ * Copy constructor of the class.
+ *
+ * \param other the other instance
+ */
FixedaryNode ( const FixedaryNode & other ) : FixedaryNode ( other.m_children ) {
}
+ /**
+ * \brief
+ * Move constructor of the class.
+ *
+ * \param other the other instance
+ */
FixedaryNode ( FixedaryNode && other ) noexcept : FixedaryNode ( std::move ( other.m_children ) ) {
}
+ /**
+ * \brief
+ * Copy operator of assignment.
+ *
+ * \param other the other instance
+ */
FixedaryNode & operator =( const FixedaryNode & other ) {
return * this = FixedaryNode ( other );
}
+ /**
+ * \brief
+ * Move operator of assignment.
+ *
+ * \param other the other instance
+ */
FixedaryNode & operator =( FixedaryNode && other ) noexcept {
using std::swap;
@@ -327,14 +793,32 @@ public:
return * this;
}
- ext::ptr_vector < Data > & getChildren ( ) {
+ /**
+ * \brief
+ * Getter of the vector of children.
+ *
+ * \return the child nodes
+ */
+ const ext::ptr_vector < Data > & getChildren ( ) {
return m_children;
}
+ /**
+ * \brief
+ * Getter of the vector of children.
+ *
+ * \return the child nodes
+ */
const ext::ptr_vector < Data > & getChildren ( ) const {
return m_children;
}
+ /**
+ * \brief
+ * Setter of the vector of children.
+ *
+ * \param c the new child nodes in for of a vector
+ */
void setChildren ( ext::ptr_vector < Data > c ) {
if ( c.size ( ) != m_children.size ( ) )
throw "Arity != size";
@@ -345,50 +829,191 @@ public:
child->parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Getter of the child at given index.
+ *
+ * \param index the index to retrieve
+ *
+ * \return reference to the child at given index
+ */
+ Data & getChild ( int index ) {
+ return m_children [ index ];
+ }
+
+ /**
+ * \brief
+ * Getter of the child at given index.
+ *
+ * \param index the index to retrieve
+ *
+ * \return reference to the child at given index
+ */
+ const Data & getChild ( int index ) const {
+ return m_children [ index ];
+ }
+
+ /**
+ * \brief
+ * Setter of the single child of the node.
+ *
+ * \param d the new child node
+ * \param it the position where to change the child
+ */
void setChild ( Data && d, typename ext::ptr_vector < Data >::const_iterator it ) {
m_children.set ( it, std::move ( d ) )->parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Setter of the single child of the node.
+ *
+ * \param d the new child node
+ * \param it the position where to change the child
+ */
void setChild ( const Data & d, typename ext::ptr_vector < Data >::const_iterator it ) {
m_children.set ( it, d )->parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Setter of the single child of the node.
+ *
+ * \param d the new child node
+ * \param index the position where to change the child
+ */
void setChild ( const Data & d, int index ) {
setChild ( d, m_children.begin ( ) + index );
}
+ /**
+ * \brief
+ * Setter of the single child of the node.
+ *
+ * \param d the new child node
+ * \param index the position where to change the child
+ */
void setChild ( Data && d, int index ) {
setChild ( std::move ( d ), m_children.begin ( ) + index );
}
+ /**
+ * \brief
+ * Getter of an iterator to the begining of children vector
+ *
+ * \return begin iterator
+ */
+ typename ext::ptr_vector < Data >::iterator begin ( ) {
+ return m_children.begin ( );
+ }
+
+ /**
+ * \brief
+ * Getter of an iterator to the begining of children vector
+ *
+ * \return begin iterator
+ */
+ typename ext::ptr_vector < Data >::const_iterator begin ( ) const {
+ return m_children.begin ( );
+ }
+
+ /**
+ * \brief
+ * Getter of an iterator to the end of children vector
+ *
+ * \return end iterator
+ */
+ typename ext::ptr_vector < Data >::iterator end ( ) {
+ return m_children.end ( );
+ }
+
+ /**
+ * \brief
+ * Getter of an iterator to the end of children vector
+ *
+ * \return end iterator
+ */
+ typename ext::ptr_vector < Data >::const_iterator end ( ) const {
+ return m_children.end ( );
+ }
+
};
+/**
+ * \brief
+ * Varary node is tree node that can hold any number of children.
+ *
+ * \tparam Data the base class of the actual tree nodes hierarchy on top of this one
+ * \tparam Cast the actual class from the actual tree nodes hierarchy
+ */
template < class Data, class Cast = Data >
class VararyNode {
+ /**
+ * \brief
+ * Representation of child nodes
+ */
ext::ptr_vector < Data > m_children;
public:
+ /**
+ * \brief
+ * Default constructor. Sets the vector of children to empty vector.
+ */
VararyNode ( ) {
}
+ /**
+ * \brief
+ * Constructor from vector of child nodes.
+ *
+ * \param c the vector of child nodes
+ */
VararyNode ( ext::ptr_vector < Data > c ) : m_children ( std::move ( c ) ) {
for ( Data & child : m_children )
child.parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Destructor of the class.
+ */
virtual ~VararyNode ( ) noexcept {
}
+ /**
+ * \brief
+ * Copy constructor of the class.
+ *
+ * \param other the other instance
+ */
VararyNode ( const VararyNode & other ) : VararyNode ( other.m_children ) {
}
+ /**
+ * \brief
+ * Move constructor of the class.
+ *
+ * \param other the other instance
+ */
VararyNode ( VararyNode && other ) noexcept : VararyNode ( std::move ( other.m_children ) ) {
}
+ /**
+ * \brief
+ * Copy operator of assignment.
+ *
+ * \param other the other instance
+ */
VararyNode & operator =( const VararyNode & other ) {
return * this = VararyNode ( other );
}
+ /**
+ * \brief
+ * Move operator of assignment.
+ *
+ * \param other the other instance
+ */
VararyNode & operator =( VararyNode && other ) noexcept {
using std::swap;
@@ -400,14 +1025,32 @@ public:
return * this;
}
- ext::ptr_vector < Data > & getChildren ( ) {
+ /**
+ * \brief
+ * Getter of the vector of children.
+ *
+ * \return the child nodes
+ */
+ const ext::ptr_vector < Data > & getChildren ( ) {
return m_children;
}
+ /**
+ * \brief
+ * Getter of the vector of children.
+ *
+ * \return the child nodes
+ */
const ext::ptr_vector < Data > & getChildren ( ) const {
return m_children;
}
+ /**
+ * \brief
+ * Setter of the vector of children.
+ *
+ * \param c the new child nodes in for of a vector
+ */
void setChildren ( ext::ptr_vector < Data > c ) {
m_children = std::move ( c );
@@ -415,22 +1058,59 @@ public:
child.parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Setter of the single child of the node.
+ *
+ * \param d the new child node
+ * \param it the position where to change the child
+ */
void setChild ( Data && d, typename ext::ptr_vector < Data >::const_iterator it ) {
m_children.set ( it, std::move ( d ) )->parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Setter of the single child of the node.
+ *
+ * \param d the new child node
+ * \param it the position where to change the child
+ */
void setChild ( const Data & d, typename ext::ptr_vector < Data >::const_iterator it ) {
m_children.set ( it, d )->parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Setter of the single child of the node.
+ *
+ * \param d the new child node
+ * \param index the position where to change the child
+ */
void setChild ( const Data & d, int index ) {
setChild ( d, m_children.begin ( ) + index );
}
+ /**
+ * \brief
+ * Setter of the single child of the node.
+ *
+ * \param d the new child node
+ * \param index the position where to change the child
+ */
void setChild ( Data && d, int index ) {
setChild ( std::move ( d ), m_children.begin ( ) + index );
}
+ /**
+ * \brief
+ * Inserts a new child at position specified by iterator.
+ *
+ * \param it the position where to insert
+ * \param d the new child to insert
+ *
+ * \return the updated iterator to the inserted child
+ */
typename ext::ptr_vector < Data >::iterator insert ( typename ext::ptr_vector < Data >::const_iterator it, const Data & d ) {
typename ext::ptr_vector < Data >::iterator iter = m_children.insert ( it, d );
@@ -439,6 +1119,15 @@ public:
return iter;
}
+ /**
+ * \brief
+ * Inserts a new child at position specified by iterator.
+ *
+ * \param it the position where to insert
+ * \param d the new child to insert
+ *
+ * \return the updated iterator to the inserted child
+ */
typename ext::ptr_vector < Data >::iterator insert ( typename ext::ptr_vector < Data >::const_iterator it, Data && d ) {
typename ext::ptr_vector < Data >::iterator iter = m_children.insert ( it, std::move ( d ) );
@@ -447,6 +1136,18 @@ public:
return iter;
}
+ /**
+ * \brief
+ * Inserts a new children from a given range at position specified by iterator.
+ *
+ * \tparam InputIterator tye type of iterators specifying the range of new children
+ *
+ * \param it the position where to insert
+ * \param first the begining of the children range
+ * \param last the end of the children range
+ *
+ * \return the updated iterator to the inserted child
+ */
template < class InputIterator >
typename ext::ptr_vector < Data >::iterator insert ( typename ext::ptr_vector < Data >::const_iterator it, InputIterator first, InputIterator last ) {
size_t size = std::distance ( first, last );
@@ -460,86 +1161,99 @@ public:
return iter;
}
+ /**
+ * \brief
+ * Erases a child specified by an iterator.
+ *
+ * \param it the position where to insert
+ *
+ * \return the updated iterator to node after the erased one
+ */
+ typename ext::ptr_vector < Data >::iterator erase ( typename ext::ptr_vector < Data >::const_iterator it ) {
+ return m_children.erase ( it );
+ }
+
+ /**
+ * \brief
+ * Erases a range of children specified by an iterator.
+ *
+ * \param first the position where to insert
+ * \param last the position where to insert
+ *
+ * \return the updated iterator to node after the last erased one
+ */
+ typename ext::ptr_vector < Data >::iterator erase ( typename ext::ptr_vector < Data >::const_iterator first, typename ext::ptr_vector < Data >::const_iterator last ) {
+ return m_children.erase ( first, last );
+ }
+
+ /**
+ * \brief
+ * Erases all children.
+ */
+ void clear ( ) {
+ m_children.clear ( );
+ }
+
+ /**
+ * \brief
+ * Appends a new child at the end of the child vector.
+ *
+ * \param d the new child to add
+ */
void pushBackChild ( const Data & d ) {
m_children.push_back ( d );
m_children [ m_children.size ( ) - 1].parent = static_cast < Cast * > ( this );
}
+ /**
+ * \brief
+ * Appends a new child at the end of the child vector.
+ *
+ * \param d the new child to add
+ */
void pushBackChild ( Data && d ) {
m_children.push_back ( std::move ( d ) );
m_children [ m_children.size ( ) - 1].parent = static_cast < Cast * > ( this );
}
-};
-
-template < class Data, class Cast >
-class Tree {
-public:
- static void setChild ( const UnaryNode < Data, Cast > & node, Data child ) {
- const_cast < UnaryNode < Data, Cast > & > ( node ).setChild ( std::move ( child ) );
- }
-
- static void setLeft ( const BinaryNode < Data, Cast > & node, Data child ) {
- const_cast < BinaryNode < Data, Cast > & > ( node ).setLeft ( std::move ( child ) );
- }
-
- static void setRight ( const BinaryNode < Data, Cast > & node, Data child ) {
- const_cast < BinaryNode < Data, Cast > & > ( node ).setRight ( std::move ( child ) );
- }
-
- static void setFirst ( const TernaryNode < Data, Cast > & node, Data child ) {
- const_cast < TernaryNode < Data, Cast > & > ( node ).setFirst ( std::move ( child ) );
- }
-
- static void setSecond ( const TernaryNode < Data, Cast > & node, Data child ) {
- const_cast < TernaryNode < Data, Cast > & > ( node ).setSecond ( std::move ( child ) );
- }
-
- static void setThird ( const TernaryNode < Data, Cast > & node, Data child ) {
- const_cast < TernaryNode < Data, Cast > & > ( node ).setThird ( std::move ( child ) );
- }
-
- template < std::size_t arity >
- static void setChildren ( const AnyaryNode < Data, arity, Cast > & node, ext::ptr_array < Data, arity > children ) {
- const_cast < AnyaryNode < Data, arity, Cast > & > ( node ).setChildren ( std::move ( children ) );
- }
-
- template < class N, std::size_t arity >
- static void setChild ( const AnyaryNode < Data, arity, Cast > & node, Data child ) {
- const_cast < AnyaryNode < Data, arity, Cast > & > ( node ).template setChild < N > ( std::move ( child ) );
- }
-
- static void setChildren ( const FixedaryNode < Data, Cast > & node, ext::ptr_vector < Data > child ) {
- const_cast < FixedaryNode < Data, Cast > & > ( node ).setChildren ( std::move ( child ) );
- }
-
- static void setChild ( const FixedaryNode < Data, Cast > & node, Data && child, int index ) {
- const_cast < FixedaryNode < Data, Cast > & > ( node ).setChild ( std::move ( child ), index );
- }
-
- static void setChildren ( const VararyNode < Data, Cast > & node, ext::ptr_vector < Data > children ) {
- const_cast < VararyNode < Data, Cast > & > ( node ).setChildren ( std::move ( children ) );
- }
-
- static void setChild ( const VararyNode < Data, Cast > & node, Data && child, int index ) {
- const_cast < VararyNode < Data, Cast > & > ( node ).setChild ( std::move ( child ), index );
- }
-
- static void setChild ( const VararyNode < Data, Cast > & node, Data && child, typename ext::ptr_vector < Data >::iterator it ) {
- const_cast < VararyNode < Data, Cast > & > ( node ).setChild ( std::move ( child ), it );
- }
-
- typename ext::ptr_vector < Data >::iterator insert ( const VararyNode < Data, Cast > & node, typename ext::ptr_vector < Data >::iterator it, Data && child ) {
- const_cast < VararyNode < Data, Cast > & > ( node ).insert ( it, std::move ( child ) );
- }
-
- template < class InputIterator >
- typename ext::ptr_vector < Data >::iterator insert ( const VararyNode < Data, Cast > & node, typename ext::ptr_vector < Data >::iterator it, InputIterator first, InputIterator last ) {
- const_cast < VararyNode < Data, Cast > & > ( node ).insert ( it, first, last );
- }
-
- static void pushBackChild ( const VararyNode < Data, Cast > & node, Data && child ) {
- const_cast < VararyNode < Data, Cast > & > ( node ).pushBackChild ( std::move ( child ) );
+ /**
+ * \brief
+ * Getter of an iterator to the begining of children vector
+ *
+ * \return begin iterator
+ */
+ typename ext::ptr_vector < Data >::iterator begin ( ) {
+ return m_children.begin ( );
+ }
+
+ /**
+ * \brief
+ * Getter of an iterator to the begining of children vector
+ *
+ * \return begin iterator
+ */
+ typename ext::ptr_vector < Data >::const_iterator begin ( ) const {
+ return m_children.begin ( );
+ }
+
+ /**
+ * \brief
+ * Getter of an iterator to the end of children vector
+ *
+ * \return end iterator
+ */
+ typename ext::ptr_vector < Data >::iterator end ( ) {
+ return m_children.end ( );
+ }
+
+ /**
+ * \brief
+ * Getter of an iterator to the end of children vector
+ *
+ * \return end iterator
+ */
+ typename ext::ptr_vector < Data >::const_iterator end ( ) const {
+ return m_children.end ( );
}
};
diff --git a/alib2std/test-src/extensions/TreeBaseTest.cpp b/alib2std/test-src/extensions/TreeBaseTest.cpp
index d79ff277fe..5dde60d3d0 100644
--- a/alib2std/test-src/extensions/TreeBaseTest.cpp
+++ b/alib2std/test-src/extensions/TreeBaseTest.cpp
@@ -27,7 +27,7 @@ void TreeBaseTest::testRegexps ( ) {
RegExpSymbol s ( 'x' );
const RegExpSymbol & sr = s;
- sr.getElements ( );
+ sr.getChildren ( );
RegExpAlternation alter ( std::move ( iter ), std::move ( iter2 ) );
for ( const RegExpElement & element : alter.getChildren ( ) ) {
--
GitLab