diff --git a/alib2std/src/extensions/tree_base.hpp b/alib2std/src/extensions/tree_base.hpp
index baa7b43bc741ad99b869f53d69895ed7060dea5c..8f22a8d7cdb63c9bf7f9e7724a363b5deef912e6 100644
--- a/alib2std/src/extensions/tree_base.hpp
+++ b/alib2std/src/extensions/tree_base.hpp
@@ -8,8 +8,8 @@
 #ifndef __TREE_BASE_HPP_
 #define __TREE_BASE_HPP_
 
-#include "array.hpp"
-#include "vector.hpp"
+#include "ptr_vector.hpp"
+#include "ptr_array.hpp"
 
 namespace ext {
 
@@ -17,19 +17,19 @@ template < class Data >
 class BaseNode {
 	Data * parent;
 
-	template < class D, class CD, class C >
+	template < class D, class C >
 	friend class NullaryNode;
-	template < class D, class CD, class C >
+	template < class D, class C >
 	friend class UnaryNode;
-	template < class D, class CD, class C >
+	template < class D, class C >
 	friend class BinaryNode;
-	template < class D, class CD, class C >
+	template < class D, class C >
 	friend class TernaryNode;
-	template < class D, int I, class CD, class C >
+	template < class D, std::size_t I, class C >
 	friend class AnyaryNode;
-	template < class D, class CD, class C >
+	template < class D, class C >
 	friend class FixedaryNode;
-	template < class D, class CD, class C >
+	template < class D, class C >
 	friend class VararyNode;
 
 	Data * operator ->( ) {
@@ -71,42 +71,27 @@ public:
 
 };
 
-template < class Data, int arity, class ConstData = Data, class Cast = Data >
+template < class Data, std::size_t arity, class Cast = Data >
 class AnyaryNode {
-	typedef ext::array < Data, arity > ChildrenType;
-	typedef ext::array < ConstData, arity > ConstChildrenType;
+	ext::ptr_array < Data, arity > m_children;
 
-	union ChildrenUnion {
-		ChildrenType children;
-		ConstChildrenType const_children;
-
-		ChildrenUnion ( ) : children ( ) { }
-		ChildrenUnion ( ChildrenType data ) : children ( std::move ( data ) ) { }
-
-		~ChildrenUnion ( ) {
-			children.~ChildrenType();
-		}
-	};
-
-	ChildrenUnion children_union;
-
-	template < std::size_t ... Indices >
-	void setParent ( std::index_sequence < Indices ... > ) {
-		( void ) std::initializer_list < void * > { std::get < Indices > ( children_union.children )->parent = static_cast < Cast * > ( this ) ... };
+	void setParents ( ) {
+		for ( Data & child : m_children )
+			child->parent = static_cast < Cast * > ( this );
 	}
 
 public:
-	AnyaryNode ( ext::array < Data, arity > c ) : children_union ( std::move ( c ) ) {
-		setParent ( std::make_index_sequence < arity > ( ) );
+	AnyaryNode ( ext::ptr_array < Data, arity > c ) : m_children ( std::move ( c ) ) {
+		setParents ( );
 	}
 
 	virtual ~AnyaryNode ( ) noexcept {
 	}
 
-	AnyaryNode ( const AnyaryNode & other ) : AnyaryNode ( other.children_union.children ) {
+	AnyaryNode ( const AnyaryNode & other ) : AnyaryNode ( other.m_children ) {
 	}
 
-	AnyaryNode ( AnyaryNode && other ) noexcept : AnyaryNode ( std::move ( other.children_union.children ) ) {
+	AnyaryNode ( AnyaryNode && other ) noexcept : AnyaryNode ( std::move ( other.m_children ) ) {
 	}
 
 	AnyaryNode & operator =( const AnyaryNode & other ) {
@@ -116,87 +101,107 @@ public:
 	AnyaryNode & operator =( AnyaryNode && other ) noexcept {
 		using std::swap;
 
-		swap ( this->children_union.children, other.children_union.children );
+		swap ( this->m_children, other.m_children );
 
-		setParent ( std::make_index_sequence < arity > ( ) );
+		setParents ( );
 
 		return * this;
 	}
 
-	const ext::array < Data, arity > & getElements ( ) {
-		return children_union.children;
+	const ext::ptr_array < Data, arity > & getElements ( ) {
+		return m_children;
 	}
 
-	const ext::array < ConstData, arity > & getElements ( ) const {
-		return children_union.const_children;
+	const ext::ptr_array < Data, arity > & getElements ( ) const {
+		return m_children;
 	}
 
 	template < int N >
-	const ConstData & getElement ( ) const {
-		return std::get < N > ( children_union.const_children );
+	const Data & getElement ( ) const {
+		return std::get < N > ( m_children );
 	}
 
 	template < int N >
 	Data & getElement ( ) {
-		return std::get < N > ( children_union.children );
+		return std::get < N > ( m_children );
+	}
+
+	void setElements ( ext::ptr_array < Data, arity > c ) {
+		m_children = std::move ( c );
+		setParents ( );
 	}
 
-	void setElements ( ext::array < Data, arity > c ) {
-		children_union.children = std::move ( c );
-		setParent ( std::make_index_sequence < arity > ( ) );
+	template < int N >
+	void setElement ( const Data & d ) {
+		m_children.set ( m_children.cbegin ( ) + N, d );
+		std::get < N > ( m_children )->parent = static_cast < Cast * > ( this );
 	}
 
 	template < int N >
-	void setElement ( Data d ) {
-		std::get < N > ( children_union.children ) = std::move ( d );
-		std::get < N > ( children_union.children )->parent = static_cast < Cast * > ( this );
+	void setElement ( Data && d ) {
+		m_children.set ( m_children.cbegin ( ) + N, std::move ( d ) );
+		std::get < N > ( m_children )->parent = static_cast < Cast * > ( this );
 	}
 
 };
 
-template < class Data, class ConstData = Data, class Cast = Data >
-class NullaryNode : public AnyaryNode < Data, 0, ConstData, Cast > {
+template < class Data, class Cast = Data >
+class NullaryNode : public AnyaryNode < Data, 0, Cast > {
 public:
-	NullaryNode ( ) : AnyaryNode < Data, 0, ConstData, Cast > ( ext::make_array < Data > ( ) ) {
+	NullaryNode ( ) : AnyaryNode < Data, 0, Cast > ( ext::make_ptr_array < Data > ( ) ) {
 	}
 
 };
 
-template < class Data, class ConstData = Data, class Cast = Data >
-class UnaryNode : public AnyaryNode < Data, 1, ConstData, Cast > {
+template < class Data, class Cast = Data >
+class UnaryNode : public AnyaryNode < Data, 1, Cast > {
 public:
-	UnaryNode ( Data c ) : AnyaryNode < Data, 1, ConstData, Cast > ( ext::make_array ( std::move ( c ) ) ) {
+	UnaryNode ( const Data & c ) : AnyaryNode < Data, 1, Cast > ( ext::make_ptr_array ( c ) ) {
+	}
+
+	UnaryNode ( Data && c ) : AnyaryNode < Data, 1, Cast > ( ext::make_ptr_array ( std::move ( c ) ) ) {
 	}
 
 	Data & getChild ( ) {
 		return this->template getElement < 0 > ( );
 	}
 
-	const ConstData & getChild ( ) const {
+	const Data & getChild ( ) const {
 		return this->template getElement < 0 > ( );
 	}
 
-	void setChild ( Data c ) {
+	void setChild ( const Data & c ) {
+		this->template setElement < 0 > ( c );
+	}
+
+	void setChild ( Data && c ) {
 		this->template setElement < 0 > ( std::move ( c ) );
 	}
 
 };
 
-template < class Data, class ConstData = Data, class Cast = Data >
-class BinaryNode : public AnyaryNode < Data, 2, ConstData, Cast > {
+template < class Data, class Cast = Data >
+class BinaryNode : public AnyaryNode < Data, 2, Cast > {
 public:
-	BinaryNode ( Data l, Data r ) : AnyaryNode < Data, 2, ConstData, Cast > ( ext::make_array ( std::move ( l ), std::move ( r ) ) ) {
+	BinaryNode ( const Data & l, const Data & r ) : AnyaryNode < Data, 2, Cast > ( ext::make_ptr_array ( l, r ) ) {
+	}
+
+	BinaryNode ( Data && l, Data && r ) : AnyaryNode < Data, 2, Cast > ( ext::make_ptr_array ( std::move ( l ), std::move ( r ) ) ) {
 	}
 
 	Data & getLeft ( ) {
 		return this->template getElement < 0 > ( );
 	}
 
-	const ConstData & getLeft ( ) const {
+	const Data & getLeft ( ) const {
 		return this->template getElement < 0 > ( );
 	}
 
-	void setLeft ( Data l ) {
+	void setLeft ( const Data & l ) {
+		this->template setElement < 0 > ( l );
+	}
+
+	void setLeft ( Data && l ) {
 		this->template setElement < 0 > ( std::move ( l ) );
 	}
 
@@ -204,31 +209,42 @@ public:
 		return this->template getElement < 1 > ( );
 	}
 
-	const ConstData & getRight ( ) const {
+	const Data & getRight ( ) const {
 		return this->template getElement < 1 > ( );
 	}
 
-	void setRight ( Data r ) {
+	void setRight ( const Data & r ) {
+		this->template setElement < 1 > ( r );
+	}
+
+	void setRight ( Data && r ) {
 		this->template setElement < 1 > ( std::move ( r ) );
 	}
 
 };
 
-template < class Data, class ConstData = Data, class Cast = Data >
-class TernaryNode : public AnyaryNode < Data, 3, ConstData, Cast > {
+template < class Data, class Cast = Data >
+class TernaryNode : public AnyaryNode < Data, 3, Cast > {
 public:
-	TernaryNode ( Data f, Data s, Data t ) : AnyaryNode < Data, 3, ConstData, Cast > ( ext::make_array ( std::move ( f ), std::move ( s ), std::move ( t ) ) ) {
+	TernaryNode ( const Data & f, const Data & s, const Data & t ) : AnyaryNode < Data, 3, Cast > ( ext::make_ptr_array ( f, s, t ) ) {
+	}
+
+	TernaryNode ( Data && f, Data && s, Data && t ) : AnyaryNode < Data, 3, Cast > ( ext::make_ptr_array ( std::move ( f ), std::move ( s ), std::move ( t ) ) ) {
 	}
 
 	Data & getFirst ( ) {
 		return this->template getElement < 0 > ( );
 	}
 
-	const ConstData & getFirst ( ) const {
+	const Data & getFirst ( ) const {
 		return this->template getElement < 0 > ( );
 	}
 
-	void setFirst ( Data f ) {
+	void setFirst ( const Data & f ) {
+		this->template setElement < 0 > ( f );
+	}
+
+	void setFirst ( Data && f ) {
 		this->template setElement < 0 > ( std::move ( f ) );
 	}
 
@@ -236,11 +252,15 @@ public:
 		return this->template getElement < 1 > ( );
 	}
 
-	const ConstData & getSecond ( ) const {
+	const Data & getSecond ( ) const {
 		return this->template getElement < 1 > ( );
 	}
 
-	void setSecond ( Data s ) {
+	void setSecond ( const Data & s ) {
+		this->template setElement < 1 > ( s );
+	}
+
+	void setSecond ( Data && s ) {
 		this->template setElement < 1 > ( std::move ( s ) );
 	}
 
@@ -248,31 +268,23 @@ public:
 		return this->template getElement < 2 > ( );
 	}
 
-	const ConstData & getThird ( ) const {
+	const Data & getThird ( ) const {
 		return this->template getElement < 2 > ( );
 	}
 
-	void setThird ( Data t ) {
+	void setThird ( const Data & t ) {
+		this->template setElement < 2 > ( t );
+	}
+
+	void setThird ( Data && t ) {
 		this->template setElement < 2 > ( std::move ( t ) );
 	}
 
 };
 
-template < class Data, class ConstData = Data, class Cast = Data >
+template < class Data, class Cast = Data >
 class FixedaryNode {
-	union ChildrenUnion {
-		ext::vector < Data > children;
-		ext::vector < ConstData > const_children;
-
-		ChildrenUnion ( ) : children ( ) { }
-		ChildrenUnion ( ext::vector < Data > data ) : children ( std::move ( data ) ) { }
-
-		~ChildrenUnion ( ) {
-			children.~vector();
-		}
-	};
-
-	ChildrenUnion children_union;
+	ext::ptr_vector < Data > m_children;
 
 public:
 	template < typename ... Types >
@@ -280,24 +292,24 @@ public:
 		Data args[] { std::move ( data ) ... };
 
 		for ( Data & child : args )
-			children_union.children.push_back ( std::move ( child ) );
+			m_children.push_back ( std::move ( child ) );
 
-		for ( Data & child : children_union.children )
-			child->parent = static_cast < Cast * > ( this );
+		for ( Data & child : m_children )
+			child.parent = static_cast < Cast * > ( this );
 	}
 
-	FixedaryNode ( ext::vector < Data > c ) : children_union ( std::move ( c ) ) {
-		for ( Data & child : children_union.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 );
 	}
 
 	virtual ~FixedaryNode ( ) noexcept {
 	}
 
-	FixedaryNode ( const FixedaryNode & other ) : FixedaryNode ( other.children_union.children ) {
+	FixedaryNode ( const FixedaryNode & other ) : FixedaryNode ( other.m_children ) {
 	}
 
-	FixedaryNode ( FixedaryNode && other ) noexcept : FixedaryNode ( std::move ( other.children_union.children ) ) {
+	FixedaryNode ( FixedaryNode && other ) noexcept : FixedaryNode ( std::move ( other.m_children ) ) {
 	}
 
 	FixedaryNode & operator =( const FixedaryNode & other ) {
@@ -307,75 +319,70 @@ public:
 	FixedaryNode & operator =( FixedaryNode && other ) noexcept {
 		using std::swap;
 
-		swap ( this->children_union.children, other.children_union.children );
+		swap ( this->m_children, other.m_children );
 
-		for ( Data & child : children_union.children )
-			child->parent = static_cast < Cast * > ( this );
+		for ( Data & child : m_children )
+			child.parent = static_cast < Cast * > ( this );
 
 		return * this;
 	}
 
-	ext::vector < Data > & getChildren ( ) {
-		return children_union.children;
+	ext::ptr_vector < Data > & getChildren ( ) {
+		return m_children;
 	}
 
-	const ext::vector < ConstData > & getChildren ( ) const {
-		return children_union.const_children;
+	const ext::ptr_vector < Data > & getChildren ( ) const {
+		return m_children;
 	}
 
-	void setChildren ( ext::vector < Data > c ) {
-		if ( c.size ( ) != children_union.children.size ( ) )
+	void setChildren ( ext::ptr_vector < Data > c ) {
+		if ( c.size ( ) != m_children.size ( ) )
 			throw "Arity != size";
 
-		children_union.children = std::move ( c );
+		m_children = std::move ( c );
 
-		for ( Data & child : children_union.children )
+		for ( Data & child : m_children )
 			child->parent = static_cast < Cast * > ( this );
 	}
 
-	void setChild ( Data d, int index ) {
-		if ( children_union.children.size ( ) >= index )
-			throw "Index out of bounds";
+	void setChild ( Data && d, typename ext::ptr_vector < Data >::const_iterator it ) {
+		m_children.set ( it, std::move ( d ) )->parent = static_cast < Cast * > ( this );
+	}
+
+	void setChild ( const Data & d, typename ext::ptr_vector < Data >::const_iterator it ) {
+		m_children.set ( it, d )->parent = static_cast < Cast * > ( this );
+	}
 
-		children_union.children[index] = std::move ( d );
+	void setChild ( const Data & d, int index ) {
+		setChild ( d, m_children.begin ( ) + index );
+	}
 
-		children_union.children[index]->parent = static_cast < Cast * > ( this );
+	void setChild ( Data && d, int index ) {
+		setChild ( std::move ( d ), m_children.begin ( ) + index );
 	}
 
 };
 
-template < class Data, class ConstData = Data, class Cast = Data >
+template < class Data, class Cast = Data >
 class VararyNode {
-	union ChildrenUnion {
-		ext::vector < Data > children;
-		ext::vector < ConstData > const_children;
-
-		ChildrenUnion ( ) : children ( ) { }
-		ChildrenUnion ( ext::vector < Data > data ) : children ( std::move ( data ) ) { }
-
-		~ChildrenUnion ( ) {
-			children.~vector();
-		}
-	};
-
-	ChildrenUnion children_union;
+	ext::ptr_vector < Data > m_children;
 
 public:
 	VararyNode ( ) {
 	}
 
-	VararyNode ( ext::vector < Data > c ) : children_union ( std::move ( c ) ) {
-		for ( Data & child : children_union.children )
-			child->parent = static_cast < Cast * > ( this );
+	VararyNode ( ext::ptr_vector < Data > c ) : m_children ( std::move ( c ) ) {
+		for ( Data & child : m_children )
+			child.parent = static_cast < Cast * > ( this );
 	}
 
 	virtual ~VararyNode ( ) noexcept {
 	}
 
-	VararyNode ( const VararyNode & other ) : VararyNode ( other.children_union.children ) {
+	VararyNode ( const VararyNode & other ) : VararyNode ( other.m_children ) {
 	}
 
-	VararyNode ( VararyNode && other ) noexcept : VararyNode ( std::move ( other.children_union.children ) ) {
+	VararyNode ( VararyNode && other ) noexcept : VararyNode ( std::move ( other.m_children ) ) {
 	}
 
 	VararyNode & operator =( const VararyNode & other ) {
@@ -385,141 +392,154 @@ public:
 	VararyNode & operator =( VararyNode && other ) noexcept {
 		using std::swap;
 
-		swap ( this->children_union.children, other.children_union.children );
+		swap ( this->m_children, other.m_children );
 
-		for ( Data & child : children_union.children )
-			child->parent = static_cast < Cast * > ( this );
+		for ( Data & child : m_children )
+			child.parent = static_cast < Cast * > ( this );
 
 		return * this;
 	}
 
-	ext::vector < Data > & getChildren ( ) {
-		return children_union.children;
+	ext::ptr_vector < Data > & getChildren ( ) {
+		return m_children;
 	}
 
-	const ext::vector < ConstData > & getChildren ( ) const {
-		return children_union.const_children;
+	const ext::ptr_vector < Data > & getChildren ( ) const {
+		return m_children;
 	}
 
-	void setChildren ( ext::vector < Data > c ) {
-		children_union.children = std::move ( c );
+	void setChildren ( ext::ptr_vector < Data > c ) {
+		m_children = std::move ( c );
 
-		for ( Data & child : children_union.children )
-			child->parent = static_cast < Cast * > ( this );
+		for ( Data & child : m_children )
+			child.parent = static_cast < Cast * > ( this );
 	}
 
-	void setChild ( Data d, int index ) {
-		children_union.children[index] = std::move ( d );
+	void setChild ( Data && d, typename ext::ptr_vector < Data >::const_iterator it ) {
+		m_children.set ( it, std::move ( d ) )->parent = static_cast < Cast * > ( this );
+	}
 
-		children_union.children[index]->parent = static_cast < Cast * > ( this );
+	void setChild ( const Data & d, typename ext::ptr_vector < Data >::const_iterator it ) {
+		m_children.set ( it, d )->parent = static_cast < Cast * > ( this );
 	}
 
-	void setChild ( Data d, typename ext::vector < Data >::iterator it ) {
-		* it = std::move ( d );
+	void setChild ( const Data & d, int index ) {
+		setChild ( d, m_children.begin ( ) + index );
+	}
 
-		( * it )->parent = static_cast < Cast * > ( this );
+	void setChild ( Data && d, int index ) {
+		setChild ( std::move ( d ), m_children.begin ( ) + index );
 	}
 
-	typename ext::vector < Data >::iterator insert ( typename ext::vector < Data >::iterator it, Data d ) {
-		it = children_union.children.insert ( it, std::move ( d ) );
+	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 );
 
-		( * std::prev ( it ) )->parent = static_cast < Cast * > ( this );
+		iter->parent = static_cast < Cast * > ( this );
 
-		return it;
+		return iter;
+	}
+
+	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 ) );
+
+		iter->parent = static_cast < Cast * > ( this );
+
+		return iter;
 	}
 
 	template < class InputIterator >
-	typename ext::vector < Data >::iterator insert ( typename ext::vector < Data >::iterator it, InputIterator first, InputIterator last ) {
-		size_t off = it - children_union.children.begin ( );
-		size_t size = last - first;
+	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 );
 
-		children_union.children.insert ( it, first, last );
-		it = children_union.children.begin ( ) + off;
+		typename ext::ptr_vector < Data >::iterator iter = m_children.insert ( it, first, last );
 
-		 // TODO on g++-4.9 use: it = children_union.children.insert( it, first, last );
-		typename ext::vector < Data >::iterator end = it + size;
+		for ( size_t i = 0; i < size; ++ i ) {
+			( iter + i )->parent = static_cast < Cast * > ( this );
+		}
 
-		for ( ; it != end; it++ )
-			( * it )->parent = static_cast < Cast * > ( this );
+		return iter;
+	}
 
-		return it;
+	void pushBackChild ( const Data & d ) {
+		m_children.push_back ( d );
+		m_children [ m_children.size ( ) - 1].parent = static_cast < Cast * > ( this );
 	}
 
-	void pushBackChild ( Data d ) {
-		children_union.children.push_back ( std::move ( d ) );
-		children_union.children[children_union.children.size ( ) - 1]->parent = static_cast < Cast * > ( this );
+	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 ConstData, class Cast >
+template < class Data, class Cast >
 class Tree {
 public:
-	static void setChild ( const UnaryNode < Data, ConstData, Cast > & node, Data child ) {
-		const_cast < UnaryNode < Data, ConstData, Cast > & > ( node ).setChild ( std::move ( child ) );
+	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, ConstData, Cast > & node, Data child ) {
-		const_cast < BinaryNode < Data, ConstData, Cast > & > ( node ).setLeft ( 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, ConstData, Cast > & node, Data child ) {
-		const_cast < BinaryNode < Data, ConstData, Cast > & > ( node ).setRight ( 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, ConstData, Cast > & node, Data child ) {
-		const_cast < TernaryNode < Data, ConstData, Cast > & > ( node ).setFirst ( 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, ConstData, Cast > & node, Data child ) {
-		const_cast < TernaryNode < Data, ConstData, Cast > & > ( node ).setSecond ( 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, ConstData, Cast > & node, Data child ) {
-		const_cast < TernaryNode < Data, ConstData, Cast > & > ( node ).setThird ( std::move ( child ) );
+	static void setThird ( const TernaryNode < Data, Cast > & node, Data child ) {
+		const_cast < TernaryNode < Data, Cast > & > ( node ).setThird ( std::move ( child ) );
 	}
 
-	template < int arity >
-	static void setChildren ( const AnyaryNode < Data, arity, ConstData, Cast > & node, ext::array < Data, arity > children ) {
-		const_cast < AnyaryNode < Data, arity, ConstData, Cast > & > ( node ).setChildren ( std::move ( children ) );
+	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, int arity >
-	static void setChild ( const AnyaryNode < Data, arity, ConstData, Cast > & node, Data child ) {
-		const_cast < AnyaryNode < Data, arity, ConstData, Cast > & > ( node ).template setChild < N > ( std::move ( child ) );
+	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, ConstData, Cast > & node, ext::vector < Data > child ) {
-		const_cast < FixedaryNode < Data, ConstData, Cast > & > ( node ).setChildren ( 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, ConstData, Cast > & node, Data child, int index ) {
-		const_cast < FixedaryNode < Data, ConstData, Cast > & > ( node ).setChild ( std::move ( child ), index );
+	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, ConstData, Cast > & node, ext::vector < Data > children ) {
-		const_cast < VararyNode < Data, ConstData, Cast > & > ( node ).setChildren ( std::move ( children ) );
+	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, ConstData, Cast > & node, Data child, int index ) {
-		const_cast < VararyNode < Data, ConstData, Cast > & > ( node ).setChild ( std::move ( child ), index );
+	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, ConstData, Cast > & node, Data child, typename ext::vector < Data >::iterator it ) {
-		const_cast < VararyNode < Data, ConstData, Cast > & > ( node ).setChild ( std::move ( child ), it );
+	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::vector < Data >::iterator insert ( const VararyNode < Data, ConstData, Cast > & node, typename ext::vector < Data >::iterator it, Data child ) {
-		const_cast < VararyNode < Data, ConstData, Cast > & > ( node ).insert ( it, std::move ( child ) );
+	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::vector < Data >::iterator insert ( const VararyNode < Data, ConstData, Cast > & node, typename ext::vector < Data >::iterator it, InputIterator first, InputIterator last ) {
-		const_cast < VararyNode < Data, ConstData, Cast > & > ( node ).insert ( it, first, last );
+	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, ConstData, Cast > & node, Data child ) {
-		const_cast < VararyNode < Data, ConstData, Cast > & > ( node ).pushBackChild ( std::move ( child ) );
+	static void pushBackChild ( const VararyNode < Data, Cast > & node, Data && child ) {
+		const_cast < VararyNode < Data, Cast > & > ( node ).pushBackChild ( std::move ( child ) );
 	}
 
 };
diff --git a/alib2std/test-src/extensions/TreeBaseTest.cpp b/alib2std/test-src/extensions/TreeBaseTest.cpp
index 1c3e8c52994265e8757de0090c68ec48312ba34e..d79ff277fe1953cbfa09d51bbd0d4f7a2e81b1db 100644
--- a/alib2std/test-src/extensions/TreeBaseTest.cpp
+++ b/alib2std/test-src/extensions/TreeBaseTest.cpp
@@ -10,24 +10,29 @@ void TreeBaseTest::tearDown ( ) {
 }
 
 void TreeBaseTest::testRegexps ( ) {
-	RegExpIteration iter ( std::shared_ptr < RegExpElement > ( new RegExpEmpty ( ) ) );
+	RegExpIteration iter = RegExpEmpty ( );
 
-	CPPUNIT_ASSERT ( iter.getChild ( )->getParent ( ) == & iter );
+	CPPUNIT_ASSERT ( iter.getChild ( ).getParent ( ) == & iter );
 
-	RegExpIteration iter2 ( iter );
-	RegExpIteration iter3 ( iter2 );
+	RegExpIteration iter2 = iter;
+	RegExpIteration iter3 = iter2;
 
-	CPPUNIT_ASSERT ( iter3.getChild ( )->getParent ( ) == & iter3 );
+	CPPUNIT_ASSERT ( iter3.getChild ( ).getParent ( ) == & iter3 );
 
 	iter3 = iter;
-	RegExpIteration iter4 ( std::shared_ptr < RegExpElement > ( new RegExpEpsilon ( ) ) );
+	RegExpIteration iter4 = RegExpEpsilon ( );
 	iter3 = iter4;
 
-	CPPUNIT_ASSERT ( iter3.getChild ( )->getParent ( ) == & iter3 );
+	CPPUNIT_ASSERT ( iter3.getChild ( ).getParent ( ) == & iter3 );
 
 	RegExpSymbol s ( 'x' );
 	const RegExpSymbol & sr = s;
 	sr.getElements ( );
+
+	RegExpAlternation alter ( std::move ( iter ), std::move ( iter2 ) );
+	for ( const RegExpElement & element : alter.getChildren ( ) ) {
+		CPPUNIT_ASSERT ( element.getParent ( ) == & alter );
+	}
 }
 
 void TreeBaseTest::testRankedTree ( ) {
diff --git a/alib2std/test-src/extensions/TreeBaseTest.h b/alib2std/test-src/extensions/TreeBaseTest.h
index ea7d0e1f2c712317c4e2d734441ac1f2faa10547..896b2e61ae19c6634584d6230c042df65a1bc2d3 100644
--- a/alib2std/test-src/extensions/TreeBaseTest.h
+++ b/alib2std/test-src/extensions/TreeBaseTest.h
@@ -16,24 +16,32 @@ public:
 	class RegExpElement : public ext::BaseNode < RegExpElement > {
 	};
 
-	class RegExpAlternation : public RegExpElement {
+	class RegExpAlternation : public RegExpElement, public ext::VararyNode < RegExpElement, RegExpAlternation > {
+	public:
+		RegExpAlternation ( RegExpElement && left, RegExpElement && right ) : VararyNode < RegExpElement, RegExpAlternation > ( ) {
+			pushBackChild ( std::move ( left ) );
+			pushBackChild ( std::move ( right ) );
+		}
+
 	};
 
-	class RegExpConcatenation : public RegExpElement, public ext::BinaryNode < std::shared_ptr < RegExpElement >, std::shared_ptr < const RegExpElement >, RegExpConcatenation > {
+
+	class RegExpConcatenation : public RegExpElement, public ext::BinaryNode < RegExpElement, RegExpConcatenation > {
 	public:
-		RegExpConcatenation ( std::shared_ptr < RegExpElement > left, std::shared_ptr < RegExpElement > right ) : BinaryNode < std::shared_ptr < RegExpElement >, std::shared_ptr < const RegExpElement >, RegExpConcatenation > ( std::move ( left ), std::move ( right ) ) {
+		RegExpConcatenation ( RegExpElement && left, RegExpElement && right ) : BinaryNode < RegExpElement, RegExpConcatenation > ( std::move ( left ), std::move ( right ) ) {
 		}
 
 	};
 
-	class RegExpIteration : public RegExpElement, public ext::UnaryNode < std::shared_ptr < RegExpElement >, std::shared_ptr < const RegExpElement >, RegExpIteration > {
+	class RegExpIteration : public RegExpElement, public ext::UnaryNode < RegExpElement, RegExpIteration > {
 	public:
-		RegExpIteration ( std::shared_ptr < RegExpElement > element ) : UnaryNode < std::shared_ptr < RegExpElement >, std::shared_ptr < const RegExpElement >, RegExpIteration > ( std::move ( element ) ) {
+		RegExpIteration ( RegExpElement && element ) : UnaryNode < RegExpElement, RegExpIteration > ( std::move ( element ) ) {
+			std::cout << "Here" << std::endl;
 		}
 
 	};
 
-	class RegExpSymbol : public RegExpElement, public ext::NullaryNode < std::shared_ptr < RegExpElement >, std::shared_ptr < const RegExpElement >, RegExpSymbol > {
+	class RegExpSymbol : public RegExpElement, public ext::NullaryNode < RegExpElement, RegExpSymbol > {
 		char m_symbol;
 
 	public:
@@ -60,7 +68,7 @@ public:
 		char m_symbol;
 
 	public:
-		UnrankedTreeNode ( char symbol, ext::vector < UnrankedTreeNode > c ) : VararyNode < UnrankedTreeNode > ( std::move ( c ) ), m_symbol ( symbol ) {
+		UnrankedTreeNode ( char symbol, ext::ptr_vector < UnrankedTreeNode > c ) : VararyNode < UnrankedTreeNode > ( std::move ( c ) ), m_symbol ( symbol ) {
 		}
 
 		char getSymbol ( ) const {
@@ -78,7 +86,7 @@ public:
 		unsigned m_arity;
 
 	public:
-		RankedTreeNode ( char symbol, unsigned arity, ext::vector < RankedTreeNode > c ) : FixedaryNode < RankedTreeNode > ( std::move ( c ) ), m_symbol ( symbol ), m_arity ( arity ) {
+		RankedTreeNode ( char symbol, unsigned arity, ext::ptr_vector < RankedTreeNode > c ) : FixedaryNode < RankedTreeNode > ( std::move ( c ) ), m_symbol ( symbol ), m_arity ( arity ) {
 			if ( getChildren ( ).size ( ) != m_arity )
 				throw "Arity != size";
 		}