diff --git a/alib2algo/src/regexp/simplify/RegExpOptimizeFormalPart.hpp b/alib2algo/src/regexp/simplify/RegExpOptimizeFormalPart.hpp
index 0bdcc00213cbad151abe804932f3dbde0ae58693..99cb478f5b3591c1da780af07e22de399fb69d66 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimizeFormalPart.hpp
+++ b/alib2algo/src/regexp/simplify/RegExpOptimizeFormalPart.hpp
@@ -73,13 +73,13 @@ bool RegExpOptimize::S( FormalRegExpElement < SymbolType > * & node ) {
 		FormalRegExpElement < SymbolType > * tmp = optimizeInner ( alternation->getLeftElement ( ) );
 		if(* tmp != alternation->getLeftElement ( ) ) {
 			optimized = true;
-			alternation->setLeftElement ( * std::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
+			alternation->setLeftElement ( * ext::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
 		}
 
 		tmp = optimizeInner ( alternation->getRightElement ( ) );
 		if(* tmp != alternation->getRightElement ( ) ) {
 			optimized = true;
-			alternation->setRightElement ( * std::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
+			alternation->setRightElement ( * ext::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
 		}
 
 		return optimized;
@@ -90,13 +90,13 @@ bool RegExpOptimize::S( FormalRegExpElement < SymbolType > * & node ) {
 		FormalRegExpElement < SymbolType >* tmp = optimizeInner ( concatenation->getLeftElement() );
 		if(* tmp != concatenation->getLeftElement ( ) ) {
 			optimized = true;
-			concatenation->setLeftElement ( * std::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
+			concatenation->setLeftElement ( * ext::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
 		}
 
 		tmp = optimizeInner ( concatenation->getRightElement ( ));
 		if(* tmp != concatenation->getRightElement ( )) {
 			optimized = true;
-			concatenation->setRightElement ( * std::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
+			concatenation->setRightElement ( * ext::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
 		}
 
 		return optimized;
@@ -108,7 +108,7 @@ bool RegExpOptimize::S( FormalRegExpElement < SymbolType > * & node ) {
 
 		if(* tmp != iteration->getElement ( ) ) {
 			optimized = true;
-			iteration->setElement ( * std::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
+			iteration->setElement ( * ext::smart_ptr < FormalRegExpElement < SymbolType > > ( tmp ) );
 		}
 		return optimized;
 	}
@@ -128,11 +128,11 @@ bool RegExpOptimize::A1( FormalRegExpElement < SymbolType > * & n ) {
 	if( ! node ) return false;
 
 	if( dynamic_cast<FormalRegExpAlternation < SymbolType > *>( node->getLeft().get() ) ) {
-		std::smart_ptr < FormalRegExpAlternation < SymbolType > > leftAlt ( static_cast<FormalRegExpAlternation < SymbolType > *>( node->getLeft().release() ) );
+		ext::smart_ptr < FormalRegExpAlternation < SymbolType > > leftAlt ( static_cast<FormalRegExpAlternation < SymbolType > *>( node->getLeft().release() ) );
 
-		std::smart_ptr < FormalRegExpElement < SymbolType > > x = std::move ( leftAlt->getLeft() );
-		std::smart_ptr < FormalRegExpElement < SymbolType > > y = std::move ( leftAlt->getRight() );
-		std::smart_ptr < FormalRegExpElement < SymbolType > > z = std::move ( node->getRight() );
+		ext::smart_ptr < FormalRegExpElement < SymbolType > > x = std::move ( leftAlt->getLeft() );
+		ext::smart_ptr < FormalRegExpElement < SymbolType > > y = std::move ( leftAlt->getRight() );
+		ext::smart_ptr < FormalRegExpElement < SymbolType > > z = std::move ( node->getRight() );
 
 		leftAlt->setLeft ( std::move ( y ) );
 		leftAlt->setRight ( std::move ( z ) );
@@ -158,8 +158,8 @@ bool RegExpOptimize::A2( FormalRegExpElement < SymbolType > * & n ) {
 	if( dynamic_cast<FormalRegExpAlternation < SymbolType > *>( node->getRight().get() ) ) {
 		FormalRegExpAlternation < SymbolType > * rightAlt = static_cast < FormalRegExpAlternation < SymbolType > * > ( node->getRight ( ).get ( ) );
 
-		std::smart_ptr < FormalRegExpElement < SymbolType > > x = std::move ( node->getLeft ( ) );
-		std::smart_ptr < FormalRegExpElement < SymbolType > > y = std::move ( rightAlt->getLeft ( ) );
+		ext::smart_ptr < FormalRegExpElement < SymbolType > > x = std::move ( node->getLeft ( ) );
+		ext::smart_ptr < FormalRegExpElement < SymbolType > > y = std::move ( rightAlt->getLeft ( ) );
 
 		if(*x > *y) {
 			node->setLeft ( std::move ( y ) );
@@ -240,11 +240,11 @@ bool RegExpOptimize::A5( FormalRegExpElement < SymbolType > * & n ) {
 	if( ! node ) return false;
 
 	if( dynamic_cast<FormalRegExpConcatenation < SymbolType > *>( node->getLeft().get() ) ) {
-		std::smart_ptr < FormalRegExpConcatenation < SymbolType > > leftCon ( static_cast<FormalRegExpConcatenation < SymbolType > *>( node->getLeft().release() ) );
+		ext::smart_ptr < FormalRegExpConcatenation < SymbolType > > leftCon ( static_cast<FormalRegExpConcatenation < SymbolType > *>( node->getLeft().release() ) );
 
-		std::smart_ptr < FormalRegExpElement < SymbolType > > x = std::move ( leftCon->getLeft() );
-		std::smart_ptr < FormalRegExpElement < SymbolType > > y = std::move ( leftCon->getRight() );
-		std::smart_ptr < FormalRegExpElement < SymbolType > > z = std::move ( node->getRight() );
+		ext::smart_ptr < FormalRegExpElement < SymbolType > > x = std::move ( leftCon->getLeft() );
+		ext::smart_ptr < FormalRegExpElement < SymbolType > > y = std::move ( leftCon->getRight() );
+		ext::smart_ptr < FormalRegExpElement < SymbolType > > z = std::move ( node->getRight() );
 
 		leftCon->setLeft ( std::move ( y ) );
 		leftCon->setRight ( std::move ( z ) );
diff --git a/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.hpp b/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.hpp
index 3e1dc7c7c258240c62ea2be8baf997e4830b118c..4d8ce3e9f198076142a3cf41e2b7857f116142fe 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.hpp
+++ b/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.hpp
@@ -12,7 +12,7 @@ namespace simplify {
 template < class SymbolType >
 void RegExpOptimize::optimize( UnboundedRegExpAlternation < SymbolType > & alt ) {
 	for( unsigned i = 0; i < alt.getChildren ( ).size ( ); i++ )
-		alt.setChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( * alt.getChildren ( ) [ i ] ) ), i );
+		alt.setChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( * alt.getChildren ( ) [ i ] ) ), i );
 
 	while( A1( alt ) || A2( alt ) || A3( alt ) || A4( alt ) || A10( alt ) || V2( alt ) || V5( alt ) || V6( alt ) || X1( alt ) );
 }
@@ -20,14 +20,14 @@ void RegExpOptimize::optimize( UnboundedRegExpAlternation < SymbolType > & alt )
 template < class SymbolType >
 void RegExpOptimize::optimize( UnboundedRegExpConcatenation < SymbolType > & concat ) {
 	for( unsigned i = 0; i < concat.getChildren ( ).size ( ); i++ )
-		concat.setChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( * concat.getChildren ( ) [ i ] ) ), i );
+		concat.setChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( * concat.getChildren ( ) [ i ] ) ), i );
 
 	while( A5( concat ) || A6( concat ) || A7( concat ) || A8( concat ) || A9( concat ) || V8( concat ) );//|| V9( concat ) );
 }
 
 template < class SymbolType >
 void RegExpOptimize::optimize( UnboundedRegExpIteration < SymbolType > & iter ) {
-	iter.setChild ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner ( * iter.getChild ( ) ) ) );
+	iter.setChild ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner ( * iter.getChild ( ) ) ) );
 	do {
 		// V1 is implemented right here
 		if( dynamic_cast<UnboundedRegExpEmpty < SymbolType >*>( iter.getChild ( ).get() ) ) {
@@ -74,7 +74,7 @@ UnboundedRegExpElement < SymbolType > * RegExpOptimize::optimizeInner( const Unb
 	UnboundedRegExpAlternation < SymbolType >* alt = new UnboundedRegExpAlternation < SymbolType >( );
 
 	for( const auto & child : node.getElements ( ) )
-		alt->pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( * child ) ) );
+		alt->pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( * child ) ) );
 
 	// optimize while you can
 	while( A1( * alt ) || A2( * alt ) || A3( * alt ) || A4( * alt ) || A10( * alt ) || V2( * alt ) || V5( * alt ) || V6( * alt ) || X1( * alt ) );
@@ -98,7 +98,7 @@ UnboundedRegExpElement < SymbolType > * RegExpOptimize::optimizeInner( const Unb
 	UnboundedRegExpConcatenation < SymbolType >* concat = new UnboundedRegExpConcatenation < SymbolType >( );
 
 	for( const auto & child : node.getElements ( ) )
-		concat->pushBackChild ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( * child ) ) );
+		concat->pushBackChild ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( * child ) ) );
 
 	while( A5( * concat ) || A6( * concat ) || A7( * concat ) || A8( * concat ) || A9( * concat ) || V8( * concat ) );//|| V9( * concat ) );
 
@@ -119,7 +119,7 @@ UnboundedRegExpElement < SymbolType > * RegExpOptimize::optimizeInner( const Unb
 template < class SymbolType >
 UnboundedRegExpElement < SymbolType > * RegExpOptimize::optimizeInner( const UnboundedRegExpIteration < SymbolType > & node ) {
 	UnboundedRegExpIteration < SymbolType >* iter = new UnboundedRegExpIteration < SymbolType >( UnboundedRegExpEmpty < SymbolType > {} );
-	iter->setChild ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner ( * node.getChild ( ) ) ) );
+	iter->setChild ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner ( * node.getChild ( ) ) ) );
 
 	do {
 		// V1 is implemented right here
@@ -163,7 +163,7 @@ bool RegExpOptimize::A1( UnboundedRegExpAlternation < SymbolType > & node ) {
 
 	for( auto it = node.getChildren ( ).begin( ); it != node.getChildren ( ).end( ); ) {
 		if( dynamic_cast < UnboundedRegExpAlternation < SymbolType > * > ( it->get ( ) ) ) {
-			std::smart_ptr < UnboundedRegExpAlternation < SymbolType > > childAlt ( static_cast < UnboundedRegExpAlternation < SymbolType > * >( it->release() ) );
+			ext::smart_ptr < UnboundedRegExpAlternation < SymbolType > > childAlt ( static_cast < UnboundedRegExpAlternation < SymbolType > * >( it->release() ) );
 			it = node.getChildren ( ).erase( it );
 
 			it = node.insert( it, std::make_move_iterator(childAlt->getChildren ( ).begin ( ) ), std::make_move_iterator(childAlt->getChildren ( ).end ( ) ) );
@@ -183,7 +183,7 @@ bool RegExpOptimize::A1( UnboundedRegExpAlternation < SymbolType > & node ) {
   */
 template < class SymbolType >
 bool RegExpOptimize::A2( UnboundedRegExpAlternation < SymbolType > & node ) {
-	auto cmp = [ ]( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool { return *a < *b; };
+	auto cmp = [ ]( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool { return *a < *b; };
 
 	if( std::is_sorted( node.getChildren ( ).begin( ), node.getChildren ( ).end( ), cmp ) )
 		return false;
@@ -229,7 +229,7 @@ bool RegExpOptimize::A4( UnboundedRegExpAlternation < SymbolType > & node ) {
 	 *
 	 * As we always sort in optimization, we can use the first version, but A4 must be __always__ called __after__ A2
 	 */
-	auto cmp = [ ]( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool { return *a == *b; };
+	auto cmp = [ ]( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool { return *a == *b; };
 
 	size_t size = node.getChildren ( ).size ( );
 	node.getChildren ( ).erase ( std::unique ( node.getChildren ( ).begin ( ), node.getChildren ( ).end ( ), cmp), node.getChildren ( ).end( ) );
@@ -248,7 +248,7 @@ bool RegExpOptimize::A5( UnboundedRegExpConcatenation < SymbolType > & node ) {
 
 	for( auto it = node.getChildren ( ).begin( ); it != node.getChildren ( ).end( ); ) {
 		if( dynamic_cast<UnboundedRegExpConcatenation < SymbolType > *>( it->get() ) ) {
-			std::smart_ptr < UnboundedRegExpConcatenation < SymbolType > > childConcat ( static_cast<UnboundedRegExpConcatenation < SymbolType > *>( it->release() ) );
+			ext::smart_ptr < UnboundedRegExpConcatenation < SymbolType > > childConcat ( static_cast<UnboundedRegExpConcatenation < SymbolType > *>( it->release() ) );
 			it = node.getChildren ( ).erase( it );
 
 			it = node.insert( it, std::make_move_iterator(childConcat->getChildren ( ).begin( )), std::make_move_iterator(childConcat->getChildren ( ).end( ) ));
@@ -293,9 +293,9 @@ template < class SymbolType >
 bool RegExpOptimize::A7( UnboundedRegExpConcatenation < SymbolType > & node ) {
 	if(node.getChildren ( ).size() == 1) return false;
 
-	if( std::any_of( node.getChildren ( ).begin( ), node.getChildren ( ).end( ), []( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return dynamic_cast < UnboundedRegExpEmpty < SymbolType > * >( a.get() ); } ) ) {
+	if( std::any_of( node.getChildren ( ).begin( ), node.getChildren ( ).end( ), []( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return dynamic_cast < UnboundedRegExpEmpty < SymbolType > * >( a.get() ); } ) ) {
 		node.getChildren ( ).clear( );
-		node.pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEmpty < SymbolType >( ) ) );
+		node.pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEmpty < SymbolType >( ) ) );
 
 		return true;
 	}
@@ -418,7 +418,7 @@ bool RegExpOptimize::A10( UnboundedRegExpAlternation < SymbolType > & node ) {
 	 */
 
 	// check if we have some epsilon or iteration left, else nothing to do
-	auto eps = find_if( node.getElements().begin( ), node.getElements().end( ), [ ]( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool {
+	auto eps = find_if( node.getElements().begin( ), node.getElements().end( ), [ ]( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool {
 		return dynamic_cast<UnboundedRegExpEpsilon < SymbolType > const *>( a.get() ) || dynamic_cast<UnboundedRegExpIteration < SymbolType > const*>( a.get() );
 	});
 
@@ -464,7 +464,7 @@ 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 std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool {
+		auto eps = find_if( childAlt->getChildren ( ).begin( ), childAlt->getChildren ( ).end( ), [ ]( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool {
 			return dynamic_cast<UnboundedRegExpEpsilon < SymbolType > *>( a.get() );
 		});
 
@@ -508,12 +508,12 @@ bool RegExpOptimize::V2( UnboundedRegExpAlternation < SymbolType > & node ) {
 
 	std::vector < UnboundedRegExpElement < SymbolType > * > iterElements;
 	// cache  iter elements because of operator invalidation after erase
-	for( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & n : node.getElements ( ) ) {
+	for( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & n : node.getElements ( ) ) {
 		UnboundedRegExpIteration < SymbolType > * iter = dynamic_cast < UnboundedRegExpIteration < SymbolType > * > ( n.get ( ) );
 		if( iter ) {
 			UnboundedRegExpAlternation < SymbolType > * inner = dynamic_cast < UnboundedRegExpAlternation < SymbolType > * > ( iter->getChild ( ).get ( ) );
 			if ( inner )
-				for ( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & innerElement : inner->getElements ( ) )
+				for ( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & innerElement : inner->getElements ( ) )
 					iterElements.push_back ( innerElement.get() );
 			else
 				iterElements.push_back ( iter->getChild ( ).get ( ) );
@@ -522,7 +522,7 @@ bool RegExpOptimize::V2( UnboundedRegExpAlternation < SymbolType > & node ) {
 	}
 
 	for( UnboundedRegExpElement < SymbolType > * n : iterElements ) {
-		auto it = find_if( node.getChildren().begin( ), node.getChildren().end( ), [ n ] ( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool {
+		auto it = find_if( node.getChildren().begin( ), node.getChildren().end( ), [ n ] ( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool {
 			return *a == *n;
 		});
 
@@ -563,7 +563,7 @@ template < class SymbolType >
 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 ( ).get() );
-	if( ! cont || ! all_of( cont->getChildren ( ).begin( ), cont->getChildren ( ).end( ), [] ( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return dynamic_cast<UnboundedRegExpIteration < SymbolType > * >( a.get() ); } ) )
+	if( ! cont || ! all_of( cont->getChildren ( ).begin( ), cont->getChildren ( ).end( ), [] ( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return dynamic_cast<UnboundedRegExpIteration < SymbolType > * >( a.get() ); } ) )
 		return false;
 
 	UnboundedRegExpAlternation < SymbolType > newAlt;
@@ -571,7 +571,7 @@ bool RegExpOptimize::V4( UnboundedRegExpIteration < SymbolType > & node ) {
 	for( const auto & n : cont->getChildren ( ) )
 		newAlt.pushBackChild ( std::move ( static_cast < UnboundedRegExpIteration < SymbolType > * > ( n.get ( ) )->getChild ( ) ) );
 
-	node.setChild ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner ( newAlt ) ) );
+	node.setChild ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner ( newAlt ) ) );
 
 	return true;
 }
@@ -615,7 +615,7 @@ bool RegExpOptimize::V5( UnboundedRegExpAlternation < SymbolType > & node ) {
 
 				if( iterConcat->getChildren().size( ) != ( unsigned ) distance( std::next( itC ), concat->getChildren().end( ) )
 					|| ! equal( iterConcat->getChildren().begin( ), iterConcat->getChildren().end( ), std::next( itC ),
-					[ ]( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool{ return *a == *b; } ) ) {
+					[ ]( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool{ return *a == *b; } ) ) {
 					++ itC;
 					continue;
 				}
@@ -632,26 +632,26 @@ bool RegExpOptimize::V5( UnboundedRegExpAlternation < SymbolType > & node ) {
 			// store everything before iteration as "a"
 			UnboundedRegExpConcatenation < SymbolType > tmpAY;
 			if( concat->getChildren().begin( ) == itC ) {
-				tmpAY.pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType >( ) ) );
+				tmpAY.pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType >( ) ) );
 			} else {
 				UnboundedRegExpConcatenation < SymbolType > tmpA;
 				tmpA.insert( tmpA.getChildren().end( ), concat->getChildren().begin( ), itC );
-				tmpAY.pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpA ) ) );
+				tmpAY.pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpA ) ) );
 			}
 
 			// store everything behind iteration's followup element as "y"
 			if( itStartY == concat->getChildren().end( ) ) {
-				tmpAY.pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType >( ) ) );
+				tmpAY.pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType >( ) ) );
 			} else {
 				UnboundedRegExpConcatenation < SymbolType > tmpY;
 				tmpY.insert( tmpY.getChildren().end( ), itStartY, concat->getChildren().end( ) );
-				tmpAY.pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpY ) ) );
+				tmpAY.pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpY ) ) );
 			}
 
 			// concatenate "a" and "y" and see if they exist somewhere in parent alternation ( node.getChildren() )
 			UnboundedRegExpElement < SymbolType > * regexpAY = optimizeInner( tmpAY );
 
-			auto iterAY = find_if( node.getChildren().begin( ), node.getChildren().end( ), [ regexpAY ] ( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return *a == *regexpAY; } );
+			auto iterAY = find_if( node.getChildren().begin( ), node.getChildren().end( ), [ regexpAY ] ( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return *a == *regexpAY; } );
 			delete regexpAY;
 			if( iterAY == node.getChildren().end( ) ) {
 				++ itC;
@@ -661,7 +661,7 @@ bool RegExpOptimize::V5( UnboundedRegExpAlternation < SymbolType > & node ) {
 
 			tmpAY.insert( tmpAY.getChildren ( ).begin ( ) + 1, * itC );
 
-			node.setChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpAY ) ), itA );
+			node.setChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpAY ) ), itA );
 
 			itA = node.getChildren().erase( iterAY );
 
@@ -720,7 +720,7 @@ bool RegExpOptimize::V6( UnboundedRegExpAlternation < SymbolType > & node ) {
 
 				if( iterConcat->getChildren ( ).size( ) != ( unsigned ) distance( itStartX, concat->getChildren ( ).end( ) )
 						|| ! equal( iterConcat->getChildren().begin( ), iterConcat->getChildren().end( ), itStartX,
-						[]( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool{ return *a == *b; } ) ) {
+						[]( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool{ return *a == *b; } ) ) {
 					++ itC;
 					continue;
 				}
@@ -736,24 +736,24 @@ bool RegExpOptimize::V6( UnboundedRegExpAlternation < SymbolType > & node ) {
 			// concatenate "a" and "y" and see if they exist somewhere in parent alternation ( node->getChildren() )
 			UnboundedRegExpConcatenation < SymbolType > tmpAY;
 			if( concat->getChildren().begin( ) == itStartX ) {
-				tmpAY.pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType >( ) ) );
+				tmpAY.pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType >( ) ) );
 			} else {
 				UnboundedRegExpConcatenation < SymbolType > tmpA;
 				tmpA.insert( tmpA.getChildren().end( ), concat->getChildren().begin( ), itStartX );
-				tmpAY.pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpA ) ) );
+				tmpAY.pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpA ) ) );
 			}
 
 			if( std::next( itC ) == concat->getChildren().end( ) ) {
-				tmpAY.pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType >( ) ) );
+				tmpAY.pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType >( ) ) );
 			} else {
 				UnboundedRegExpConcatenation < SymbolType > tmpY;
 				tmpY.insert( tmpY.getChildren().end( ), std::next( itC ), concat->getChildren ( ).end( ) );
-				tmpAY.pushBackChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpY ) ) );
+				tmpAY.pushBackChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpY ) ) );
 			}
 
 			UnboundedRegExpElement < SymbolType > * regexpAY = optimizeInner( tmpAY );
 
-			auto iterAY = find_if( node.getChildren().begin( ), node.getChildren().end( ), [ regexpAY ] ( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return *a == *regexpAY; } );
+			auto iterAY = find_if( node.getChildren().begin( ), node.getChildren().end( ), [ regexpAY ] ( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return *a == *regexpAY; } );
 			delete regexpAY;
 			if( iterAY == node.getChildren().end( ) ) {
 				++ itC;
@@ -764,7 +764,7 @@ bool RegExpOptimize::V6( UnboundedRegExpAlternation < SymbolType > & node ) {
 			// if so make a x* y and replace a x x* y
 			tmpAY.insert( tmpAY.getChildren ( ).begin ( ) + 1, * itC );
 
-			node.setChild( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpAY ) ), itA );
+			node.setChild( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( optimizeInner( tmpAY ) ), itA );
 
 			// remove a y
 			itA = node.getChildren().erase( iterAY );
@@ -817,7 +817,7 @@ bool RegExpOptimize::V8( UnboundedRegExpConcatenation < SymbolType > & node ) {
 
 			if( regexp::properties::RegExpEpsilon::languageContainsEpsilon(*concat) &&
 				concat->getChildren().size ( ) == ( unsigned ) distance ( it2, node.getChildren ( ).end( ) ) &&
-				equal( concat->getChildren ( ).begin( ), concat->getChildren ( ).end( ), it2, [] ( const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool { return *a == *b; } ) ) {
+				equal( concat->getChildren ( ).begin( ), concat->getChildren ( ).end( ), it2, [] ( const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a, const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & b ) -> bool { return *a == *b; } ) ) {
 				optimized = true;
 
 				it = node.getChildren().erase( it2, it );
@@ -883,7 +883,7 @@ bool RegExpOptimize::V9( UnboundedRegExpConcatenation < SymbolType > & node ) {
 		// std::cout << RegExp( tmp ) << std::endl;
 
 		// copy the range <it;sth>, delete it and go back to the iter node
-		std::vector<std::smart_ptr < UnboundedRegExpElement < SymbolType > > > copyRange;
+		std::vector<ext::smart_ptr < UnboundedRegExpElement < SymbolType > > > copyRange;
 		copyRange.insert( copyRange.end(), std::next( it ), c1Iter );
 		it = node.getChildren().erase( std::next( it ), c1Iter );
 		it = std::prev( it );
@@ -911,7 +911,7 @@ template < class SymbolType >
 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 ( ).get() );
-	if( ! alt || ! any_of( alt->getChildren ( ).begin( ), alt->getChildren ( ).end( ), [] ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return dynamic_cast<UnboundedRegExpIteration < SymbolType > * >( a.get() ); } ) )
+	if( ! alt || ! any_of( alt->getChildren ( ).begin( ), alt->getChildren ( ).end( ), [] ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool{ return dynamic_cast<UnboundedRegExpIteration < SymbolType > * >( a.get() ); } ) )
 		return false;
 
 	for( auto it = alt->getChildren ( ).begin( ); it != alt->getChildren ( ).end( ); ++it ) {
@@ -932,8 +932,8 @@ 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 std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool { return dynamic_cast<UnboundedRegExpIteration < SymbolType > * >( a.get() );} );
-	auto eps = find_if( node.getChildren ( ).begin( ), node.getChildren ( ).end( ), [] (const std::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool { return dynamic_cast<UnboundedRegExpEpsilon < SymbolType > * >( a.get() );} );
+	auto iter = find_if( node.getChildren ( ).begin( ), node.getChildren ( ).end( ), [] (const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool { return dynamic_cast<UnboundedRegExpIteration < SymbolType > * >( a.get() );} );
+	auto eps = find_if( node.getChildren ( ).begin( ), node.getChildren ( ).end( ), [] (const ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & a ) -> bool { return dynamic_cast<UnboundedRegExpEpsilon < SymbolType > * >( a.get() );} );
 
 	if( iter != node.getChildren ( ).end( ) && eps != node.getChildren ( ).end( ) ) {
 		node.getChildren ( ).erase( eps );
diff --git a/alib2algo/src/rte/glushkov/GlushkovFollow.h b/alib2algo/src/rte/glushkov/GlushkovFollow.h
index 6a996ce959ebec2780cb7ddb1a19af00705f2145..68cb4480b09443de3212e0c9f5f0a3ec8b99c8d5 100644
--- a/alib2algo/src/rte/glushkov/GlushkovFollow.h
+++ b/alib2algo/src/rte/glushkov/GlushkovFollow.h
@@ -187,7 +187,7 @@ std::set < std::vector < common::ranked_symbol < SymbolType, RankType > > > Glus
 	if ( symbolF == node.getSymbol ( ) ) {
 		std::vector < common::ranked_symbol < SymbolType, RankType > > children;
 
-		for ( const std::smart_ptr < const rte::FormalRTESymbol < SymbolType, RankType > > & c : node.getElements ( ) )
+		for ( const ext::smart_ptr < const rte::FormalRTESymbol < SymbolType, RankType > > & c : node.getElements ( ) )
 			children.push_back ( c->getSymbol ( ) );
 
 		return replaceConstants ( alphabetK, children, subMap );
diff --git a/alib2algo/src/rte/glushkov/GlushkovIndexate.cpp b/alib2algo/src/rte/glushkov/GlushkovIndexate.cpp
index f5caa63030536787942e9270d9b32ff91b0a390e..09a7ae55bd9f8756188b5999fb4185d5b82e8355 100644
--- a/alib2algo/src/rte/glushkov/GlushkovIndexate.cpp
+++ b/alib2algo/src/rte/glushkov/GlushkovIndexate.cpp
@@ -29,7 +29,7 @@ std::rvalue_ref < FormalRTEElement < DefaultSymbolType, primitive::Unsigned > >
 	DefaultSymbolsPairType sps = DefaultSymbolsPairType ( std::make_pair ( DefaultSymbolType ( node.getSymbol ( ).getSymbol ( ) ), DefaultSymbolType ( i++ ) ) );
 	FormalRTESymbolAlphabet < DefaultSymbolType, primitive::Unsigned > * ns = new FormalRTESymbolAlphabet < DefaultSymbolType, primitive::Unsigned > ( common::ranked_symbol < > ( DefaultSymbolType ( sps ), node.getSymbol ( ).getRank ( ) ) );
 
-	for ( const std::smart_ptr < const rte::FormalRTESymbol < DefaultSymbolType, primitive::Unsigned > > & e : node.getElements ( ) ) {
+	for ( const ext::smart_ptr < const rte::FormalRTESymbol < DefaultSymbolType, primitive::Unsigned > > & e : node.getElements ( ) ) {
 		std::rvalue_ref < FormalRTEElement < DefaultSymbolType, primitive::Unsigned > > child = e->accept < std::rvalue_ref < rte::FormalRTEElement < DefaultSymbolType, primitive::Unsigned > >, GlushkovIndexate::Formal > ( i );
 		ns->appendElement ( * static_cast < FormalRTESymbol < DefaultSymbolType, primitive::Unsigned > * > ( child->clone ( ) ) ); // FIXME typecast
 	}
diff --git a/alib2algo/src/rte/glushkov/GlushkovPos.h b/alib2algo/src/rte/glushkov/GlushkovPos.h
index 940dbcaf3394a26d626b623125d38dc561c37bea..d8a0a5e7e89a8947171a4285f2f4e81ec9b8df07 100644
--- a/alib2algo/src/rte/glushkov/GlushkovPos.h
+++ b/alib2algo/src/rte/glushkov/GlushkovPos.h
@@ -60,7 +60,7 @@ template < class SymbolType, class RankType >
 bool GlushkovPos::Formal < SymbolType, RankType >::visit ( const rte::FormalRTESymbolAlphabet < SymbolType, RankType > & node, const common::ranked_symbol < SymbolType, RankType > & symbolF ) {
 	if ( symbolF == node.getSymbol ( ) ) return true;
 
-	for ( const std::smart_ptr < const rte::FormalRTESymbol < SymbolType, RankType > > & element : node.getElements ( ) )
+	for ( const ext::smart_ptr < const rte::FormalRTESymbol < SymbolType, RankType > > & element : node.getElements ( ) )
 		if ( element->template accept < bool, GlushkovPos::Formal < SymbolType, RankType > > ( symbolF ) )
 			return true;
 
diff --git a/alib2algo/src/tree/properties/ExactSubtreeRepeats.h b/alib2algo/src/tree/properties/ExactSubtreeRepeats.h
index f2c92e3b16e2b05db740a9675f80e7f3f3893675..55617c9e50e0d3b0be6583417a18dd740451bd88 100644
--- a/alib2algo/src/tree/properties/ExactSubtreeRepeats.h
+++ b/alib2algo/src/tree/properties/ExactSubtreeRepeats.h
@@ -157,7 +157,7 @@ void ExactSubtreeRepeats::ExactSubtreeRepeatsAux::buildMu ( const std::vector <
 	this->alphabetSize = 0;
 
 	for ( auto it = symbols.begin ( ); it != symbols.end ( ); it++ ) {
-		auto search = mu_map.find ( make_pair ( it->getSymbol ( ), it->getRank ( ) ) );
+		auto search = mu_map.find ( std::make_pair ( it->getSymbol ( ), it->getRank ( ) ) );
 
 		if ( search == mu_map.end ( ) ) {
 			mu_map.insert ( std::make_pair ( std::make_pair ( it->getSymbol ( ), it->getRank ( ) ), this->alphabetSize ) );
diff --git a/alib2common/src/base/WrapperBase.hpp b/alib2common/src/base/WrapperBase.hpp
index 30545e978e40a6cbb10447471f8918efa6ec7d41..fbca24ffc960e24074ef556ccf274ba5029a61c4 100644
--- a/alib2common/src/base/WrapperBase.hpp
+++ b/alib2common/src/base/WrapperBase.hpp
@@ -33,7 +33,7 @@ public:
 template < typename T >
 class WrapperBaseMiddle : public WrapperBaseBase {
 protected:
-	std::cow_shared_ptr < T > m_data;
+	ext::cow_shared_ptr < T > m_data;
 
 private:
 	void unify ( WrapperBaseMiddle & other ) {
@@ -94,7 +94,7 @@ public:
 		if ( & getData ( ) == data )
 			return;
 
-		this->m_data = std::cow_shared_ptr < T > ( data );
+		this->m_data = ext::cow_shared_ptr < T > ( data );
 	}
 
 	/**
diff --git a/alib2common/src/object/ObjectBase.h b/alib2common/src/object/ObjectBase.h
index 797155e21bcfeaea71e419063900b341ef4bf12e..db4c884d1352001882e4e6ab138d09b02fa32136 100644
--- a/alib2common/src/object/ObjectBase.h
+++ b/alib2common/src/object/ObjectBase.h
@@ -18,7 +18,7 @@ namespace alib {
 /**
  * Represents a base for any object.
  */
-class ObjectBase : public alib::CommonBase<ObjectBase>, public std::cow_shared_ptr_base {
+class ObjectBase : public alib::CommonBase<ObjectBase>, public ext::cow_shared_ptr_base {
 public:
 	virtual void compose ( std::deque < sax::Token > & out ) const = 0;
 
diff --git a/alib2data/src/regexp/formal/FormalRegExpAlternation.h b/alib2data/src/regexp/formal/FormalRegExpAlternation.h
index 6930af952a110616a0d5b71355f37764b362ba2f..2953fe277047918713ede9d417716502c825c3ae 100644
--- a/alib2data/src/regexp/formal/FormalRegExpAlternation.h
+++ b/alib2data/src/regexp/formal/FormalRegExpAlternation.h
@@ -22,7 +22,7 @@ namespace regexp {
  * as operands of the operator.
  */
 template < class SymbolType >
-class FormalRegExpAlternation : public FormalRegExpElement < SymbolType >, public ext::BinaryNode < std::smart_ptr < FormalRegExpElement < SymbolType > >, std::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpAlternation < SymbolType > > {
+class FormalRegExpAlternation : public FormalRegExpElement < SymbolType >, public ext::BinaryNode < ext::smart_ptr < FormalRegExpElement < SymbolType > >, ext::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpAlternation < SymbolType > > {
 public:
 	void accept ( typename FormalRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -45,7 +45,7 @@ public:
 	/**
 	 * @copydoc FormalRegExpElement::clone() const
 	 */
-	std::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
+	ext::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
 
 	/**
 	 * @copydoc FormalRegExpElement::testSymbol() const
@@ -101,8 +101,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpAlternation < DefaultSymbolType > ( std::move ( * std::move ( getLeftElement ( ) ).normalize ( ) ), std::move ( * std::move ( getRightElement ( ) ).normalize ( ) ) ) );
+	virtual ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpAlternation < DefaultSymbolType > ( std::move ( * std::move ( getLeftElement ( ) ).normalize ( ) ), std::move ( * std::move ( getRightElement ( ) ).normalize ( ) ) ) );
 	}
 };
 
@@ -113,7 +113,7 @@ public:
 namespace regexp {
 
 template < class SymbolType >
-FormalRegExpAlternation < SymbolType >::FormalRegExpAlternation ( FormalRegExpElement < SymbolType > && leftElement, FormalRegExpElement < SymbolType > && rightElement ) : ext::BinaryNode < std::smart_ptr < FormalRegExpElement < SymbolType > >, std::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpAlternation < SymbolType > > ( std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( leftElement ).plunder ( ) ), std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( rightElement ).plunder ( ) ) ) {
+FormalRegExpAlternation < SymbolType >::FormalRegExpAlternation ( FormalRegExpElement < SymbolType > && leftElement, FormalRegExpElement < SymbolType > && rightElement ) : ext::BinaryNode < ext::smart_ptr < FormalRegExpElement < SymbolType > >, ext::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpAlternation < SymbolType > > ( ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( leftElement ).plunder ( ) ), ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( rightElement ).plunder ( ) ) ) {
 }
 
 template < class SymbolType >
@@ -142,7 +142,7 @@ FormalRegExpElement < SymbolType > & FormalRegExpAlternation < SymbolType >::get
 
 template < class SymbolType >
 void FormalRegExpAlternation < SymbolType >::setLeftElement ( FormalRegExpElement < SymbolType > && element ) {
-	this->setLeft ( std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
+	this->setLeft ( ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType >
@@ -152,7 +152,7 @@ void FormalRegExpAlternation < SymbolType >::setLeftElement ( const FormalRegExp
 
 template < class SymbolType >
 void FormalRegExpAlternation < SymbolType >::setRightElement ( FormalRegExpElement < SymbolType > && element ) {
-	this->setRight ( std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
+	this->setRight ( ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType >
@@ -171,13 +171,13 @@ FormalRegExpAlternation < SymbolType > * FormalRegExpAlternation < SymbolType >:
 }
 
 template < class SymbolType >
-std::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpAlternation < SymbolType >::asUnbounded ( ) const {
+ext::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpAlternation < SymbolType >::asUnbounded ( ) const {
 	UnboundedRegExpAlternation < SymbolType > * res = new UnboundedRegExpAlternation < SymbolType > ( );
 
 	res->appendElement ( std::move ( * getLeftElement ( ).asUnbounded ( ) ) );
 	res->appendElement ( std::move ( * getRightElement ( ).asUnbounded ( ) ) );
 
-	return std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( res );
+	return ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( res );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/formal/FormalRegExpConcatenation.h b/alib2data/src/regexp/formal/FormalRegExpConcatenation.h
index 8e417f39d550b54360ac4c7890738e5081ecd26a..6125125bfcfcbc83dd7427a5fa1d00608b0483dd 100644
--- a/alib2data/src/regexp/formal/FormalRegExpConcatenation.h
+++ b/alib2data/src/regexp/formal/FormalRegExpConcatenation.h
@@ -22,7 +22,7 @@ namespace regexp {
  * as operands of the operator.
  */
 template < class SymbolType >
-class FormalRegExpConcatenation : public FormalRegExpElement < SymbolType >, public ext::BinaryNode < std::smart_ptr < FormalRegExpElement < SymbolType > >, std::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpConcatenation < SymbolType > > {
+class FormalRegExpConcatenation : public FormalRegExpElement < SymbolType >, public ext::BinaryNode < ext::smart_ptr < FormalRegExpElement < SymbolType > >, ext::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpConcatenation < SymbolType > > {
 public:
 	void accept ( typename FormalRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -44,7 +44,7 @@ public:
 	/**
 	 * @copydoc FormalRegExpElement::clone() const
 	 */
-	std::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
+	ext::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
 
 	/**
 	 * @copydoc FormalRegExpElement::testSymbol() const
@@ -97,8 +97,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpConcatenation < DefaultSymbolType > ( std::move ( * std::move ( getLeftElement ( ) ).normalize ( ) ), std::move ( * std::move ( getRightElement ( ) ).normalize ( ) ) ) );
+	virtual ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpConcatenation < DefaultSymbolType > ( std::move ( * std::move ( getLeftElement ( ) ).normalize ( ) ), std::move ( * std::move ( getRightElement ( ) ).normalize ( ) ) ) );
 	}
 };
 
@@ -109,7 +109,7 @@ public:
 namespace regexp {
 
 template < class SymbolType >
-FormalRegExpConcatenation < SymbolType >::FormalRegExpConcatenation ( FormalRegExpElement < SymbolType > && leftElement, FormalRegExpElement < SymbolType > && rightElement ) : ext::BinaryNode < std::smart_ptr < FormalRegExpElement < SymbolType > >, std::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpConcatenation < SymbolType > > ( std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( leftElement ).plunder ( ) ), std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( rightElement ).plunder ( ) ) ) {
+FormalRegExpConcatenation < SymbolType >::FormalRegExpConcatenation ( FormalRegExpElement < SymbolType > && leftElement, FormalRegExpElement < SymbolType > && rightElement ) : ext::BinaryNode < ext::smart_ptr < FormalRegExpElement < SymbolType > >, ext::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpConcatenation < SymbolType > > ( ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( leftElement ).plunder ( ) ), ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( rightElement ).plunder ( ) ) ) {
 }
 
 template < class SymbolType >
@@ -138,7 +138,7 @@ FormalRegExpElement < SymbolType > & FormalRegExpConcatenation < SymbolType >::g
 
 template < class SymbolType >
 void FormalRegExpConcatenation < SymbolType >::setLeftElement ( FormalRegExpElement < SymbolType > && element ) {
-	this->setLeft( std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
+	this->setLeft( ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType >
@@ -148,7 +148,7 @@ void FormalRegExpConcatenation < SymbolType >::setLeftElement ( const FormalRegE
 
 template < class SymbolType >
 void FormalRegExpConcatenation < SymbolType >::setRightElement ( FormalRegExpElement < SymbolType > && element ) {
-	this->setRight ( std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
+	this->setRight ( ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType >
@@ -167,13 +167,13 @@ FormalRegExpConcatenation < SymbolType > * FormalRegExpConcatenation < SymbolTyp
 }
 
 template < class SymbolType >
-std::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpConcatenation < SymbolType >::asUnbounded ( ) const {
+ext::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpConcatenation < SymbolType >::asUnbounded ( ) const {
 	UnboundedRegExpConcatenation < SymbolType > * res = new UnboundedRegExpConcatenation < SymbolType > ( );
 
 	res->appendElement ( std::move ( * getLeftElement ( ).asUnbounded ( ) ) );
 	res->appendElement ( std::move ( * getRightElement ( ).asUnbounded ( ) ) );
 
-	return std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( res );
+	return ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( res );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/formal/FormalRegExpElement.h b/alib2data/src/regexp/formal/FormalRegExpElement.h
index 9e7994bb9dfff569cef832730fe1b596b20ac6c6..ac46da24037cbb62b553fd1f3ad5b3a2db9afc32 100644
--- a/alib2data/src/regexp/formal/FormalRegExpElement.h
+++ b/alib2data/src/regexp/formal/FormalRegExpElement.h
@@ -75,7 +75,7 @@ public:
 	 *
 	 * @return copy of the element
 	 */
-	virtual std::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const = 0;
+	virtual ext::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const = 0;
 
 	/**
 	 * Traverses the regexp tree looking if particular Symbol is used in the regexp.
@@ -110,7 +110,7 @@ public:
 
 	/** Traverses the regexp tree and normalizes the symbols to DefaultSymbolType
 	 */
-	virtual std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && = 0;
+	virtual ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && = 0;
 };
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/formal/FormalRegExpEmpty.h b/alib2data/src/regexp/formal/FormalRegExpEmpty.h
index 1b1eb8cd43a7ce7f2cfb8a1195a54ba218b898a0..c42a30853c43ae1085e7003063c1ee4c2fc2b246 100644
--- a/alib2data/src/regexp/formal/FormalRegExpEmpty.h
+++ b/alib2data/src/regexp/formal/FormalRegExpEmpty.h
@@ -18,7 +18,7 @@ namespace regexp {
  * Represents empty regular expression in the regular expression.
  */
 template < class SymbolType >
-class FormalRegExpEmpty : public FormalRegExpElement < SymbolType >, public ext::NullaryNode < std::smart_ptr < FormalRegExpElement < SymbolType > >, std::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpSymbol < SymbolType > > {
+class FormalRegExpEmpty : public FormalRegExpElement < SymbolType >, public ext::NullaryNode < ext::smart_ptr < FormalRegExpElement < SymbolType > >, ext::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpSymbol < SymbolType > > {
 public:
 	void accept ( typename FormalRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -39,7 +39,7 @@ public:
 	/**
 	 * @copydoc FormalRegExpElement::clone() const
 	 */
-	std::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
+	ext::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
 
 	/**
 	 * @copydoc FormalRegExpElement::testSymbol() const
@@ -71,8 +71,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpEmpty < DefaultSymbolType > ( ) );
+	virtual ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpEmpty < DefaultSymbolType > ( ) );
 	}
 };
 
@@ -98,8 +98,8 @@ FormalRegExpEmpty < SymbolType > * FormalRegExpEmpty < SymbolType >::plunder ( )
 }
 
 template < class SymbolType >
-std::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpEmpty < SymbolType >::asUnbounded ( ) const {
-	return std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEmpty < SymbolType > ( ) );
+ext::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpEmpty < SymbolType >::asUnbounded ( ) const {
+	return ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEmpty < SymbolType > ( ) );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/formal/FormalRegExpEpsilon.h b/alib2data/src/regexp/formal/FormalRegExpEpsilon.h
index 53894519d839b8b5a0e902d815f90b0f2595d85f..c41e6925935d53cbd534d86bdf79b9ad93532841 100644
--- a/alib2data/src/regexp/formal/FormalRegExpEpsilon.h
+++ b/alib2data/src/regexp/formal/FormalRegExpEpsilon.h
@@ -18,7 +18,7 @@ namespace regexp {
  * Represents epsilon in the regular expression.
  */
 template < class SymbolType >
-class FormalRegExpEpsilon : public FormalRegExpElement < SymbolType >, public ext::NullaryNode < std::smart_ptr < FormalRegExpElement < SymbolType > >, std::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpSymbol < SymbolType > > {
+class FormalRegExpEpsilon : public FormalRegExpElement < SymbolType >, public ext::NullaryNode < ext::smart_ptr < FormalRegExpElement < SymbolType > >, ext::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpSymbol < SymbolType > > {
 public:
 	void accept ( typename FormalRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -39,7 +39,7 @@ public:
 	/**
 	 * @copydoc FormalRegExpElement::clone() const
 	 */
-	std::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
+	ext::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
 
 	/**
 	 * @copydoc FormalRegExpElement::testSymbol() const
@@ -71,8 +71,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpEpsilon < DefaultSymbolType > ( ) );
+	virtual ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpEpsilon < DefaultSymbolType > ( ) );
 	}
 };
 
@@ -98,8 +98,8 @@ FormalRegExpEpsilon < SymbolType > * FormalRegExpEpsilon < SymbolType >::plunder
 }
 
 template < class SymbolType >
-std::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpEpsilon < SymbolType >::asUnbounded ( ) const {
-	return std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType > ( ) );
+ext::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpEpsilon < SymbolType >::asUnbounded ( ) const {
+	return ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpEpsilon < SymbolType > ( ) );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/formal/FormalRegExpIteration.h b/alib2data/src/regexp/formal/FormalRegExpIteration.h
index 4ec67e3d52eefff4028f3c2f96be5b804c2cb5ad..777310049f699a887dbf5249a0f5f78b7093d1b3 100644
--- a/alib2data/src/regexp/formal/FormalRegExpIteration.h
+++ b/alib2data/src/regexp/formal/FormalRegExpIteration.h
@@ -22,7 +22,7 @@ namespace regexp {
  * as operand.
  */
 template < class SymbolType >
-class FormalRegExpIteration : public FormalRegExpElement < SymbolType >, public ext::UnaryNode < std::smart_ptr < FormalRegExpElement < SymbolType > >, std::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpIteration < SymbolType > > {
+class FormalRegExpIteration : public FormalRegExpElement < SymbolType >, public ext::UnaryNode < ext::smart_ptr < FormalRegExpElement < SymbolType > >, ext::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpIteration < SymbolType > > {
 public:
 	void accept ( typename FormalRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -44,7 +44,7 @@ public:
 	/**
 	 * @copydoc FormalRegExpElement::clone() const
 	 */
-	std::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
+	ext::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
 
 	/**
 	 * @copydoc FormalRegExpElement::testSymbol() const
@@ -92,8 +92,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpIteration < DefaultSymbolType > ( std::move ( * std::move ( getElement ( ) ).normalize ( ) ) ) );
+	virtual ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpIteration < DefaultSymbolType > ( std::move ( * std::move ( getElement ( ) ).normalize ( ) ) ) );
 	}
 };
 
@@ -105,7 +105,7 @@ public:
 namespace regexp {
 
 template < class SymbolType >
-FormalRegExpIteration < SymbolType >::FormalRegExpIteration ( FormalRegExpElement < SymbolType > && element ) : ext::UnaryNode < std::smart_ptr < FormalRegExpElement < SymbolType > >, std::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpIteration < SymbolType > > ( std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) ) {
+FormalRegExpIteration < SymbolType >::FormalRegExpIteration ( FormalRegExpElement < SymbolType > && element ) : ext::UnaryNode < ext::smart_ptr < FormalRegExpElement < SymbolType > >, ext::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpIteration < SymbolType > > ( ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) ) {
 }
 
 template < class SymbolType >
@@ -124,7 +124,7 @@ FormalRegExpElement < SymbolType > & FormalRegExpIteration < SymbolType >::getEl
 
 template < class SymbolType >
 void FormalRegExpIteration < SymbolType >::setElement ( FormalRegExpElement < SymbolType > && elementParam ) {
-	this->setChild ( std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( elementParam ).plunder ( ) ) );
+	this->setChild ( ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( elementParam ).plunder ( ) ) );
 }
 
 template < class SymbolType >
@@ -143,8 +143,8 @@ FormalRegExpIteration < SymbolType > * FormalRegExpIteration < SymbolType >::plu
 }
 
 template < class SymbolType >
-std::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpIteration < SymbolType >::asUnbounded ( ) const {
-	return std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpIteration < SymbolType > ( * getElement ( ).asUnbounded ( ) ) );
+ext::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpIteration < SymbolType >::asUnbounded ( ) const {
+	return ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpIteration < SymbolType > ( * getElement ( ).asUnbounded ( ) ) );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/formal/FormalRegExpStructure.h b/alib2data/src/regexp/formal/FormalRegExpStructure.h
index a075686736ede9447cd73c319f62e94049470fcc..ded702b36f7ad8ac7fc4719f88ac6ac147f6d321 100644
--- a/alib2data/src/regexp/formal/FormalRegExpStructure.h
+++ b/alib2data/src/regexp/formal/FormalRegExpStructure.h
@@ -25,7 +25,7 @@ namespace regexp {
 template < class SymbolType >
 class FormalRegExpStructure {
 protected:
-	std::smart_ptr < FormalRegExpElement < SymbolType > > m_structure;
+	ext::smart_ptr < FormalRegExpElement < SymbolType > > m_structure;
 
 public:
 	explicit FormalRegExpStructure ( );
@@ -131,7 +131,7 @@ void FormalRegExpStructure < SymbolType >::setStructure ( const FormalRegExpElem
 
 template < class SymbolType >
 void FormalRegExpStructure < SymbolType >::setStructure ( FormalRegExpElement < SymbolType > && param ) {
-	this->m_structure = std::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( param ).plunder ( ) );
+	this->m_structure = ext::smart_ptr < FormalRegExpElement < SymbolType > > ( std::move ( param ).plunder ( ) );
 }
 
 } /* namespace regexp */
diff --git a/alib2data/src/regexp/formal/FormalRegExpSymbol.h b/alib2data/src/regexp/formal/FormalRegExpSymbol.h
index 9e4e90b5c5233b721d00db7c85eda3d8488cc8b9..c71c235156a7c91da9e5ee43147bec9e38c9599d 100644
--- a/alib2data/src/regexp/formal/FormalRegExpSymbol.h
+++ b/alib2data/src/regexp/formal/FormalRegExpSymbol.h
@@ -19,7 +19,7 @@ namespace regexp {
  * Represents symbol in the regular expression. Contains name of the symbol.
  */
 template < class SymbolType >
-class FormalRegExpSymbol : public FormalRegExpElement < SymbolType >, public ext::NullaryNode < std::smart_ptr < FormalRegExpElement < SymbolType > >, std::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpSymbol < SymbolType > > {
+class FormalRegExpSymbol : public FormalRegExpElement < SymbolType >, public ext::NullaryNode < ext::smart_ptr < FormalRegExpElement < SymbolType > >, ext::smart_ptr < const FormalRegExpElement < SymbolType > >, FormalRegExpSymbol < SymbolType > > {
 	SymbolType m_symbol;
 
 public:
@@ -42,7 +42,7 @@ public:
 	/**
 	 * @copydoc FormalRegExpElement::clone() const
 	 */
-	std::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
+	ext::smart_ptr < UnboundedRegExpElement < SymbolType > > asUnbounded ( ) const override;
 
 	/**
 	 * @copydoc FormalRegExpElement::testSymbol() const
@@ -79,8 +79,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpSymbol < DefaultSymbolType > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( m_symbol ) ) ) );
+	virtual ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRegExpElement < DefaultSymbolType > > ( new FormalRegExpSymbol < DefaultSymbolType > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( m_symbol ) ) ) );
 	}
 };
 
@@ -105,8 +105,8 @@ FormalRegExpSymbol < SymbolType > * FormalRegExpSymbol < SymbolType >::plunder (
 }
 
 template < class SymbolType >
-std::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpSymbol < SymbolType >::asUnbounded ( ) const {
-	return std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpSymbol < SymbolType > ( this->m_symbol ) );
+ext::smart_ptr < UnboundedRegExpElement < SymbolType > > FormalRegExpSymbol < SymbolType >::asUnbounded ( ) const {
+	return ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( new UnboundedRegExpSymbol < SymbolType > ( this->m_symbol ) );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h b/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h
index 8673f18ae2530c1b382619baac9e9e4a7ef08fa1..f30eeef9c501aa67333913d1a7fa907eb488857c 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h
@@ -22,7 +22,7 @@ namespace regexp {
  * as operands of the operator.
  */
 template < class SymbolType >
-class UnboundedRegExpAlternation : public UnboundedRegExpElement < SymbolType >, public ext::VararyNode < std::smart_ptr < UnboundedRegExpElement < SymbolType > >, std::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpAlternation < SymbolType > > {
+class UnboundedRegExpAlternation : public UnboundedRegExpElement < SymbolType >, public ext::VararyNode < ext::smart_ptr < UnboundedRegExpElement < SymbolType > >, ext::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpAlternation < SymbolType > > {
 public:
 	void accept ( typename UnboundedRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -43,7 +43,7 @@ public:
 	/**
 	 * @copydoc UnboundedRegExpElement::cloneAsFormal() const
 	 */
-	std::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
+	ext::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
 
 	/**
 	 * @copydoc UnboundedRegExpElement::testSymbol() const
@@ -63,12 +63,12 @@ public:
 	/**
 	 * @return elements
 	 */
-	const std::vector < std::smart_ptr < const UnboundedRegExpElement < SymbolType > > > & getElements ( ) const;
+	const std::vector < ext::smart_ptr < const UnboundedRegExpElement < SymbolType > > > & getElements ( ) const;
 
 	/**
 	 * @return elements
 	 */
-	const std::vector < std::smart_ptr < UnboundedRegExpElement < SymbolType > > > & getElements ( );
+	const std::vector < ext::smart_ptr < UnboundedRegExpElement < SymbolType > > > & getElements ( );
 
 	/**
 	 * @param element to append
@@ -91,13 +91,13 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+	virtual ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
 		UnboundedRegExpAlternation < DefaultSymbolType > * res = new UnboundedRegExpAlternation < DefaultSymbolType > ( );
 
-		for ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > & element : this->getChildren ( ) )
+		for ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & element : this->getChildren ( ) )
 			res->appendElement ( std::move ( * std::move ( * element ).normalize ( ) ) );
 
-		return std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( res );
+		return ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( res );
 	}
 };
 
@@ -113,18 +113,18 @@ UnboundedRegExpAlternation < SymbolType >::UnboundedRegExpAlternation ( ) {
 }
 
 template < class SymbolType >
-const std::vector < std::smart_ptr < const UnboundedRegExpElement < SymbolType > > > & UnboundedRegExpAlternation < SymbolType >::getElements ( ) const {
+const std::vector < ext::smart_ptr < const UnboundedRegExpElement < SymbolType > > > & UnboundedRegExpAlternation < SymbolType >::getElements ( ) const {
 	return this->getChildren();
 }
 
 template < class SymbolType >
-const std::vector < std::smart_ptr < UnboundedRegExpElement < SymbolType > > > & UnboundedRegExpAlternation < SymbolType >::getElements ( ) {
+const std::vector < ext::smart_ptr < UnboundedRegExpElement < SymbolType > > > & UnboundedRegExpAlternation < SymbolType >::getElements ( ) {
 	return this->getChildren();
 }
 
 template < class SymbolType >
 void UnboundedRegExpAlternation < SymbolType >::appendElement ( UnboundedRegExpElement < SymbolType > && element ) {
-	this->pushBackChild ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
+	this->pushBackChild ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType >
@@ -143,13 +143,13 @@ UnboundedRegExpAlternation < SymbolType > * UnboundedRegExpAlternation < SymbolT
 }
 
 template < class SymbolType >
-std::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpAlternation < SymbolType >::asFormal ( ) const {
-	if ( getElements ( ).size ( ) == 0 ) return std::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpEmpty < SymbolType > ( ) );
+ext::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpAlternation < SymbolType >::asFormal ( ) const {
+	if ( getElements ( ).size ( ) == 0 ) return ext::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpEmpty < SymbolType > ( ) );
 
-	std::smart_ptr < FormalRegExpElement < SymbolType > > res = getElements ( )[getElements ( ).size ( ) - 1]->asFormal ( );
+	ext::smart_ptr < FormalRegExpElement < SymbolType > > res = getElements ( )[getElements ( ).size ( ) - 1]->asFormal ( );
 
 	for ( unsigned i = getElements ( ).size ( ) - 1; i >= 1; i-- )
-		res = std::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpAlternation < SymbolType > ( std::move ( * getElements ( )[i - 1]->asFormal ( ) ), std::move ( * res ) ) );
+		res = ext::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpAlternation < SymbolType > ( std::move ( * getElements ( )[i - 1]->asFormal ( ) ), std::move ( * res ) ) );
 
 	return res;
 }
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h b/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h
index ad092f934889a1ebe18bf9f67d983f851280e196..f1f5aff9ef41d92a886330c281c554c142bec144 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h
@@ -22,7 +22,7 @@ namespace regexp {
  * as operands of the operator.
  */
 template < class SymbolType >
-class UnboundedRegExpConcatenation : public UnboundedRegExpElement < SymbolType >, public ext::VararyNode < std::smart_ptr < UnboundedRegExpElement < SymbolType > >, std::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpConcatenation < SymbolType > > {
+class UnboundedRegExpConcatenation : public UnboundedRegExpElement < SymbolType >, public ext::VararyNode < ext::smart_ptr < UnboundedRegExpElement < SymbolType > >, ext::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpConcatenation < SymbolType > > {
 public:
 	void accept ( typename UnboundedRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -43,7 +43,7 @@ public:
 	/**
 	 * @copydoc UnboundedRegExpElement::cloneAsFormal() const
 	 */
-	std::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
+	ext::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
 
 	/**
 	 * @copydoc UnboundedRegExpElement::testSymbol() const
@@ -63,12 +63,12 @@ public:
 	/**
 	 * @return elements
 	 */
-	const std::vector < std::smart_ptr < const UnboundedRegExpElement < SymbolType > > > & getElements ( ) const;
+	const std::vector < ext::smart_ptr < const UnboundedRegExpElement < SymbolType > > > & getElements ( ) const;
 
 	/**
 	 * @return elements
 	 */
-	const std::vector < std::smart_ptr < UnboundedRegExpElement < SymbolType > > > & getElements ( );
+	const std::vector < ext::smart_ptr < UnboundedRegExpElement < SymbolType > > > & getElements ( );
 
 	/**
 	 * @param element to append
@@ -91,13 +91,13 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+	virtual ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
 		UnboundedRegExpConcatenation < DefaultSymbolType > * res = new UnboundedRegExpConcatenation < DefaultSymbolType > ( );
 
-		for ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > & element : this->getChildren ( ) )
+		for ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > & element : this->getChildren ( ) )
 			res->appendElement ( std::move ( * std::move ( * element ).normalize ( ) ) );
 
-		return std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( res );
+		return ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( res );
 	}
 };
 
@@ -113,18 +113,18 @@ UnboundedRegExpConcatenation < SymbolType >::UnboundedRegExpConcatenation ( ) {
 }
 
 template < class SymbolType >
-const std::vector < std::smart_ptr < const UnboundedRegExpElement < SymbolType > > > & UnboundedRegExpConcatenation < SymbolType >::getElements ( ) const {
+const std::vector < ext::smart_ptr < const UnboundedRegExpElement < SymbolType > > > & UnboundedRegExpConcatenation < SymbolType >::getElements ( ) const {
 	return this->getChildren();
 }
 
 template < class SymbolType >
-const std::vector < std::smart_ptr < UnboundedRegExpElement < SymbolType > > > & UnboundedRegExpConcatenation < SymbolType >::getElements ( ) {
+const std::vector < ext::smart_ptr < UnboundedRegExpElement < SymbolType > > > & UnboundedRegExpConcatenation < SymbolType >::getElements ( ) {
 	return this->getChildren();
 }
 
 template < class SymbolType >
 void UnboundedRegExpConcatenation < SymbolType >::appendElement ( UnboundedRegExpElement < SymbolType > && element ) {
-	this->pushBackChild ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
+	this->pushBackChild ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType >
@@ -143,13 +143,13 @@ UnboundedRegExpConcatenation < SymbolType > * UnboundedRegExpConcatenation < Sym
 }
 
 template < class SymbolType >
-std::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpConcatenation < SymbolType >::asFormal ( ) const {
-	if ( getElements ( ).size ( ) == 0 ) return std::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpEpsilon < SymbolType > ( ) );
+ext::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpConcatenation < SymbolType >::asFormal ( ) const {
+	if ( getElements ( ).size ( ) == 0 ) return ext::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpEpsilon < SymbolType > ( ) );
 
-	std::smart_ptr < FormalRegExpElement < SymbolType > > res = getElements ( )[getElements ( ).size ( ) - 1]->asFormal ( );
+	ext::smart_ptr < FormalRegExpElement < SymbolType > > res = getElements ( )[getElements ( ).size ( ) - 1]->asFormal ( );
 
 	for ( unsigned i = getElements ( ).size ( ) - 1; i >= 1; i-- )
-		res = std::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpConcatenation < SymbolType > ( std::move ( * getElements ( )[i - 1]->asFormal ( ) ), std::move ( * res ) ) );
+		res = ext::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpConcatenation < SymbolType > ( std::move ( * getElements ( )[i - 1]->asFormal ( ) ), std::move ( * res ) ) );
 
 	return res;
 }
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpElement.h b/alib2data/src/regexp/unbounded/UnboundedRegExpElement.h
index bc2ea68884ae43937a1864e8c97e201ccf896e1e..bf0f1c3f32b50af43f05e90aaf13853b6f74b5fd 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpElement.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpElement.h
@@ -74,7 +74,7 @@ public:
 	 * Creates copy of the element.
 	 * @return copy of the element
 	 */
-	virtual std::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const = 0;
+	virtual ext::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const = 0;
 
 	/**
 	 * Traverses the regexp tree looking if particular Symbol is used in the regexp.
@@ -107,7 +107,7 @@ public:
 
 	/** Traverses the regexp tree and normalizes the symbols to DefaultSymbolType
 	 */
-	virtual std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && = 0;
+	virtual ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && = 0;
 };
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpEmpty.h b/alib2data/src/regexp/unbounded/UnboundedRegExpEmpty.h
index 88a2521d1966dd5f58607a661885a5e704d238bc..f510034b89504d1a6a1307251184755493406e4a 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpEmpty.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpEmpty.h
@@ -18,7 +18,7 @@ namespace regexp {
  * Represents empty regular expression in the regular expression.
  */
 template < class SymbolType >
-class UnboundedRegExpEmpty : public UnboundedRegExpElement < SymbolType >, public ext::NullaryNode < std::smart_ptr < UnboundedRegExpElement < SymbolType > >, std::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpSymbol < SymbolType > > {
+class UnboundedRegExpEmpty : public UnboundedRegExpElement < SymbolType >, public ext::NullaryNode < ext::smart_ptr < UnboundedRegExpElement < SymbolType > >, ext::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpSymbol < SymbolType > > {
 public:
 	void accept ( typename UnboundedRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -39,7 +39,7 @@ public:
 	/**
 	 * @copydoc UnboundedRegExpElement::cloneAsFormal() const
 	 */
-	std::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
+	ext::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
 
 	/**
 	 * @copydoc UnboundedRegExpElement::testSymbol() const
@@ -71,8 +71,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( new UnboundedRegExpEmpty < DefaultSymbolType > ( ) );
+	virtual ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( new UnboundedRegExpEmpty < DefaultSymbolType > ( ) );
 	}
 };
 
@@ -98,8 +98,8 @@ UnboundedRegExpEmpty < SymbolType > * UnboundedRegExpEmpty < SymbolType >::plund
 }
 
 template < class SymbolType >
-std::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpEmpty < SymbolType >::asFormal ( ) const {
-	return std::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpEmpty < SymbolType > ( ) );
+ext::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpEmpty < SymbolType >::asFormal ( ) const {
+	return ext::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpEmpty < SymbolType > ( ) );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpEpsilon.h b/alib2data/src/regexp/unbounded/UnboundedRegExpEpsilon.h
index cd6c3c7bc9a7f34dfc26aae51e54d0c40660230d..7f16676e6fb5b53473404b53746cd85a9a8b986b 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpEpsilon.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpEpsilon.h
@@ -18,7 +18,7 @@ namespace regexp {
  * Represents epsilon in the regular expression.
  */
 template < class SymbolType >
-class UnboundedRegExpEpsilon : public UnboundedRegExpElement < SymbolType >, public ext::NullaryNode < std::smart_ptr < UnboundedRegExpElement < SymbolType > >, std::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpSymbol < SymbolType > > {
+class UnboundedRegExpEpsilon : public UnboundedRegExpElement < SymbolType >, public ext::NullaryNode < ext::smart_ptr < UnboundedRegExpElement < SymbolType > >, ext::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpSymbol < SymbolType > > {
 public:
 	void accept ( typename UnboundedRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -39,7 +39,7 @@ public:
 	/**
 	 * @copydoc UnboundedRegExpElement::cloneAsFormal() const
 	 */
-	std::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
+	ext::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
 
 	/**
 	 * @copydoc UnboundedRegExpElement::testSymbol() const
@@ -71,8 +71,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( new UnboundedRegExpEpsilon < DefaultSymbolType > ( ) );
+	virtual ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( new UnboundedRegExpEpsilon < DefaultSymbolType > ( ) );
 	}
 };
 
@@ -98,8 +98,8 @@ UnboundedRegExpEpsilon < SymbolType > * UnboundedRegExpEpsilon < SymbolType >::p
 }
 
 template < class SymbolType >
-std::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpEpsilon < SymbolType >::asFormal ( ) const {
-	return std::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpEpsilon < SymbolType > ( ) );
+ext::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpEpsilon < SymbolType >::asFormal ( ) const {
+	return ext::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpEpsilon < SymbolType > ( ) );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpIteration.h b/alib2data/src/regexp/unbounded/UnboundedRegExpIteration.h
index 3518ade97385324342adaf07f091b37677d21081..5b7302e1b671ee5fb405deb209ab5e78680c1334 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpIteration.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpIteration.h
@@ -21,7 +21,7 @@ namespace regexp {
  * as operand.
  */
 template < class SymbolType >
-class UnboundedRegExpIteration : public UnboundedRegExpElement < SymbolType >, public ext::UnaryNode < std::smart_ptr < UnboundedRegExpElement < SymbolType > >, std::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpIteration < SymbolType > > {
+class UnboundedRegExpIteration : public UnboundedRegExpElement < SymbolType >, public ext::UnaryNode < ext::smart_ptr < UnboundedRegExpElement < SymbolType > >, ext::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpIteration < SymbolType > > {
 public:
 	void accept ( typename UnboundedRegExpElement < SymbolType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -43,7 +43,7 @@ public:
 	/**
 	 * @copydoc UnboundedRegExpElement::cloneAsFormal() const
 	 */
-	std::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
+	ext::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
 
 	/**
 	 * @copydoc UnboundedRegExpElement::testSymbol() const
@@ -91,8 +91,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( new UnboundedRegExpIteration < DefaultSymbolType > ( std::move ( * std::move ( getElement ( ) ).normalize ( ) ) ) );
+	virtual ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( new UnboundedRegExpIteration < DefaultSymbolType > ( std::move ( * std::move ( getElement ( ) ).normalize ( ) ) ) );
 	}
 };
 
@@ -104,7 +104,7 @@ public:
 namespace regexp {
 
 template < class SymbolType >
-UnboundedRegExpIteration < SymbolType >::UnboundedRegExpIteration ( UnboundedRegExpElement < SymbolType > && element ) : ext::UnaryNode < std::smart_ptr < UnboundedRegExpElement < SymbolType > >, std::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpIteration < SymbolType > > ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) ) {
+UnboundedRegExpIteration < SymbolType >::UnboundedRegExpIteration ( UnboundedRegExpElement < SymbolType > && element ) : ext::UnaryNode < ext::smart_ptr < UnboundedRegExpElement < SymbolType > >, ext::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpIteration < SymbolType > > ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( element ).plunder ( ) ) ) {
 }
 
 template < class SymbolType >
@@ -123,7 +123,7 @@ UnboundedRegExpElement < SymbolType > & UnboundedRegExpIteration < SymbolType >:
 
 template < class SymbolType >
 void UnboundedRegExpIteration < SymbolType >::setElement ( UnboundedRegExpElement < SymbolType > && elementParam ) {
-	this->setChild ( std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( elementParam ).plunder ( ) ) );
+	this->setChild ( ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( elementParam ).plunder ( ) ) );
 }
 
 template < class SymbolType >
@@ -142,8 +142,8 @@ UnboundedRegExpIteration < SymbolType > * UnboundedRegExpIteration < SymbolType
 }
 
 template < class SymbolType >
-std::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpIteration < SymbolType >::asFormal ( ) const {
-	return std::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpIteration < SymbolType > ( std::move ( * getElement ( ).asFormal ( ) ) ) );
+ext::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpIteration < SymbolType >::asFormal ( ) const {
+	return ext::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpIteration < SymbolType > ( std::move ( * getElement ( ).asFormal ( ) ) ) );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpStructure.h b/alib2data/src/regexp/unbounded/UnboundedRegExpStructure.h
index 36cffb91d95fa3052d251fd108e528833726d3c5..8c80d99b38286355045f47a5eb458643e5b975fc 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpStructure.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpStructure.h
@@ -25,7 +25,7 @@ namespace regexp {
 template < class SymbolType >
 class UnboundedRegExpStructure {
 protected:
-	std::smart_ptr < UnboundedRegExpElement < SymbolType > > m_structure;
+	ext::smart_ptr < UnboundedRegExpElement < SymbolType > > m_structure;
 
 public:
 	explicit UnboundedRegExpStructure ( );
@@ -131,7 +131,7 @@ void UnboundedRegExpStructure < SymbolType >::setStructure ( const UnboundedRegE
 
 template < class SymbolType >
 void UnboundedRegExpStructure < SymbolType >::setStructure ( UnboundedRegExpElement < SymbolType > && param ) {
-	this->m_structure = std::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( param ).plunder ( ) );
+	this->m_structure = ext::smart_ptr < UnboundedRegExpElement < SymbolType > > ( std::move ( param ).plunder ( ) );
 }
 
 } /* namespace regexp */
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpSymbol.h b/alib2data/src/regexp/unbounded/UnboundedRegExpSymbol.h
index 76b01822331f215b5b6a0e4f58b62ff93ff98b21..a091cb6e4481894c42ee91f31a2338b34ec75a42 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpSymbol.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpSymbol.h
@@ -19,7 +19,7 @@ namespace regexp {
  * Represents symbol in the regular expression. Contains name of the symbol.
  */
 template < class SymbolType >
-class UnboundedRegExpSymbol : public UnboundedRegExpElement < SymbolType >, public ext::NullaryNode < std::smart_ptr < UnboundedRegExpElement < SymbolType > >, std::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpSymbol < SymbolType > > {
+class UnboundedRegExpSymbol : public UnboundedRegExpElement < SymbolType >, public ext::NullaryNode < ext::smart_ptr < UnboundedRegExpElement < SymbolType > >, ext::smart_ptr < const UnboundedRegExpElement < SymbolType > >, UnboundedRegExpSymbol < SymbolType > > {
 	SymbolType m_symbol;
 
 public:
@@ -42,7 +42,7 @@ public:
 	/**
 	 * @copydoc UnboundedRegExpElement::cloneAsFormal() const
 	 */
-	std::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
+	ext::smart_ptr < FormalRegExpElement < SymbolType > > asFormal ( ) const override;
 
 	/**
 	 * @copydoc UnboundedRegExpElement::testSymbol() const
@@ -79,8 +79,8 @@ public:
 
 	explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
-		return std::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( new UnboundedRegExpSymbol < DefaultSymbolType > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( m_symbol ) ) ) );
+	virtual ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > normalize ( ) && override {
+		return ext::smart_ptr < UnboundedRegExpElement < DefaultSymbolType > > ( new UnboundedRegExpSymbol < DefaultSymbolType > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( m_symbol ) ) ) );
 	}
 };
 
@@ -107,8 +107,8 @@ UnboundedRegExpSymbol < SymbolType > * UnboundedRegExpSymbol < SymbolType >::plu
 }
 
 template < class SymbolType >
-std::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpSymbol < SymbolType >::asFormal ( ) const {
-	return std::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpSymbol < SymbolType > ( this->m_symbol ) );
+ext::smart_ptr < FormalRegExpElement < SymbolType > > UnboundedRegExpSymbol < SymbolType >::asFormal ( ) const {
+	return ext::smart_ptr < FormalRegExpElement < SymbolType > > ( new FormalRegExpSymbol < SymbolType > ( this->m_symbol ) );
 }
 
 template < class SymbolType >
diff --git a/alib2data/src/rte/common/RTEToXMLComposer.h b/alib2data/src/rte/common/RTEToXMLComposer.h
index 52b4c6da9e2f62df8e6e97ad06d7edacb1452c0f..a6015ed7f039249a0f3e1b9c64474dfae190d711 100644
--- a/alib2data/src/rte/common/RTEToXMLComposer.h
+++ b/alib2data/src/rte/common/RTEToXMLComposer.h
@@ -78,7 +78,7 @@ void RTEToXMLComposer::Formal::visit ( const FormalRTESymbolAlphabet < SymbolTyp
 	out.emplace_back ( sax::Token ( "symbol", sax::Token::TokenType::START_ELEMENT ) );
 	alib::xmlApi < common::ranked_symbol < SymbolType, RankType > >::compose ( out, symbol.getSymbol ( ) );
 
-	for ( const std::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > & element : symbol.getElements ( ) )
+	for ( const ext::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > & element : symbol.getElements ( ) )
 		element->template accept < void, RTEToXMLComposer::Formal > ( out );
 
 	out.emplace_back ( sax::Token ( "symbol", sax::Token::TokenType::END_ELEMENT ) );
diff --git a/alib2data/src/rte/formal/FormalRTEAlternation.h b/alib2data/src/rte/formal/FormalRTEAlternation.h
index 59b54c0f78196f4044c3cdfeecb67975e7a091ac..cd1a40df65aea24e7be078de719a9a273fc83428 100644
--- a/alib2data/src/rte/formal/FormalRTEAlternation.h
+++ b/alib2data/src/rte/formal/FormalRTEAlternation.h
@@ -22,7 +22,7 @@ namespace rte {
  * as operands of the operator.
  */
 template < class SymbolType, class RankType >
-class FormalRTEAlternation : public FormalRTEElement < SymbolType, RankType >, public ext::BinaryNode < std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, FormalRTEAlternation < SymbolType, RankType > > {
+class FormalRTEAlternation : public FormalRTEElement < SymbolType, RankType >, public ext::BinaryNode < ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, FormalRTEAlternation < SymbolType, RankType > > {
 public:
 	virtual void accept ( typename FormalRTEElement < SymbolType, RankType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -95,13 +95,13 @@ public:
 
 	virtual explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( new FormalRTEAlternation < DefaultSymbolType, DefaultRankType > ( std::move ( * std::move ( getLeftElement ( ) ).normalize ( ) ), std::move ( * std::move ( getRightElement ( ) ).normalize ( ) ) ) );
+	virtual ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( new FormalRTEAlternation < DefaultSymbolType, DefaultRankType > ( std::move ( * std::move ( getLeftElement ( ) ).normalize ( ) ), std::move ( * std::move ( getRightElement ( ) ).normalize ( ) ) ) );
 	}
 };
 
 template < class SymbolType, class RankType >
-FormalRTEAlternation < SymbolType, RankType >::FormalRTEAlternation ( FormalRTEElement < SymbolType, RankType > && left, FormalRTEElement < SymbolType, RankType > && right ) : ext::BinaryNode < std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, FormalRTEAlternation < SymbolType, RankType > > ( std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( left ).plunder ( ) ), std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( right ).plunder ( ) ) ) {
+FormalRTEAlternation < SymbolType, RankType >::FormalRTEAlternation ( FormalRTEElement < SymbolType, RankType > && left, FormalRTEElement < SymbolType, RankType > && right ) : ext::BinaryNode < ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, FormalRTEAlternation < SymbolType, RankType > > ( ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( left ).plunder ( ) ), ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( right ).plunder ( ) ) ) {
 }
 
 template < class SymbolType, class RankType >
@@ -135,7 +135,7 @@ void FormalRTEAlternation < SymbolType, RankType >::setLeftElement ( const Forma
 
 template < class SymbolType, class RankType >
 void FormalRTEAlternation < SymbolType, RankType >::setLeftElement ( FormalRTEElement < SymbolType, RankType > && element ) {
-	setLeft ( std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
+	setLeft ( ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType, class RankType >
@@ -145,7 +145,7 @@ void FormalRTEAlternation < SymbolType, RankType >::setRightElement ( const Form
 
 template < class SymbolType, class RankType >
 void FormalRTEAlternation < SymbolType, RankType >::setRightElement ( FormalRTEElement < SymbolType, RankType > && element ) {
-	setRight ( std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
+	setRight ( ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType, class RankType >
diff --git a/alib2data/src/rte/formal/FormalRTEElement.h b/alib2data/src/rte/formal/FormalRTEElement.h
index 90aba5158a40c1b5aa626c38a5991a1f9266b751..96aa3b0026613de1c232f1273c842858fbe56cac 100644
--- a/alib2data/src/rte/formal/FormalRTEElement.h
+++ b/alib2data/src/rte/formal/FormalRTEElement.h
@@ -99,7 +99,7 @@ public:
 
 	/** Traverses the rte tree and normalizes the symbols to DefaultSymbolType and ranks to DefaultRankType
 	 */
-	virtual std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && = 0;
+	virtual ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && = 0;
 };
 
 template < class SymbolType, class RankType >
diff --git a/alib2data/src/rte/formal/FormalRTEEmpty.h b/alib2data/src/rte/formal/FormalRTEEmpty.h
index 58af1c43fa145fb04280021df72f8b933656f10c..3affebe80cf49c9ef325962c9ba6428a013f40f3 100644
--- a/alib2data/src/rte/formal/FormalRTEEmpty.h
+++ b/alib2data/src/rte/formal/FormalRTEEmpty.h
@@ -65,8 +65,8 @@ public:
 
 	virtual explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( new FormalRTEEmpty < DefaultSymbolType, DefaultRankType > ( ) );
+	virtual ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( new FormalRTEEmpty < DefaultSymbolType, DefaultRankType > ( ) );
 	}
 };
 
diff --git a/alib2data/src/rte/formal/FormalRTEIteration.h b/alib2data/src/rte/formal/FormalRTEIteration.h
index 5bd783ba3c5e1c652e74df17868a0cfc5c90c1b3..5582b3a7dae4f0972340662641b9ea964a5a2054 100644
--- a/alib2data/src/rte/formal/FormalRTEIteration.h
+++ b/alib2data/src/rte/formal/FormalRTEIteration.h
@@ -23,9 +23,9 @@ namespace rte {
  * as operand.
  */
 template < class SymbolType, class RankType >
-class FormalRTEIteration : public FormalRTEElement < SymbolType, RankType >, public ext::UnaryNode < std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, std::smart_ptr < const FormalRTEElement < SymbolType, RankType > >, FormalRTEIteration < SymbolType, RankType > > {
+class FormalRTEIteration : public FormalRTEElement < SymbolType, RankType >, public ext::UnaryNode < ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, ext::smart_ptr < const FormalRTEElement < SymbolType, RankType > >, FormalRTEIteration < SymbolType, RankType > > {
 protected:
-	std::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > m_substitutionSymbol;
+	ext::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > m_substitutionSymbol;
 
 public:
 	virtual void accept ( typename FormalRTEElement < SymbolType, RankType >::Visitor & visitor ) const override {
@@ -95,13 +95,13 @@ public:
 
 	virtual explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( new FormalRTEIteration < DefaultSymbolType, DefaultRankType > ( std::move ( * std::move ( getElement ( ) ).normalize ( ) ), std::move ( * m_substitutionSymbol ).normalizeRaw ( ) ) );
+	virtual ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( new FormalRTEIteration < DefaultSymbolType, DefaultRankType > ( std::move ( * std::move ( getElement ( ) ).normalize ( ) ), std::move ( * m_substitutionSymbol ).normalizeRaw ( ) ) );
 	}
 };
 
 template < class SymbolType, class RankType >
-FormalRTEIteration < SymbolType, RankType >::FormalRTEIteration ( FormalRTEElement < SymbolType, RankType > && element, FormalRTESymbolSubst < SymbolType, RankType > substitutionSymbol ) : ext::UnaryNode < std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, std::smart_ptr < const FormalRTEElement < SymbolType, RankType > >, FormalRTEIteration < SymbolType, RankType > > ( std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) ), m_substitutionSymbol ( std::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > ( std::move ( substitutionSymbol ).plunder ( ) ) ) {
+FormalRTEIteration < SymbolType, RankType >::FormalRTEIteration ( FormalRTEElement < SymbolType, RankType > && element, FormalRTESymbolSubst < SymbolType, RankType > substitutionSymbol ) : ext::UnaryNode < ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, ext::smart_ptr < const FormalRTEElement < SymbolType, RankType > >, FormalRTEIteration < SymbolType, RankType > > ( ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) ), m_substitutionSymbol ( ext::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > ( std::move ( substitutionSymbol ).plunder ( ) ) ) {
 }
 
 template < class SymbolType, class RankType >
@@ -135,12 +135,12 @@ void FormalRTEIteration < SymbolType, RankType >::setElement ( const FormalRTEEl
 
 template < class SymbolType, class RankType >
 void FormalRTEIteration < SymbolType, RankType >::setElement ( FormalRTEElement < SymbolType, RankType > && elementParam ) {
-	setChild ( std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( elementParam ).plunder ( ) ) );
+	setChild ( ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( elementParam ).plunder ( ) ) );
 }
 
 template < class SymbolType, class RankType >
 void FormalRTEIteration < SymbolType, RankType >::setSubstitutionSymbol ( FormalRTESymbolSubst < SymbolType, RankType > symbol ) {
-	m_substitutionSymbol = std::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > ( std::move ( symbol ).plunder ( ) );
+	m_substitutionSymbol = ext::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > ( std::move ( symbol ).plunder ( ) );
 }
 
 template < class SymbolType, class RankType >
diff --git a/alib2data/src/rte/formal/FormalRTEStructure.h b/alib2data/src/rte/formal/FormalRTEStructure.h
index b789cd4f0465c56309943fb841ec757022b8bf2d..34df3646eebbb7597c1777ea0f99bd6b600f4812 100644
--- a/alib2data/src/rte/formal/FormalRTEStructure.h
+++ b/alib2data/src/rte/formal/FormalRTEStructure.h
@@ -26,7 +26,7 @@ namespace rte {
 template < class SymbolType, class RankType >
 class FormalRTEStructure {
 protected:
-	std::smart_ptr < FormalRTEElement < SymbolType, RankType > > m_structure;
+	ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > m_structure;
 
 public:
 	explicit FormalRTEStructure ( );
@@ -126,7 +126,7 @@ void FormalRTEStructure < SymbolType, RankType >::setStructure ( const FormalRTE
 
 template < class SymbolType, class RankType >
 void FormalRTEStructure < SymbolType, RankType >::setStructure ( FormalRTEElement < SymbolType, RankType > && param ) {
-	this->m_structure = std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( param ).plunder ( ) );
+	this->m_structure = ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( param ).plunder ( ) );
 }
 
 } /* namespace rte */
diff --git a/alib2data/src/rte/formal/FormalRTESubstitution.h b/alib2data/src/rte/formal/FormalRTESubstitution.h
index 3ff11f99e260e42b71b1d79d80b23b587505ed27..0178f3e2fc18dce30a1fc550f7588dd469d3cb5c 100644
--- a/alib2data/src/rte/formal/FormalRTESubstitution.h
+++ b/alib2data/src/rte/formal/FormalRTESubstitution.h
@@ -22,9 +22,9 @@ namespace rte {
  * as operands of the operator.
  */
 template < class SymbolType, class RankType >
-class FormalRTESubstitution : public FormalRTEElement < SymbolType, RankType >, public ext::BinaryNode < std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, FormalRTESubstitution < SymbolType, RankType > > {
+class FormalRTESubstitution : public FormalRTEElement < SymbolType, RankType >, public ext::BinaryNode < ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, FormalRTESubstitution < SymbolType, RankType > > {
 protected:
-	std::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > m_substitutionSymbol; // substite this in left by right
+	ext::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > m_substitutionSymbol; // substite this in left by right
 
 public:
 	virtual void accept ( typename FormalRTEElement < SymbolType, RankType >::Visitor & visitor ) const override {
@@ -98,13 +98,13 @@ public:
 	virtual void operator >>( std::ostream & out ) const override;
 	virtual explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( new FormalRTESubstitution < DefaultSymbolType, DefaultRankType > ( std::move ( * std::move ( getLeftElement ( ) ).normalize ( ) ), std::move ( * std::move ( getRightElement ( ) ).normalize ( ) ), std::move ( * m_substitutionSymbol ).normalizeRaw ( ) ) );
+	virtual ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( new FormalRTESubstitution < DefaultSymbolType, DefaultRankType > ( std::move ( * std::move ( getLeftElement ( ) ).normalize ( ) ), std::move ( * std::move ( getRightElement ( ) ).normalize ( ) ), std::move ( * m_substitutionSymbol ).normalizeRaw ( ) ) );
 	}
 };
 
 template < class SymbolType, class RankType >
-FormalRTESubstitution < SymbolType, RankType >::FormalRTESubstitution ( FormalRTEElement < SymbolType, RankType > && left, FormalRTEElement < SymbolType, RankType > && right, FormalRTESymbolSubst < SymbolType, RankType > substitutionSymbol ) : ext::BinaryNode < std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, std::smart_ptr < FormalRTEElement < SymbolType, RankType > >, FormalRTESubstitution < SymbolType, RankType > > ( std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( left ).plunder ( ) ), std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( right ).plunder ( ) ) ), m_substitutionSymbol ( std::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > ( std::move ( substitutionSymbol ).plunder ( ) ) ) {
+FormalRTESubstitution < SymbolType, RankType >::FormalRTESubstitution ( FormalRTEElement < SymbolType, RankType > && left, FormalRTEElement < SymbolType, RankType > && right, FormalRTESymbolSubst < SymbolType, RankType > substitutionSymbol ) : ext::BinaryNode < ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, ext::smart_ptr < FormalRTEElement < SymbolType, RankType > >, FormalRTESubstitution < SymbolType, RankType > > ( ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( left ).plunder ( ) ), ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( right ).plunder ( ) ) ), m_substitutionSymbol ( ext::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > ( std::move ( substitutionSymbol ).plunder ( ) ) ) {
 }
 
 template < class SymbolType, class RankType >
@@ -148,7 +148,7 @@ void FormalRTESubstitution < SymbolType, RankType >::setLeftElement ( const Form
 
 template < class SymbolType, class RankType >
 void FormalRTESubstitution < SymbolType, RankType >::setLeftElement ( FormalRTEElement < SymbolType, RankType > && element ) {
-	setLeft ( std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
+	setLeft ( ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType, class RankType >
@@ -158,12 +158,12 @@ void FormalRTESubstitution < SymbolType, RankType >::setRightElement ( const For
 
 template < class SymbolType, class RankType >
 void FormalRTESubstitution < SymbolType, RankType >::setRightElement ( FormalRTEElement < SymbolType, RankType > && element ) {
-	setRight ( std::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
+	setRight ( ext::smart_ptr < FormalRTEElement < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType, class RankType >
 void FormalRTESubstitution < SymbolType, RankType >::setSubstitutionSymbol ( FormalRTESymbolSubst < SymbolType, RankType > symbol ) {
-	m_substitutionSymbol = std::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > ( std::move ( symbol ).plunder ( ) );
+	m_substitutionSymbol = ext::smart_ptr < FormalRTESymbolSubst < SymbolType, RankType > > ( std::move ( symbol ).plunder ( ) );
 }
 
 template < class SymbolType, class RankType >
diff --git a/alib2data/src/rte/formal/FormalRTESymbol.h b/alib2data/src/rte/formal/FormalRTESymbol.h
index 5c893ab87d67c33468e61c510069736ab03265a6..241b83e89059c0f8f7e78fa2a6851b2a72a2cad8 100644
--- a/alib2data/src/rte/formal/FormalRTESymbol.h
+++ b/alib2data/src/rte/formal/FormalRTESymbol.h
@@ -36,7 +36,7 @@ public:
 
 	const common::ranked_symbol < SymbolType, RankType > & getSymbol ( ) const;
 
-	virtual std::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > normalizeSymbol ( ) && = 0;
+	virtual ext::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > normalizeSymbol ( ) && = 0;
 };
 
 template < class SymbolType, class RankType >
diff --git a/alib2data/src/rte/formal/FormalRTESymbolAlphabet.h b/alib2data/src/rte/formal/FormalRTESymbolAlphabet.h
index 7b0d8e62b359f75b459c32f8d12e329d026da44b..1d7a95a670507528e93220df13773c18df6215fc 100644
--- a/alib2data/src/rte/formal/FormalRTESymbolAlphabet.h
+++ b/alib2data/src/rte/formal/FormalRTESymbolAlphabet.h
@@ -21,7 +21,7 @@ namespace rte {
  * Represents symbol in the regular expression. Contains name of the symbol.
  */
 template < class SymbolType, class RankType >
-class FormalRTESymbolAlphabet : public FormalRTESymbol < SymbolType, RankType >, public ext::VararyNode < std::smart_ptr < FormalRTESymbol < SymbolType, RankType > >, std::smart_ptr < const FormalRTESymbol < SymbolType, RankType > >, FormalRTESymbolAlphabet < SymbolType, RankType > > {
+class FormalRTESymbolAlphabet : public FormalRTESymbol < SymbolType, RankType >, public ext::VararyNode < ext::smart_ptr < FormalRTESymbol < SymbolType, RankType > >, ext::smart_ptr < const FormalRTESymbol < SymbolType, RankType > >, FormalRTESymbolAlphabet < SymbolType, RankType > > {
 public:
 	virtual void accept ( typename FormalRTEElement < SymbolType, RankType >::Visitor & visitor ) const override {
 		visitor.visit ( * this );
@@ -54,8 +54,8 @@ public:
 	 */
 	virtual bool checkAlphabet ( const std::set < common::ranked_symbol < SymbolType, RankType > > & alphabetF, const std::set < common::ranked_symbol < SymbolType, RankType > > & alphabetK ) const override;
 
-	const std::vector < std::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > > & getElements ( ) const;
-	const std::vector < std::smart_ptr < FormalRTESymbol < SymbolType, RankType > > > & getElements ( );
+	const std::vector < ext::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > > & getElements ( ) const;
+	const std::vector < ext::smart_ptr < FormalRTESymbol < SymbolType, RankType > > > & getElements ( );
 
 	void appendElement ( const FormalRTESymbol < SymbolType, RankType > & element );
 	void appendElement ( FormalRTESymbol < SymbolType, RankType > && element );
@@ -78,17 +78,17 @@ public:
 	 */
 	virtual explicit operator std::string ( ) const override;
 
-	virtual std::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > normalizeSymbol ( ) && override {
+	virtual ext::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > normalizeSymbol ( ) && override {
 		FormalRTESymbolAlphabet < DefaultSymbolType, DefaultRankType > res ( alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->m_symbol ) ) );
 
-		for ( const std::smart_ptr < FormalRTESymbol < SymbolType, RankType > > & element : this->getChildren ( ) )
+		for ( const ext::smart_ptr < FormalRTESymbol < SymbolType, RankType > > & element : this->getChildren ( ) )
 			res.appendElement ( * std::move ( * element ).normalizeSymbol ( ) );
 
-		return std::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > ( std::move ( res ).plunder ( ) );
+		return ext::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > ( std::move ( res ).plunder ( ) );
 	}
 
-	virtual std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( std::move ( * this ).normalizeSymbol ( ) );
+	virtual ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( std::move ( * this ).normalizeSymbol ( ) );
 	}
 };
 
@@ -107,12 +107,12 @@ FormalRTESymbolAlphabet < SymbolType, RankType > * FormalRTESymbolAlphabet < Sym
 }
 
 template < class SymbolType, class RankType >
-const std::vector < std::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > > & FormalRTESymbolAlphabet < SymbolType, RankType >::getElements ( ) const {
+const std::vector < ext::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > > & FormalRTESymbolAlphabet < SymbolType, RankType >::getElements ( ) const {
 	return this->getChildren ( );
 }
 
 template < class SymbolType, class RankType >
-const std::vector < std::smart_ptr < FormalRTESymbol < SymbolType, RankType > > > & FormalRTESymbolAlphabet < SymbolType, RankType >::getElements ( ) {
+const std::vector < ext::smart_ptr < FormalRTESymbol < SymbolType, RankType > > > & FormalRTESymbolAlphabet < SymbolType, RankType >::getElements ( ) {
 	return this->getChildren ( );
 }
 
@@ -128,7 +128,7 @@ void FormalRTESymbolAlphabet < SymbolType, RankType >::appendElement ( FormalRTE
 	if ( this->getChildren ( ).size ( ) >= ( size_t ) this->getSymbol ( ).getRank ( ) )
 		throw exception::CommonException ( "Ranked node cannot have more children then its rank" );
 
-	this->pushBackChild ( std::smart_ptr < FormalRTESymbol < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
+	this->pushBackChild ( ext::smart_ptr < FormalRTESymbol < SymbolType, RankType > > ( std::move ( element ).plunder ( ) ) );
 }
 
 template < class SymbolType, class RankType >
@@ -155,13 +155,13 @@ template < class SymbolType, class RankType >
 void FormalRTESymbolAlphabet < SymbolType, RankType >::computeMinimalAlphabet ( std::set < common::ranked_symbol < SymbolType, RankType > > & alphabetF, std::set < common::ranked_symbol < SymbolType, RankType > > & alphabetK ) const {
 	alphabetF.insert ( this->getSymbol ( ) );
 
-	for ( const std::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > & child : this->getChildren ( ) )
+	for ( const ext::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > & child : this->getChildren ( ) )
 		child->computeMinimalAlphabet ( alphabetF, alphabetK );
 }
 
 template < class SymbolType, class RankType >
 bool FormalRTESymbolAlphabet < SymbolType, RankType >::checkAlphabet ( const std::set < common::ranked_symbol < SymbolType, RankType > > & alphabetF, const std::set < common::ranked_symbol < SymbolType, RankType > > & alphabetK ) const {
-	return alphabetF.count ( this->getSymbol ( ) ) > 0 && std::all_of ( getElements ( ).begin ( ), getElements ( ).end ( ), [&] ( const std::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > & e ) {
+	return alphabetF.count ( this->getSymbol ( ) ) > 0 && std::all_of ( getElements ( ).begin ( ), getElements ( ).end ( ), [&] ( const ext::smart_ptr < const FormalRTESymbol < SymbolType, RankType > > & e ) {
 			return e->checkAlphabet ( alphabetF, alphabetK );
 		} );
 }
diff --git a/alib2data/src/rte/formal/FormalRTESymbolSubst.h b/alib2data/src/rte/formal/FormalRTESymbolSubst.h
index d8b6e6c793ff0cf25670bb4031c56c1de2eecd13..1dd84741e62c4cb6f2c472187ec2c01fd28beadf 100644
--- a/alib2data/src/rte/formal/FormalRTESymbolSubst.h
+++ b/alib2data/src/rte/formal/FormalRTESymbolSubst.h
@@ -75,12 +75,12 @@ public:
 		return FormalRTESymbolSubst < DefaultSymbolType, DefaultRankType > ( alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->m_symbol ) ) );
 	}
 
-	virtual std::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > normalizeSymbol ( ) && override {
-		return std::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > ( std::move ( * this ).normalizeRaw ( ).plunder ( ) );
+	virtual ext::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > normalizeSymbol ( ) && override {
+		return ext::smart_ptr < FormalRTESymbol < DefaultSymbolType, DefaultRankType > > ( std::move ( * this ).normalizeRaw ( ).plunder ( ) );
 	}
 
-	virtual std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
-		return std::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( std::move ( * this ).normalizeSymbol ( ) );
+	virtual ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > normalize ( ) && override {
+		return ext::smart_ptr < FormalRTEElement < DefaultSymbolType, DefaultRankType > > ( std::move ( * this ).normalizeSymbol ( ) );
 	}
 };
 
diff --git a/alib2std/src/extensions/memory.hpp b/alib2std/src/extensions/memory.hpp
index f8982179b1d5ffc742f87f26eebbdb503ecf6439..733793fb65788f6de90a54623bebf15da712fa75 100644
--- a/alib2std/src/extensions/memory.hpp
+++ b/alib2std/src/extensions/memory.hpp
@@ -15,7 +15,7 @@
 #include "type_traits.hpp"
 #include "clone.hpp"
 
-namespace std {
+namespace ext {
 
 template < typename T, typename Enable = void >
 class cow_shared_ptr;
@@ -301,6 +301,8 @@ public:
 	}
 
 	smart_ptr & operator =( smart_ptr && other ) noexcept {
+		using std::swap;
+
 		swap ( this->m_Data, other.m_Data );
 		return * this;
 	}
@@ -343,11 +345,15 @@ public:
 };
 
 template < class T >
-std::ostream & operator <<( std::ostream & out, const std::cow_shared_ptr < T > & ptr ) {
+std::ostream & operator <<( std::ostream & out, const ext::cow_shared_ptr < T > & ptr ) {
 	out << * ptr;
 	return out;
 }
 
+} /* namespace ext */
+
+namespace std {
+
 template < class T >
 std::ostream & operator <<( std::ostream & out, const std::shared_ptr < T > & ptr ) {
 	out << * ptr;
@@ -360,19 +366,19 @@ std::ostream & operator <<( std::ostream & out, const std::unique_ptr < T > & pt
 	return out;
 }
 
+} /* namespace std */
+
+namespace ext {
+
 template < class T >
-std::ostream & operator <<( std::ostream & out, const std::smart_ptr < T > & ptr ) {
+std::ostream & operator <<( std::ostream & out, const ext::smart_ptr < T > & ptr ) {
 	out << * ptr;
 	return out;
 }
 
-} /* namespace std */
-
-namespace ext {
-
 template < class T >
-struct compare < std::cow_shared_ptr < T > > {
-	int operator ()( const std::cow_shared_ptr < T > & first, const std::cow_shared_ptr < T > & second ) const {
+struct compare < ext::cow_shared_ptr < T > > {
+	int operator ()( const ext::cow_shared_ptr < T > & first, const ext::cow_shared_ptr < T > & second ) const {
 		if ( first.get ( ) == second.get ( ) ) return 0;
 
 		if ( !first ) return -1;
@@ -416,8 +422,8 @@ struct compare < std::unique_ptr < T > > {
 };
 
 template < class T >
-struct compare < std::smart_ptr < T > > {
-	int operator ()( const std::smart_ptr < T > & first, const std::smart_ptr < T > & second ) const {
+struct compare < ext::smart_ptr < T > > {
+	int operator ()( const ext::smart_ptr < T > & first, const ext::smart_ptr < T > & second ) const {
 		if ( first.get ( ) == second.get ( ) ) return 0;
 
 		if ( !first ) return -1;
diff --git a/alib2std/test-src/extensions/SharedPtrTest.cpp b/alib2std/test-src/extensions/SharedPtrTest.cpp
index bcf5b95dedf2d76a9fd53e6741abc3d5f86849bb..019c067e46d7585e69dc08b97bb4630f2b335eae 100644
--- a/alib2std/test-src/extensions/SharedPtrTest.cpp
+++ b/alib2std/test-src/extensions/SharedPtrTest.cpp
@@ -15,13 +15,13 @@ void SharedPtrTest::testSharedPtr1() {
 	int moves;
 	int copies;
 
-	std::cow_shared_ptr<SharedPtrTest::Moveable> one(new SharedPtrTest::Moveable(moves, copies));
+	ext::cow_shared_ptr<SharedPtrTest::Moveable> one(new SharedPtrTest::Moveable(moves, copies));
 
 	CPPUNIT_ASSERT(one.unique());
 	CPPUNIT_ASSERT(moves == 0);
 	CPPUNIT_ASSERT(copies == 0);
 
-	std::cow_shared_ptr<SharedPtrTest::Moveable> two(one);
+	ext::cow_shared_ptr<SharedPtrTest::Moveable> two(one);
 
 	CPPUNIT_ASSERT(!one.unique());
 	CPPUNIT_ASSERT(moves == 0);
@@ -29,7 +29,7 @@ void SharedPtrTest::testSharedPtr1() {
 
 	std::make_const(two).get();
 
-	std::cow_shared_ptr<SharedPtrTest::Moveable> three(std::move ( two ) );
+	ext::cow_shared_ptr<SharedPtrTest::Moveable> three(std::move ( two ) );
 
 	std::make_const(three).get();
 
@@ -50,13 +50,13 @@ void SharedPtrTest::testSharedPtr2() {
 	int moves;
 	int copies;
 
-	std::cow_shared_ptr<SharedPtrTest::Moveable2> one(new SharedPtrTest::Moveable2(moves, copies));
+	ext::cow_shared_ptr<SharedPtrTest::Moveable2> one(new SharedPtrTest::Moveable2(moves, copies));
 
 	CPPUNIT_ASSERT(one.unique());
 	CPPUNIT_ASSERT(moves == 0);
 	CPPUNIT_ASSERT(copies == 0);
 
-	std::cow_shared_ptr<SharedPtrTest::Moveable2> two(one);
+	ext::cow_shared_ptr<SharedPtrTest::Moveable2> two(one);
 
 	CPPUNIT_ASSERT(!one.unique());
 	CPPUNIT_ASSERT(moves == 0);
@@ -64,7 +64,7 @@ void SharedPtrTest::testSharedPtr2() {
 
 	std::make_const(two).get();
 
-	std::cow_shared_ptr<SharedPtrTest::Moveable2> three(std::move ( two ) );
+	ext::cow_shared_ptr<SharedPtrTest::Moveable2> three(std::move ( two ) );
 
 	std::make_const(three).get();
 
@@ -82,8 +82,8 @@ void SharedPtrTest::testSharedPtr2() {
 }
 
 void SharedPtrTest::testSharedPtr3() {
-	std::cow_shared_ptr<SharedPtrTest::Base> one(new SharedPtrTest::Derived());
-	std::cow_shared_ptr<SharedPtrTest::Base> two(one);
+	ext::cow_shared_ptr<SharedPtrTest::Base> one(new SharedPtrTest::Derived());
+	ext::cow_shared_ptr<SharedPtrTest::Base> two(one);
 
 	CPPUNIT_ASSERT(!one.unique());
 
diff --git a/alib2std/test-src/extensions/SharedPtrTest.h b/alib2std/test-src/extensions/SharedPtrTest.h
index e19ea4d5378f77139eedd6740f5e9a0b7cdaee37..bff20bd84adc104502b3b2d01545603e60213c85 100644
--- a/alib2std/test-src/extensions/SharedPtrTest.h
+++ b/alib2std/test-src/extensions/SharedPtrTest.h
@@ -35,7 +35,7 @@ public:
 	}
 };
 
-class Moveable2 : public std::cow_shared_ptr_base {
+class Moveable2 : public ext::cow_shared_ptr_base {
 	int& m_moves;
 	int& m_copies;