diff --git a/alib2abstraction/src/common/OverloadResolution.hpp b/alib2abstraction/src/common/OverloadResolution.hpp
index 8e09668e8c0b436db33529e39f4f2b6dee7e3562..9fdc29a9c6482bec354e7c2d576fccfa2ad669fc 100644
--- a/alib2abstraction/src/common/OverloadResolution.hpp
+++ b/alib2abstraction/src/common/OverloadResolution.hpp
@@ -6,7 +6,7 @@
 namespace abstraction {
 
 template < class Entry >
-std::shared_ptr < abstraction::OperationAbstraction > getOverload ( const ext::list < std::unique_ptr < Entry > > & overloads, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > &, AlgorithmCategories::AlgorithmCategory category ) {
+std::unique_ptr < abstraction::OperationAbstraction > getOverload ( const ext::list < std::unique_ptr < Entry > > & overloads, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > &, AlgorithmCategories::AlgorithmCategory category ) {
 	enum class MatchType {
 		EXACT,
 		CAST,
diff --git a/alib2abstraction/src/registration/AlgoRegistration.hpp b/alib2abstraction/src/registration/AlgoRegistration.hpp
index f5cdc33aafde85b8f72fb0839b6e336952efaf13..3035972c88ff0f57eb383fe1b961936f02430c2c 100644
--- a/alib2abstraction/src/registration/AlgoRegistration.hpp
+++ b/alib2abstraction/src/registration/AlgoRegistration.hpp
@@ -59,7 +59,7 @@ template < class Algorithm, class ReturnType, class ... ParameterTypes >
 class WrapperRegister : public ext::Register < void > {
 public:
 	template < class ... ParamNames >
-	explicit WrapperRegister ( std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( ParameterTypes ... ), ParamNames ... paramNames ) : ext::Register < void > ( [=] ( ) {
+	explicit WrapperRegister ( std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( ParameterTypes ... ), ParamNames ... paramNames ) : ext::Register < void > ( [=] ( ) {
 				std::array < std::string, sizeof ... ( ParameterTypes ) > parameterNames = AlgoRegisterHelper::generateNames < sizeof ... ( ParameterTypes ) > ( paramNames ... );
 
 				abstraction::AlgorithmRegistry::registerWrapper < Algorithm, ReturnType, ParameterTypes ... > ( callback, std::move ( parameterNames ) );
diff --git a/alib2abstraction/src/registry/AlgorithmRegistry.cpp b/alib2abstraction/src/registry/AlgorithmRegistry.cpp
index 1cd0da449e620df588b88c149d5c4cfb9340089a..5c882886f488661bafb7bfb91b753fbc87cb3be2 100644
--- a/alib2abstraction/src/registry/AlgorithmRegistry.cpp
+++ b/alib2abstraction/src/registry/AlgorithmRegistry.cpp
@@ -12,8 +12,8 @@
 
 namespace abstraction {
 
-std::shared_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::RawImpl::getAbstraction ( ) const {
-	return std::make_shared < abstraction::RawAbstraction > ( getEntryInfo ( ).getParams ( ), m_rawCallback );
+std::unique_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::RawImpl::getAbstraction ( ) const {
+	return std::make_unique < abstraction::RawAbstraction > ( getEntryInfo ( ).getParams ( ), m_rawCallback );
 }
 
 ext::map < ext::pair < std::string, ext::vector < std::string > >, ext::list < std::unique_ptr < AlgorithmRegistry::Entry > > > & AlgorithmRegistry::getEntries ( ) {
@@ -89,7 +89,7 @@ ext::list < std::unique_ptr < AlgorithmRegistry::Entry > > & AlgorithmRegistry::
 	return group->second;
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::getAbstraction ( const std::string & name, const ext::vector < std::string > & templateParams, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
+std::unique_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::getAbstraction ( const std::string & name, const ext::vector < std::string > & templateParams, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
 	const auto & group = findAbstractionGroup ( name, templateParams );
 
 	try {
diff --git a/alib2abstraction/src/registry/AlgorithmRegistry.hpp b/alib2abstraction/src/registry/AlgorithmRegistry.hpp
index 61d53cf43ec3af3b9452a84fb2fd35a8b52eb95f..d9795eefd5c06bd134c8c8a344359372387c5ce1 100644
--- a/alib2abstraction/src/registry/AlgorithmRegistry.hpp
+++ b/alib2abstraction/src/registry/AlgorithmRegistry.hpp
@@ -54,7 +54,7 @@ private:
 		explicit MemberImpl ( std::array < std::string, sizeof ... ( Params ) > paramNames, std::function < Return ( typename std::remove_reference < ObjectType >::type *, Params ... ) > callback ) : Entry ( AlgorithmFullInfo::methodEntryInfo < ObjectType, Return, Params ... > ( std::move ( paramNames ) ) ), m_callback ( std::move ( callback ) ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	template < class Return, class ... Params >
@@ -65,18 +65,18 @@ private:
 		explicit EntryImpl ( AlgorithmCategories::AlgorithmCategory category, std::array < std::string, sizeof ... ( Params ) > paramNames, std::function < Return ( Params ... ) > callback ) : Entry ( AlgorithmFullInfo::algorithmEntryInfo < Return, Params ... > ( category, std::move ( paramNames ) ) ), m_callback ( std::move ( callback ) ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	template < class Return, class ... Params >
 	class WrapperImpl : public Entry {
-		std::function < std::shared_ptr < abstraction::OperationAbstraction > ( Params ... ) > m_wrapperFinder;
+		std::function < std::unique_ptr < abstraction::OperationAbstraction > ( Params ... ) > m_wrapperFinder;
 
 	public:
-		explicit WrapperImpl ( std::array < std::string, sizeof ... ( Params ) > paramNames, std::function < std::shared_ptr < abstraction::OperationAbstraction > ( Params ... ) > wrapperFinder ) : Entry ( AlgorithmFullInfo::wrapperEntryInfo < Return, Params ... > ( std::move ( paramNames ) ) ), m_wrapperFinder ( std::move ( wrapperFinder ) ) {
+		explicit WrapperImpl ( std::array < std::string, sizeof ... ( Params ) > paramNames, std::function < std::unique_ptr < abstraction::OperationAbstraction > ( Params ... ) > wrapperFinder ) : Entry ( AlgorithmFullInfo::wrapperEntryInfo < Return, Params ... > ( std::move ( paramNames ) ) ), m_wrapperFinder ( std::move ( wrapperFinder ) ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	class RawImpl : public Entry {
@@ -86,7 +86,7 @@ private:
 		explicit RawImpl ( ext::pair < std::string, abstraction::TypeQualifiers::TypeQualifierSet > result, ext::vector < ext::tuple < std::string, abstraction::TypeQualifiers::TypeQualifierSet, std::string > > paramSpecs, std::function < std::shared_ptr < abstraction::Value > ( std::vector < std::shared_ptr < abstraction::Value > > ) > rawCallback ) : Entry ( AlgorithmFullInfo::rawEntryInfo ( std::move ( result ), std::move ( paramSpecs ) ) ), m_rawCallback ( std::move ( rawCallback ) ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < ext::pair < std::string, ext::vector < std::string > >, ext::list < std::unique_ptr < Entry > > > & getEntries ( );
@@ -189,7 +189,7 @@ public:
 	}
 
 	template < class Algo, class ReturnType, class ... ParamTypes >
-	static void registerWrapper ( std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( ParamTypes ... ), std::array < std::string, sizeof ... ( ParamTypes ) > paramNames ) {
+	static void registerWrapper ( std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( ParamTypes ... ), std::array < std::string, sizeof ... ( ParamTypes ) > paramNames ) {
 		std::string algorithm = ext::to_string < Algo > ( );
 		ext::vector < std::string > templateParams = ext::get_template_info ( algorithm );
 		algorithm = ext::erase_template_info ( algorithm );
@@ -210,7 +210,7 @@ public:
 		registerInternal ( std::move ( algorithm ), std::move ( templateParams ), std::make_unique < RawImpl > ( std::move ( result ), std::move ( paramSpecs ), std::move ( callback ) ) );
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & name, const ext::vector < std::string > & templateParams, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & name, const ext::vector < std::string > & templateParams, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category );
 
 	static ext::set < ext::pair < std::string, ext::vector < std::string > > > listGroup ( const std::string & group );
 
@@ -228,18 +228,18 @@ public:
 namespace abstraction {
 
 template < class Object, class Return, class ... Params >
-std::shared_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::MemberImpl < Object, Return, Params ... >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::MemberAbstraction < Object, Return, Params ... > > ( m_callback );
+std::unique_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::MemberImpl < Object, Return, Params ... >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::MemberAbstraction < Object, Return, Params ... > > ( m_callback );
 }
 
 template < class Return, class ... Params >
-std::shared_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::EntryImpl < Return, Params ... >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::AlgorithmAbstraction < Return, Params ... > > ( m_callback );
+std::unique_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::EntryImpl < Return, Params ... >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::AlgorithmAbstraction < Return, Params ... > > ( m_callback );
 }
 
 template < class Return, class ... Params >
-std::shared_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::WrapperImpl < Return, Params ... >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::WrapperAbstraction < Params ... > > ( m_wrapperFinder );
+std::unique_ptr < abstraction::OperationAbstraction > AlgorithmRegistry::WrapperImpl < Return, Params ... >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::WrapperAbstraction < Params ... > > ( m_wrapperFinder );
 }
 
 } /* namespace abstraction */
diff --git a/alib2abstraction/src/registry/AlgorithmRegistryInfo.cpp b/alib2abstraction/src/registry/AlgorithmRegistryInfo.cpp
index 0545ce0ff8b8e3575aeb972641ea3cf710e4ecc5..491be9665893562819c1ec79e51bc212c6fb579d 100644
--- a/alib2abstraction/src/registry/AlgorithmRegistryInfo.cpp
+++ b/alib2abstraction/src/registry/AlgorithmRegistryInfo.cpp
@@ -13,7 +13,7 @@ ext::pair < std::string, abstraction::TypeQualifiers::TypeQualifierSet > Algorit
 	if ( ! abstraction::Registry::hasNormalize ( m_result.first ) )
 		return m_result;
 
-	std::shared_ptr < abstraction::OperationAbstraction > normalized = abstraction::Registry::getNormalizeAbstraction ( m_result.first );
+	std::unique_ptr < abstraction::OperationAbstraction > normalized = abstraction::Registry::getNormalizeAbstraction ( m_result.first );
 
 	return ext::make_pair ( normalized->getReturnType ( ), normalized->getReturnTypeQualifiers ( ) );
 }
diff --git a/alib2abstraction/src/registry/BaseRegistryEntry.hpp b/alib2abstraction/src/registry/BaseRegistryEntry.hpp
index 31bb1532e83206d9cfd3bea2f6fa6a7b2eba2773..6b62fc934b474ba1501dbaf0204728ec0e254fb2 100644
--- a/alib2abstraction/src/registry/BaseRegistryEntry.hpp
+++ b/alib2abstraction/src/registry/BaseRegistryEntry.hpp
@@ -8,7 +8,7 @@ class BaseRegistryEntry {
 public:
 	virtual ~BaseRegistryEntry ( ) = default;
 
-	virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
+	virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
 };
 
 } /* namespace abstraction */
diff --git a/alib2abstraction/src/registry/CastRegistry.cpp b/alib2abstraction/src/registry/CastRegistry.cpp
index 47a54c9437ab527b400efb463947b2ff236be33d..c3d6ffb832e8d45a61270f051ce61e47656ad6ae 100644
--- a/alib2abstraction/src/registry/CastRegistry.cpp
+++ b/alib2abstraction/src/registry/CastRegistry.cpp
@@ -21,7 +21,7 @@ void CastRegistry::registerCast ( std::string target, std::string param, std::un
 		throw std::invalid_argument ( "Entry from " + iter.first->first.second + " to " + iter.first->first.first + " already registered." );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > CastRegistry::getAbstraction ( const std::string & target, const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > CastRegistry::getAbstraction ( const std::string & target, const std::string & param ) {
 	auto entry = getEntries ( ).end ( );
 	for ( auto iter = getEntries ( ).begin ( ); iter != getEntries ( ).end ( ); ++ iter )
 		if ( iter->first.second == param && ext::is_same_type ( target, ext::erase_template_info ( iter->first.first ) ) ) {
diff --git a/alib2abstraction/src/registry/CastRegistry.hpp b/alib2abstraction/src/registry/CastRegistry.hpp
index da83da39a82a3e7edaa9063979156d2fa307c8f0..5faaaa075980ed75b90ac42107fa70ea53b680cf 100644
--- a/alib2abstraction/src/registry/CastRegistry.hpp
+++ b/alib2abstraction/src/registry/CastRegistry.hpp
@@ -33,7 +33,7 @@ private:
 		explicit DefaultEntryImpl ( bool isExplicit ) : Entry ( isExplicit ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	template < class Return, class Param >
@@ -44,7 +44,7 @@ private:
 		explicit AlgorithmEntryImpl ( std::function < Return ( Param ) > callback, bool isExplicit ) : Entry ( isExplicit ), m_callback ( std::move ( callback ) ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < ext::pair < std::string, std::string >, std::unique_ptr < Entry > > & getEntries ( );
@@ -105,7 +105,7 @@ public:
 
 	static bool castAvailable ( const std::string & target, const std::string & param, bool implicitOnly );
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & target, const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & target, const std::string & param );
 
 	static ext::list < ext::pair < std::string, bool > > listFrom ( const std::string & type );
 
@@ -122,13 +122,13 @@ public:
 namespace abstraction {
 
 template < class Return, class Param >
-std::shared_ptr < abstraction::OperationAbstraction > CastRegistry::DefaultEntryImpl < Return, Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::CastAbstraction < Return, const Param & > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > CastRegistry::DefaultEntryImpl < Return, Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::CastAbstraction < Return, const Param & > > ( );
 }
 
 template < class Return, class Param >
-std::shared_ptr < abstraction::OperationAbstraction > CastRegistry::AlgorithmEntryImpl < Return, Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::AlgorithmAbstraction < Return, const Param & > > ( m_callback );
+std::unique_ptr < abstraction::OperationAbstraction > CastRegistry::AlgorithmEntryImpl < Return, Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::AlgorithmAbstraction < Return, const Param & > > ( m_callback );
 }
 
 } /* namespace abstraction */
diff --git a/alib2abstraction/src/registry/ContainerRegistry.cpp b/alib2abstraction/src/registry/ContainerRegistry.cpp
index a02d61e93b1f42ab11d0087b0f003aa2d03a398b..9373a98c9a1fa9e474fbba2304dc95271bed95b4 100644
--- a/alib2abstraction/src/registry/ContainerRegistry.cpp
+++ b/alib2abstraction/src/registry/ContainerRegistry.cpp
@@ -38,7 +38,7 @@ bool ContainerRegistry::hasAbstraction ( const std::string & container ) {
 	return getEntries ( ).contains ( container );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > ContainerRegistry::getAbstraction ( const std::string & container, const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > ContainerRegistry::getAbstraction ( const std::string & container, const std::string & param ) {
 	auto group = getEntries ( ).find ( container );
 	if ( group == getEntries ( ).end ( ) )
 		throw std::invalid_argument ( "Entry " + container + " not available" );
diff --git a/alib2abstraction/src/registry/ContainerRegistry.hpp b/alib2abstraction/src/registry/ContainerRegistry.hpp
index 06a338aacf900b0e00fe9b3a1a03994852cf7866..9b659c95fa418d91472dbaf82aba535731d14118 100644
--- a/alib2abstraction/src/registry/ContainerRegistry.hpp
+++ b/alib2abstraction/src/registry/ContainerRegistry.hpp
@@ -23,7 +23,7 @@ private:
 	template < class Params >
 	class SetEntryImpl : public Entry {
 	public:
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, ext::list < ext::pair < std::string, std::unique_ptr < Entry > > > > & getEntries ( );
@@ -52,7 +52,7 @@ public:
 
 	static bool hasAbstraction ( const std::string & container );
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & container, const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & container, const std::string & param );
 
 	static ext::set < std::string > listOverloads ( const std::string & container );
 
@@ -66,8 +66,8 @@ public:
 namespace abstraction {
 
 template < class Param >
-std::shared_ptr < abstraction::OperationAbstraction > ContainerRegistry::SetEntryImpl < Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::SetAbstraction < Param > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > ContainerRegistry::SetEntryImpl < Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::SetAbstraction < Param > > ( );
 }
 
 } /* namespace abstraction */
diff --git a/alib2abstraction/src/registry/NormalizeRegistry.cpp b/alib2abstraction/src/registry/NormalizeRegistry.cpp
index 6db5787ed7b5025a3f7830c930b43ddda67c026c..4fb66eda9afd7a186d0b338b2cb71842498ee1e8 100644
--- a/alib2abstraction/src/registry/NormalizeRegistry.cpp
+++ b/alib2abstraction/src/registry/NormalizeRegistry.cpp
@@ -23,7 +23,7 @@ std::list < std::unique_ptr < NormalizeRegistry::Entry > >::const_iterator Norma
 	return collection.insert ( collection.end ( ), std::move ( entry ) );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > NormalizeRegistry::getAbstraction ( const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > NormalizeRegistry::getAbstraction ( const std::string & param ) {
 	auto res = getEntries ( ).find ( param );
 	if ( res == getEntries ( ).end ( ) || res->second.empty ( ) )
 		throw std::invalid_argument ( "Entry " + param + " not available." );
diff --git a/alib2abstraction/src/registry/NormalizeRegistry.hpp b/alib2abstraction/src/registry/NormalizeRegistry.hpp
index f0bb128ef1a831d4fc9de800146fc03c0d4343c4..aef24b2889df95ad8f2a8d88c446b896fb19af98 100644
--- a/alib2abstraction/src/registry/NormalizeRegistry.hpp
+++ b/alib2abstraction/src/registry/NormalizeRegistry.hpp
@@ -24,7 +24,7 @@ private:
 	public:
 		EntryImpl ( ) = default;
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, std::list < std::unique_ptr < Entry > > > & getEntries ( );
@@ -53,7 +53,7 @@ public:
 
 	static bool hasNormalize ( const std::string & param );
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
 };
 
 } /* namespace abstraction */
@@ -63,8 +63,8 @@ public:
 namespace abstraction {
 
 template < class Param >
-std::shared_ptr < abstraction::OperationAbstraction > NormalizeRegistry::EntryImpl < Param >::getAbstraction ( ) const {
-	return std::make_shared < NormalizeAbstraction < core::normalizationResult < Param >, Param > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > NormalizeRegistry::EntryImpl < Param >::getAbstraction ( ) const {
+	return std::make_unique < NormalizeAbstraction < core::normalizationResult < Param >, Param > > ( );
 }
 
 } /* namespace abstraction */
diff --git a/alib2abstraction/src/registry/OperatorRegistry.cpp b/alib2abstraction/src/registry/OperatorRegistry.cpp
index fe81c2ed37d43ee06fdf73a787815256e1296fb4..38ca79957cdba97284016ab1ad48ac5609376242 100644
--- a/alib2abstraction/src/registry/OperatorRegistry.cpp
+++ b/alib2abstraction/src/registry/OperatorRegistry.cpp
@@ -44,7 +44,7 @@ void OperatorRegistry::unregisterBinaryInternal ( Operators::BinaryOperators typ
 		getBinaryEntries ( ).erase ( type );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > OperatorRegistry::getBinaryAbstraction ( Operators::BinaryOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
+std::unique_ptr < abstraction::OperationAbstraction > OperatorRegistry::getBinaryAbstraction ( Operators::BinaryOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
 	const auto & group = getBinaryEntries ( ) [ type ];
 
 	return getOverload ( group, paramTypes, typeQualifiers, category );
@@ -95,7 +95,7 @@ void OperatorRegistry::unregisterPrefixInternal ( Operators::PrefixOperators typ
 		getPrefixEntries ( ).erase ( type );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > OperatorRegistry::getPrefixAbstraction ( Operators::PrefixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
+std::unique_ptr < abstraction::OperationAbstraction > OperatorRegistry::getPrefixAbstraction ( Operators::PrefixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
 	const auto & group = getPrefixEntries ( ) [ type ];
 
 	return getOverload ( group, paramTypes, typeQualifiers, category );
@@ -146,7 +146,7 @@ void OperatorRegistry::unregisterPostfixInternal ( Operators::PostfixOperators t
 		getPostfixEntries ( ).erase ( type );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > OperatorRegistry::getPostfixAbstraction ( Operators::PostfixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
+std::unique_ptr < abstraction::OperationAbstraction > OperatorRegistry::getPostfixAbstraction ( Operators::PostfixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
 	const auto & group = getPostfixEntries ( ) [ type ];
 
 	return getOverload ( group, paramTypes, typeQualifiers, category );
diff --git a/alib2abstraction/src/registry/OperatorRegistry.hpp b/alib2abstraction/src/registry/OperatorRegistry.hpp
index 4a04530b8d195549b4d8d7087313c9c4fbf69b4b..e6efc14bf3a1dcc97d9f7a9a68b68813bc47e73f 100644
--- a/alib2abstraction/src/registry/OperatorRegistry.hpp
+++ b/alib2abstraction/src/registry/OperatorRegistry.hpp
@@ -67,7 +67,7 @@ private:
 		explicit BinaryOperator ( std::function < Return ( FirstParam, SecondParam ) > callback ) : BinaryEntry ( AlgorithmFullInfo::operatorEntryInfo < Return, FirstParam, SecondParam > ( ) ), m_callback ( std::move ( callback ) ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	template < class Return, class Param >
@@ -78,7 +78,7 @@ private:
 		explicit PrefixOperator ( std::function < Return ( Param ) > callback ) : PrefixEntry ( AlgorithmFullInfo::operatorEntryInfo < Return, Param > ( ) ), m_callback ( std::move ( callback ) ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	template < class Return, class Param >
@@ -89,7 +89,7 @@ private:
 		explicit PostfixOperator ( std::function < Return ( Param ) > callback ) : PostfixEntry ( AlgorithmFullInfo::operatorEntryInfo < Return, Param > ( ) ), m_callback ( std::move ( callback ) ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < Operators::BinaryOperators, ext::list < std::unique_ptr < BinaryEntry > > > & getBinaryEntries ( );
@@ -189,7 +189,7 @@ public:
 		}
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getBinaryAbstraction ( Operators::BinaryOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category );
+	static std::unique_ptr < abstraction::OperationAbstraction > getBinaryAbstraction ( Operators::BinaryOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category );
 
 	static ext::list < ext::pair < Operators::BinaryOperators, AlgorithmFullInfo > > listBinaryOverloads ( );
 
@@ -229,7 +229,7 @@ public:
 		}
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getPrefixAbstraction ( Operators::PrefixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category );
+	static std::unique_ptr < abstraction::OperationAbstraction > getPrefixAbstraction ( Operators::PrefixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category );
 
 	static ext::list < ext::pair < Operators::PrefixOperators, AlgorithmFullInfo > > listPrefixOverloads ( );
 
@@ -257,7 +257,7 @@ public:
 		}
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getPostfixAbstraction ( Operators::PostfixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category );
+	static std::unique_ptr < abstraction::OperationAbstraction > getPostfixAbstraction ( Operators::PostfixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category );
 
 	static ext::list < ext::pair < Operators::PostfixOperators, AlgorithmFullInfo > > listPostfixOverloads ( );
 
@@ -272,18 +272,18 @@ public:
 namespace abstraction {
 
 template < class Return, class FirstParam, class SecondParam >
-std::shared_ptr < abstraction::OperationAbstraction > OperatorRegistry::BinaryOperator < Return, FirstParam, SecondParam >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::AlgorithmAbstraction < Return, FirstParam, SecondParam > > ( m_callback );
+std::unique_ptr < abstraction::OperationAbstraction > OperatorRegistry::BinaryOperator < Return, FirstParam, SecondParam >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::AlgorithmAbstraction < Return, FirstParam, SecondParam > > ( m_callback );
 }
 
 template < class Return, class Param >
-std::shared_ptr < abstraction::OperationAbstraction > OperatorRegistry::PrefixOperator < Return, Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::AlgorithmAbstraction < Return, Param > > ( m_callback );
+std::unique_ptr < abstraction::OperationAbstraction > OperatorRegistry::PrefixOperator < Return, Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::AlgorithmAbstraction < Return, Param > > ( m_callback );
 }
 
 template < class Return, class Param >
-std::shared_ptr < abstraction::OperationAbstraction > OperatorRegistry::PostfixOperator < Return, Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::AlgorithmAbstraction < Return, Param > > ( m_callback );
+std::unique_ptr < abstraction::OperationAbstraction > OperatorRegistry::PostfixOperator < Return, Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::AlgorithmAbstraction < Return, Param > > ( m_callback );
 }
 
 } /* namespace abstraction */
diff --git a/alib2abstraction/src/registry/Registry.cpp b/alib2abstraction/src/registry/Registry.cpp
index c211ae1c8b0e3f7fc8c66a65c6a0cf6eb95fd4a8..d66ec41a0087fc14031dee81c3284f335e401ffe 100644
--- a/alib2abstraction/src/registry/Registry.cpp
+++ b/alib2abstraction/src/registry/Registry.cpp
@@ -45,27 +45,27 @@ ext::list < ext::pair < Operators::PostfixOperators, AlgorithmFullInfo > > Regis
 	return OperatorRegistry::listPostfixOverloads ( );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > Registry::getContainerAbstraction ( const std::string & container, const std::string & type ) {
+std::unique_ptr < abstraction::OperationAbstraction > Registry::getContainerAbstraction ( const std::string & container, const std::string & type ) {
 	return ContainerRegistry::getAbstraction ( container, type );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > Registry::getAlgorithmAbstraction ( const std::string & name, const ext::vector < std::string > & templateParams, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
+std::unique_ptr < abstraction::OperationAbstraction > Registry::getAlgorithmAbstraction ( const std::string & name, const ext::vector < std::string > & templateParams, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
 	return AlgorithmRegistry::getAbstraction ( name, templateParams, paramTypes, typeQualifiers, category );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > Registry::getBinaryOperatorAbstraction ( Operators::BinaryOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
+std::unique_ptr < abstraction::OperationAbstraction > Registry::getBinaryOperatorAbstraction ( Operators::BinaryOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
 	return OperatorRegistry::getBinaryAbstraction ( type, paramTypes, typeQualifiers, category );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > Registry::getPrefixOperatorAbstraction ( Operators::PrefixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
+std::unique_ptr < abstraction::OperationAbstraction > Registry::getPrefixOperatorAbstraction ( Operators::PrefixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
 	return OperatorRegistry::getPrefixAbstraction ( type, paramTypes, typeQualifiers, category );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > Registry::getPostfixOperatorAbstraction ( Operators::PostfixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
+std::unique_ptr < abstraction::OperationAbstraction > Registry::getPostfixOperatorAbstraction ( Operators::PostfixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory category ) {
 	return OperatorRegistry::getPostfixAbstraction ( type, paramTypes, typeQualifiers, category );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > Registry::getCastAbstraction ( const std::string & target, const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > Registry::getCastAbstraction ( const std::string & target, const std::string & param ) {
 	return CastRegistry::getAbstraction ( target, param );
 }
 
@@ -73,7 +73,7 @@ bool Registry::isCastNoOp ( const std::string & target, const std::string & para
 	return CastRegistry::isNoOp ( target, param );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > Registry::getNormalizeAbstraction ( const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > Registry::getNormalizeAbstraction ( const std::string & param ) {
 	return NormalizeRegistry::getAbstraction ( param );
 }
 
@@ -81,7 +81,7 @@ bool Registry::hasNormalize ( const std::string & param ) {
 	return NormalizeRegistry::hasNormalize ( param );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > Registry::getValuePrinterAbstraction ( const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > Registry::getValuePrinterAbstraction ( const std::string & param ) {
 	return ValuePrinterRegistry::getAbstraction ( param );
 }
 
diff --git a/alib2abstraction/src/registry/Registry.h b/alib2abstraction/src/registry/Registry.h
index d177672da5bb7cc40f24ea9dcf25fd4e2c7c6b50..2221356dd6dd82ac6e910a35f7edc946992c9452 100644
--- a/alib2abstraction/src/registry/Registry.h
+++ b/alib2abstraction/src/registry/Registry.h
@@ -28,16 +28,16 @@ public:
 	static ext::list < ext::pair < Operators::PrefixOperators, AlgorithmFullInfo > > listPrefixOperators ( );
 	static ext::list < ext::pair < Operators::PostfixOperators, AlgorithmFullInfo > > listPostfixOperators ( );
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getContainerAbstraction ( const std::string & container, const std::string & type );
-	static std::shared_ptr < abstraction::OperationAbstraction > getAlgorithmAbstraction ( const std::string & name, const ext::vector < std::string > & templateParams, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory );
-	static std::shared_ptr < abstraction::OperationAbstraction > getBinaryOperatorAbstraction ( Operators::BinaryOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory );
-	static std::shared_ptr < abstraction::OperationAbstraction > getPrefixOperatorAbstraction ( Operators::PrefixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory );
-	static std::shared_ptr < abstraction::OperationAbstraction > getPostfixOperatorAbstraction ( Operators::PostfixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory );
-	static std::shared_ptr < abstraction::OperationAbstraction > getCastAbstraction ( const std::string & target, const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getContainerAbstraction ( const std::string & container, const std::string & type );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAlgorithmAbstraction ( const std::string & name, const ext::vector < std::string > & templateParams, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory );
+	static std::unique_ptr < abstraction::OperationAbstraction > getBinaryOperatorAbstraction ( Operators::BinaryOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory );
+	static std::unique_ptr < abstraction::OperationAbstraction > getPrefixOperatorAbstraction ( Operators::PrefixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory );
+	static std::unique_ptr < abstraction::OperationAbstraction > getPostfixOperatorAbstraction ( Operators::PostfixOperators type, const ext::vector < std::string > & paramTypes, const ext::vector < abstraction::TypeQualifiers::TypeQualifierSet > & typeQualifiers, AlgorithmCategories::AlgorithmCategory );
+	static std::unique_ptr < abstraction::OperationAbstraction > getCastAbstraction ( const std::string & target, const std::string & param );
 	static bool isCastNoOp ( const std::string & target, const std::string & param );
-	static std::shared_ptr < abstraction::OperationAbstraction > getNormalizeAbstraction ( const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getNormalizeAbstraction ( const std::string & param );
 	static bool hasNormalize ( const std::string & param );
-	static std::shared_ptr < abstraction::OperationAbstraction > getValuePrinterAbstraction ( const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getValuePrinterAbstraction ( const std::string & param );
 };
 
 } /* namespace abstraction */
diff --git a/alib2abstraction/src/registry/ValuePrinterRegistry.cpp b/alib2abstraction/src/registry/ValuePrinterRegistry.cpp
index 91a70cd9568bce259de800e5a26924d7ab1be52a..8cf65aabe38c64574b7a04148140bc5365fad75e 100644
--- a/alib2abstraction/src/registry/ValuePrinterRegistry.cpp
+++ b/alib2abstraction/src/registry/ValuePrinterRegistry.cpp
@@ -7,7 +7,7 @@ ext::map < std::string, std::unique_ptr < ValuePrinterRegistry::Entry > > & Valu
 	return fileWriters;
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::getAbstraction ( const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::getAbstraction ( const std::string & param ) {
 	auto res = getEntries ( ).find ( param );
 	if ( res == getEntries ( ).end ( ) )
 		throw std::invalid_argument ( "Entry " + param + " not available." );
@@ -27,8 +27,8 @@ void ValuePrinterRegistry::registerValuePrinter ( std::string param, std::unique
 }
 
 template < >
-std::shared_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::EntryImpl < void >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::ValuePrinterAbstraction < void > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::EntryImpl < void >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::ValuePrinterAbstraction < void > > ( );
 }
 
 } /* namespace abstraction */
diff --git a/alib2abstraction/src/registry/ValuePrinterRegistry.hpp b/alib2abstraction/src/registry/ValuePrinterRegistry.hpp
index 9f59bd43a104a1cc56245aa4ecca2e84153bb6f5..1e9523dfccad024413742e0db6cc47fe413df805 100644
--- a/alib2abstraction/src/registry/ValuePrinterRegistry.hpp
+++ b/alib2abstraction/src/registry/ValuePrinterRegistry.hpp
@@ -21,7 +21,7 @@ private:
 	public:
 		EntryImpl ( ) = default;
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, std::unique_ptr < Entry > > & getEntries ( );
@@ -48,7 +48,7 @@ public:
 		registerValuePrinter < ParamType > ( std::move ( param ) );
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
 };
 
 } /* namespace abstraction */
@@ -58,12 +58,12 @@ public:
 namespace abstraction {
 
 template < class Param >
-std::shared_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::EntryImpl < Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::ValuePrinterAbstraction < const Param & > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::EntryImpl < Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::ValuePrinterAbstraction < const Param & > > ( );
 }
 
 template < >
-std::shared_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::EntryImpl < void >::getAbstraction ( ) const;
+std::unique_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::EntryImpl < void >::getAbstraction ( ) const;
 
 } /* namespace abstraction */
 
diff --git a/alib2cli/src/registration/InputFileTypeRegistration.cpp b/alib2cli/src/registration/InputFileTypeRegistration.cpp
index 12692dd6c62b789802c647610c15b1fe7a1b5fdc..8c95103d1a500f6aaef4e3480d2a163c4e6aa016 100644
--- a/alib2cli/src/registration/InputFileTypeRegistration.cpp
+++ b/alib2cli/src/registration/InputFileTypeRegistration.cpp
@@ -12,14 +12,14 @@
 
 namespace {
 
-	std::shared_ptr < abstraction::OperationAbstraction > dummy ( const std::string & typehint, const ext::vector < std::string > & templateParams ) {
+	std::unique_ptr < abstraction::OperationAbstraction > dummy ( const std::string & typehint, const ext::vector < std::string > & templateParams ) {
 		if ( typehint == "set" || typehint == "Set" ) {
 			ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions;
 
-			abstractions.push_back ( std::make_shared < abstraction::XmlTokensParserAbstraction > ( ) );
+			abstractions.push_back ( std::make_unique < abstraction::XmlTokensParserAbstraction > ( ) );
 			abstractions.push_back ( abstraction::XmlRegistry::getXmlContainerParserAbstraction ( "Set", templateParams [ 0 ] ) );
 
-			std::shared_ptr < abstraction::PackingAbstraction < 1 > > res = std::make_shared < abstraction::PackingAbstraction < 1 > > ( std::move ( abstractions ), 1 );
+			std::unique_ptr < abstraction::PackingAbstraction < 1 > > res = std::make_unique < abstraction::PackingAbstraction < 1 > > ( std::move ( abstractions ), 1 );
 			res->setInnerConnection ( 0, 1, 0 );
 			res->setOuterConnection ( 0, 0, 0 );
 
@@ -27,7 +27,7 @@ namespace {
 		} else {
 			ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions;
 
-			abstractions.push_back ( std::make_shared < abstraction::XmlTokensParserAbstraction > ( ) );
+			abstractions.push_back ( std::make_unique < abstraction::XmlTokensParserAbstraction > ( ) );
 
 			auto xmlParserAbstractionFinder = [ = ] ( const ext::deque < sax::Token > & tokens ) {
 				std::string type;
@@ -39,9 +39,9 @@ namespace {
 				return abstraction::XmlRegistry::getXmlParserAbstraction ( type );
 			};
 
-			abstractions.push_back ( std::make_shared < abstraction::WrapperAbstraction < const ext::deque < sax::Token > & > > ( xmlParserAbstractionFinder ) );
+			abstractions.push_back ( std::make_unique < abstraction::WrapperAbstraction < const ext::deque < sax::Token > & > > ( xmlParserAbstractionFinder ) );
 
-			std::shared_ptr < abstraction::PackingAbstraction < 1 > > res = std::make_shared < abstraction::PackingAbstraction < 1 > > ( std::move ( abstractions ), 1 );
+			std::unique_ptr < abstraction::PackingAbstraction < 1 > > res = std::make_unique < abstraction::PackingAbstraction < 1 > > ( std::move ( abstractions ), 1 );
 			res->setInnerConnection ( 0, 1, 0 );
 			res->setOuterConnection ( 0, 0, 0 );
 
@@ -49,7 +49,7 @@ namespace {
 		}
 	}
 
-	std::shared_ptr < abstraction::OperationAbstraction > dummy2 ( const std::string &, const ext::vector < std::string > & ) {
+	std::unique_ptr < abstraction::OperationAbstraction > dummy2 ( const std::string &, const ext::vector < std::string > & ) {
 		ext::vector < std::string > templateParams;
 		ext::vector < std::string > paramTypes { ext::to_string < std::string > ( ) };
 		abstraction::AlgorithmCategories::AlgorithmCategory category = abstraction::AlgorithmCategories::AlgorithmCategory::NONE;
diff --git a/alib2cli/src/registration/InputFileTypeRegistration.hpp b/alib2cli/src/registration/InputFileTypeRegistration.hpp
index 46c5bba7e4f9c50e7dac8e84d7921621af16134a..211789ae7c212f79382a40546b096987c0b19ad1 100644
--- a/alib2cli/src/registration/InputFileTypeRegistration.hpp
+++ b/alib2cli/src/registration/InputFileTypeRegistration.hpp
@@ -8,7 +8,7 @@ class InputFileRegister {
 	std::string m_FileType;
 
 public:
-	InputFileRegister ( std::string fileType, std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & type, const ext::vector < std::string > & templateParams ) ) : m_FileType ( std::move ( fileType ) ) {
+	InputFileRegister ( std::string fileType, std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & type, const ext::vector < std::string > & templateParams ) ) : m_FileType ( std::move ( fileType ) ) {
 		abstraction::InputFileRegistry::registerInputFileHandler ( m_FileType, callback );
 	}
 
diff --git a/alib2cli/src/registration/OutputFileTypeRegistration.cpp b/alib2cli/src/registration/OutputFileTypeRegistration.cpp
index 55ce715c09c7b54c75e473bc509f1194fd132521..72bbaf1b019ee9ef181af338e0f422d99f983c98 100644
--- a/alib2cli/src/registration/OutputFileTypeRegistration.cpp
+++ b/alib2cli/src/registration/OutputFileTypeRegistration.cpp
@@ -13,14 +13,14 @@
 
 namespace {
 
-	std::shared_ptr < abstraction::OperationAbstraction > dummy ( const std::string & typehint ) {
+	std::unique_ptr < abstraction::OperationAbstraction > dummy ( const std::string & typehint ) {
 		ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions;
 
 		abstractions.push_back ( abstraction::XmlRegistry::getXmlComposerAbstraction ( typehint ) );
 
-		abstractions.push_back ( std::make_shared < abstraction::XmlTokensComposerAbstraction > ( ) );
+		abstractions.push_back ( std::make_unique < abstraction::XmlTokensComposerAbstraction > ( ) );
 
-		std::shared_ptr < abstraction::PackingAbstraction < 2 > > res = std::make_shared < abstraction::PackingAbstraction < 2 > > ( std::move ( abstractions ), 1 );
+		std::unique_ptr < abstraction::PackingAbstraction < 2 > > res = std::make_unique < abstraction::PackingAbstraction < 2 > > ( std::move ( abstractions ), 1 );
 
 		res->setInnerConnection ( 0, 1, 0 );
 		res->setOuterConnection ( 0, 1, 1 ); // filename
@@ -29,7 +29,7 @@ namespace {
 		return res;
 	}
 
-	std::shared_ptr < abstraction::OperationAbstraction > dummy2 ( const std::string & ) {
+	std::unique_ptr < abstraction::OperationAbstraction > dummy2 ( const std::string & ) {
 		ext::vector < std::string > templateParams;
 		ext::vector < std::string > paramTypes { ext::to_string < std::string > ( ), ext::to_string < std::string > ( ) };
 		abstraction::AlgorithmCategories::AlgorithmCategory category = abstraction::AlgorithmCategories::AlgorithmCategory::NONE;
diff --git a/alib2cli/src/registration/OutputFileTypeRegistration.hpp b/alib2cli/src/registration/OutputFileTypeRegistration.hpp
index e2fe84dad48037e30c10e2e96f72520de81c6826..482e02126a7d17dad50b6c97764029c196445bf5 100644
--- a/alib2cli/src/registration/OutputFileTypeRegistration.hpp
+++ b/alib2cli/src/registration/OutputFileTypeRegistration.hpp
@@ -8,7 +8,7 @@ class OutputFileRegister {
 	std::string m_FileType;
 
 public:
-	OutputFileRegister ( std::string fileType, std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & typehint ) ) : m_FileType ( std::move ( fileType ) ) {
+	OutputFileRegister ( std::string fileType, std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & typehint ) ) : m_FileType ( std::move ( fileType ) ) {
 		abstraction::OutputFileRegistry::registerOutputFileHandler ( m_FileType, callback );
 	}
 
diff --git a/alib2cli/src/registry/InputFileRegistry.cpp b/alib2cli/src/registry/InputFileRegistry.cpp
index e4b0a4b82b400114f87b9419e50c2f82d7f5e0d5..3d12a14c4ceb3bab32e080cd45da0a5201fb0c4d 100644
--- a/alib2cli/src/registry/InputFileRegistry.cpp
+++ b/alib2cli/src/registry/InputFileRegistry.cpp
@@ -8,7 +8,7 @@ ext::map < std::string, std::unique_ptr < InputFileRegistry::Entry > > & InputFi
 	return inputFileHandlers;
 }
 
-void InputFileRegistry::registerInputFileHandler ( const std::string & fileType, std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & type, const ext::vector < std::string > & templateParams ) ) {
+void InputFileRegistry::registerInputFileHandler ( const std::string & fileType, std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & type, const ext::vector < std::string > & templateParams ) ) {
 	auto iter = getEntries ( ).insert ( std::make_pair ( fileType, std::unique_ptr < Entry > ( new EntryImpl ( callback ) ) ) );
 	if ( ! iter.second )
 		throw std::invalid_argument ( "Entry " + iter.first->first + " already registered." );
@@ -19,7 +19,7 @@ void InputFileRegistry::unregisterInputFileHandler ( const std::string & fileTyp
 		throw std::invalid_argument ( "Entry " + fileType + " not registered." );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > InputFileRegistry::getAbstraction ( const std::string & fileType, const std::string & type, const ext::vector < std::string > & templateParams ) {
+std::unique_ptr < abstraction::OperationAbstraction > InputFileRegistry::getAbstraction ( const std::string & fileType, const std::string & type, const ext::vector < std::string > & templateParams ) {
 	auto res = getEntries ( ).find ( fileType );
 	if ( res == getEntries ( ).end ( ) )
 		throw exception::CommonException ( "Entry " + fileType + " not available." );
@@ -27,7 +27,7 @@ std::shared_ptr < abstraction::OperationAbstraction > InputFileRegistry::getAbst
 	return res->second->getAbstraction ( type, templateParams );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > InputFileRegistry::EntryImpl::getAbstraction ( const std::string & type, const ext::vector < std::string > & templateParams ) const {
+std::unique_ptr < abstraction::OperationAbstraction > InputFileRegistry::EntryImpl::getAbstraction ( const std::string & type, const ext::vector < std::string > & templateParams ) const {
 	return m_callback ( type, templateParams );
 }
 
diff --git a/alib2cli/src/registry/InputFileRegistry.hpp b/alib2cli/src/registry/InputFileRegistry.hpp
index 2e33eb794938f2cff3b10141389552b1786fa062..e27b2704f13b83573a9ec2174a8a08dd4c205eb5 100644
--- a/alib2cli/src/registry/InputFileRegistry.hpp
+++ b/alib2cli/src/registry/InputFileRegistry.hpp
@@ -14,28 +14,28 @@ namespace abstraction {
 class InputFileRegistry {
 	class Entry {
 	public:
-		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & type, const ext::vector < std::string > & templateParams ) const = 0;
+		virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & type, const ext::vector < std::string > & templateParams ) const = 0;
 
 		virtual ~Entry ( ) = default;
 	};
 
 	class EntryImpl : public Entry {
-		std::function < std::shared_ptr < abstraction::OperationAbstraction > ( const std::string & type, const ext::vector < std::string > & templateParams ) > m_callback;
+		std::function < std::unique_ptr < abstraction::OperationAbstraction > ( const std::string & type, const ext::vector < std::string > & templateParams ) > m_callback;
 	public:
-		explicit EntryImpl ( std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & type, const ext::vector < std::string > & templateParams ) ) : m_callback ( callback ) {
+		explicit EntryImpl ( std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & type, const ext::vector < std::string > & templateParams ) ) : m_callback ( callback ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & type, const ext::vector < std::string > & templateParams ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & type, const ext::vector < std::string > & templateParams ) const override;
 	};
 
 	static ext::map < std::string, std::unique_ptr < Entry > > & getEntries ( );
 
 public:
-	static void registerInputFileHandler ( const std::string & fileType, std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & type, const ext::vector < std::string > & templateParams ) );
+	static void registerInputFileHandler ( const std::string & fileType, std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & type, const ext::vector < std::string > & templateParams ) );
 
 	static void unregisterInputFileHandler ( const std::string & fileType );
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & fileType, const std::string & type, const ext::vector < std::string > & templateParams );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & fileType, const std::string & type, const ext::vector < std::string > & templateParams );
 };
 
 } /* namespace abstraction */
diff --git a/alib2cli/src/registry/OutputFileRegistry.cpp b/alib2cli/src/registry/OutputFileRegistry.cpp
index 5585d8df0ece2d12f6ffe329cbe2a2290acb9bd1..6d7444dbad53ec138c0f8f09c53894186edf4278 100644
--- a/alib2cli/src/registry/OutputFileRegistry.cpp
+++ b/alib2cli/src/registry/OutputFileRegistry.cpp
@@ -7,7 +7,7 @@ ext::map < std::string, std::unique_ptr < OutputFileRegistry::Entry > > & Output
 	return inputFileHandlers;
 }
 
-void OutputFileRegistry::registerOutputFileHandler ( const std::string & fileType, std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & typehint ) ) {
+void OutputFileRegistry::registerOutputFileHandler ( const std::string & fileType, std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & typehint ) ) {
 	auto iter = getEntries ( ).insert ( std::make_pair ( fileType, std::unique_ptr < Entry > ( new EntryImpl ( callback ) ) ) );
 	if ( ! iter.second )
 		throw std::invalid_argument ( "Entry " + iter.first->first + " already registered." );
@@ -18,7 +18,7 @@ void OutputFileRegistry::unregisterOutputFileHandler ( const std::string & fileT
 		throw std::invalid_argument ( "Entry " + fileType + " not registered." );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > OutputFileRegistry::getAbstraction ( const std::string & fileType, const std::string & typehint ) {
+std::unique_ptr < abstraction::OperationAbstraction > OutputFileRegistry::getAbstraction ( const std::string & fileType, const std::string & typehint ) {
 	auto res = getEntries ( ).find ( fileType );
 	if ( res == getEntries ( ).end ( ) )
 		throw exception::CommonException ( "Entry " + fileType + " not available." );
@@ -26,7 +26,7 @@ std::shared_ptr < abstraction::OperationAbstraction > OutputFileRegistry::getAbs
 	return res->second->getAbstraction ( typehint );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > OutputFileRegistry::EntryImpl::getAbstraction ( const std::string & typehint ) const {
+std::unique_ptr < abstraction::OperationAbstraction > OutputFileRegistry::EntryImpl::getAbstraction ( const std::string & typehint ) const {
 	return m_callback ( typehint );
 }
 
diff --git a/alib2cli/src/registry/OutputFileRegistry.hpp b/alib2cli/src/registry/OutputFileRegistry.hpp
index 772b94d1e1b74e9cc9c848bb7257be0efbe779c8..6ddaa4a78148fefd58efb0c13cded5c20da07cde 100644
--- a/alib2cli/src/registry/OutputFileRegistry.hpp
+++ b/alib2cli/src/registry/OutputFileRegistry.hpp
@@ -13,28 +13,28 @@ namespace abstraction {
 class OutputFileRegistry {
 	class Entry {
 	public:
-		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & typehint ) const = 0;
+		virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & typehint ) const = 0;
 
 		virtual ~Entry ( ) = default;
 	};
 
 	class EntryImpl : public Entry {
-		std::function < std::shared_ptr < abstraction::OperationAbstraction > ( const std::string & typehint ) > m_callback;
+		std::function < std::unique_ptr < abstraction::OperationAbstraction > ( const std::string & typehint ) > m_callback;
 	public:
-		explicit EntryImpl ( std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & typehint ) ) : m_callback ( callback ) {
+		explicit EntryImpl ( std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & typehint ) ) : m_callback ( callback ) {
 		}
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & typehint ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & typehint ) const override;
 	};
 
 	static ext::map < std::string, std::unique_ptr < Entry > > & getEntries ( );
 
 public:
-	static void registerOutputFileHandler ( const std::string & fileType, std::shared_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & typehint ) );
+	static void registerOutputFileHandler ( const std::string & fileType, std::unique_ptr < abstraction::OperationAbstraction > ( * callback ) ( const std::string & typehint ) );
 
 	static void unregisterOutputFileHandler ( const std::string & fileType );
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & fileType, const std::string & typehint );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & fileType, const std::string & typehint );
 };
 
 } /* namespace abstraction */
diff --git a/alib2raw/src/registration/RawRegistration.hpp b/alib2raw/src/registration/RawRegistration.hpp
index 8cf60329a157a0cad9cb7952d4cf64b6707beeb0..5e74b7a12810109d99a481bc805de4bf1bb5352b 100644
--- a/alib2raw/src/registration/RawRegistration.hpp
+++ b/alib2raw/src/registration/RawRegistration.hpp
@@ -10,7 +10,7 @@ namespace raw {
 template < class Type >
 class Parse {
 public:
-	static std::shared_ptr < abstraction::OperationAbstraction > abstractionFromString ( const std::string & ) {
+	static std::unique_ptr < abstraction::OperationAbstraction > abstractionFromString ( const std::string & ) {
 		return abstraction::RawReaderRegistry::getAbstraction ( ext::to_string < Type > ( ) );
 	}
 
@@ -19,7 +19,7 @@ public:
 class Compose {
 public:
 	template < class Type >
-	static std::shared_ptr < abstraction::OperationAbstraction > abstractionFromType ( const Type & ) {
+	static std::unique_ptr < abstraction::OperationAbstraction > abstractionFromType ( const Type & ) {
 		return abstraction::RawWriterRegistry::getAbstraction ( ext::to_string < Type > ( ) );
 	}
 
diff --git a/alib2raw/src/registry/RawReaderRegistry.cpp b/alib2raw/src/registry/RawReaderRegistry.cpp
index ec6d334db9fd4a376345fa6e2f863a7f890c2442..7f48633a33c52214074098d9acfeaceb1355a717 100644
--- a/alib2raw/src/registry/RawReaderRegistry.cpp
+++ b/alib2raw/src/registry/RawReaderRegistry.cpp
@@ -19,7 +19,7 @@ void RawReaderRegistry::registerRawReader ( std::string type, std::unique_ptr <
 		throw std::invalid_argument ( "Entry " + iter.first->first + " already registered." );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > RawReaderRegistry::getAbstraction ( const std::string & type ) {
+std::unique_ptr < abstraction::OperationAbstraction > RawReaderRegistry::getAbstraction ( const std::string & type ) {
 	auto iter = std::find_if ( getEntries ( ).begin ( ), getEntries ( ).end ( ), [ & ] ( const std::pair < const std::string, std::unique_ptr < Entry > > & entry ) { return ext::is_same_type ( entry.first, type ); } );
 	if ( iter == getEntries ( ).end ( ) ) {
 		throw exception::CommonException ( "Entry " + type + " not available." );
diff --git a/alib2raw/src/registry/RawReaderRegistry.hpp b/alib2raw/src/registry/RawReaderRegistry.hpp
index c5e093588cc96cac3ad710c20a877ed38a43055c..146dffab06a5240beab8eec46e4d1ab7b750e6bc 100644
--- a/alib2raw/src/registry/RawReaderRegistry.hpp
+++ b/alib2raw/src/registry/RawReaderRegistry.hpp
@@ -14,7 +14,7 @@ class RawReaderRegistry {
 public:
 	class Entry {
 	public:
-		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
+		virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
 
 		virtual ~Entry ( ) = default;
 	};
@@ -23,7 +23,7 @@ private:
 	template < class Return >
 	class EntryImpl : public Entry {
 	public:
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, std::unique_ptr < Entry > > & getEntries ( );
@@ -50,7 +50,7 @@ public:
 		registerRawReader < ReturnType > ( std::move ( type ) );
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & type );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & type );
 };
 
 } /* namespace abstraction */
@@ -60,8 +60,8 @@ public:
 namespace abstraction {
 
 template < class Return >
-std::shared_ptr < abstraction::OperationAbstraction > RawReaderRegistry::EntryImpl < Return >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::RawReaderAbstraction < Return > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > RawReaderRegistry::EntryImpl < Return >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::RawReaderAbstraction < Return > > ( );
 }
 
 } /* namespace abstraction */
diff --git a/alib2raw/src/registry/RawWriterRegistry.cpp b/alib2raw/src/registry/RawWriterRegistry.cpp
index dd3a46afb71023a30d8b8596a32017d92e563de4..502689eb171ef0d5aa4ddcf31432dfee4dd4f271 100644
--- a/alib2raw/src/registry/RawWriterRegistry.cpp
+++ b/alib2raw/src/registry/RawWriterRegistry.cpp
@@ -19,7 +19,7 @@ void RawWriterRegistry::registerRawWriter ( std::string param, std::unique_ptr <
 		throw std::invalid_argument ( "Entry " + iter.first->first + " already registered." );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > RawWriterRegistry::getAbstraction ( const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > RawWriterRegistry::getAbstraction ( const std::string & param ) {
 	auto type = getEntries ( ).find ( param );
 	if ( type == getEntries ( ).end ( ) )
 		throw exception::CommonException ( "Entry " + param + " not available." );
diff --git a/alib2raw/src/registry/RawWriterRegistry.hpp b/alib2raw/src/registry/RawWriterRegistry.hpp
index 0cf7145ec7943bdc3e01674d403dbef165e6bc16..0a1d4bc0337c96d6a20696ee147b5eba65860f7a 100644
--- a/alib2raw/src/registry/RawWriterRegistry.hpp
+++ b/alib2raw/src/registry/RawWriterRegistry.hpp
@@ -15,7 +15,7 @@ class RawWriterRegistry {
 public:
 	class Entry {
 	public:
-		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
+		virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
 
 		virtual ~Entry ( ) = default;
 	};
@@ -26,7 +26,7 @@ private:
 	public:
 		EntryImpl ( ) = default;
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, std::unique_ptr < Entry > > & getEntries ( );
@@ -53,7 +53,7 @@ public:
 		registerRawWriter < ParamType > ( std::move ( param ) );
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
 };
 
 } /* namespace abstraction */
@@ -63,8 +63,8 @@ public:
 namespace abstraction {
 
 template < class Param >
-std::shared_ptr < abstraction::OperationAbstraction > RawWriterRegistry::EntryImpl < Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::RawWriterAbstraction < const Param & > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > RawWriterRegistry::EntryImpl < Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::RawWriterAbstraction < const Param & > > ( );
 }
 
 
diff --git a/alib2raw_cli_integration/src/InputFileTypeRegistration.cpp b/alib2raw_cli_integration/src/InputFileTypeRegistration.cpp
index 290059f6552c718c38c26a2ed6ba2a26a98c3e73..241d5c136131fe7e19d1a734ec76876ea7f52fa8 100644
--- a/alib2raw_cli_integration/src/InputFileTypeRegistration.cpp
+++ b/alib2raw_cli_integration/src/InputFileTypeRegistration.cpp
@@ -10,7 +10,7 @@
 
 namespace {
 
-	std::shared_ptr < abstraction::OperationAbstraction > dummy4 ( const std::string & typehint, const ext::vector < std::string > & ) {
+	std::unique_ptr < abstraction::OperationAbstraction > dummy4 ( const std::string & typehint, const ext::vector < std::string > & ) {
 		ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions;
 
 		ext::vector < std::string > templateParams;
@@ -24,9 +24,9 @@ namespace {
 			return abstraction::RawReaderRegistry::getAbstraction ( typehint );
 		};
 
-		abstractions.push_back ( std::make_shared < abstraction::WrapperAbstraction < std::string && > > ( rawParserAbstractionFinder ) );
+		abstractions.push_back ( std::make_unique < abstraction::WrapperAbstraction < std::string && > > ( rawParserAbstractionFinder ) );
 
-		std::shared_ptr < abstraction::PackingAbstraction < 1 > > res = std::make_shared < abstraction::PackingAbstraction < 1 > > ( abstractions, 1 );
+		std::unique_ptr < abstraction::PackingAbstraction < 1 > > res = std::make_unique < abstraction::PackingAbstraction < 1 > > ( abstractions, 1 );
 		res->setInnerConnection ( 0, 1, 0 );
 		res->setOuterConnection ( 0, 0, 0 );
 
diff --git a/alib2raw_cli_integration/src/OutputFileTypeRegistration.cpp b/alib2raw_cli_integration/src/OutputFileTypeRegistration.cpp
index f053d04d34c5a7b2f66e3e530644294b738b9aec..bb9e1be827ebe2818380108aa7caacf096790f5d 100644
--- a/alib2raw_cli_integration/src/OutputFileTypeRegistration.cpp
+++ b/alib2raw_cli_integration/src/OutputFileTypeRegistration.cpp
@@ -9,7 +9,7 @@
 
 namespace {
 
-	std::shared_ptr < abstraction::OperationAbstraction > dummy4 ( const std::string & typehint ) {
+	std::unique_ptr < abstraction::OperationAbstraction > dummy4 ( const std::string & typehint ) {
 		ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions;
 
 		abstractions.push_back ( abstraction::RawWriterRegistry::getAbstraction ( typehint ) );
@@ -21,7 +21,7 @@ namespace {
 
 		abstractions.push_back ( abstraction::Registry::getAlgorithmAbstraction ( "cli::builtin::WriteFile", templateParams, paramTypes, paramTypeQualifiers, category ) );
 
-		std::shared_ptr < abstraction::PackingAbstraction < 2 > > res = std::make_shared < abstraction::PackingAbstraction < 2 > > ( abstractions, 1 );
+		std::unique_ptr < abstraction::PackingAbstraction < 2 > > res = std::make_unique < abstraction::PackingAbstraction < 2 > > ( abstractions, 1 );
 		res->setInnerConnection ( 0, 1, 1 );
 		res->setOuterConnection ( 0, 1, 0 ); // filename
 		res->setOuterConnection ( 1, 0, 0 ); // data
diff --git a/alib2str/src/registration/StringRegistration.hpp b/alib2str/src/registration/StringRegistration.hpp
index 2fda2ea32824dc3eb7569689e453cf27bb60ce49..b3cfb50e9dbf6134e09eb64a4f6e30b31c62ce3c 100644
--- a/alib2str/src/registration/StringRegistration.hpp
+++ b/alib2str/src/registration/StringRegistration.hpp
@@ -10,7 +10,7 @@ namespace string {
 template < class Group >
 class Parse {
 public:
-	static std::shared_ptr < abstraction::OperationAbstraction > abstractionFromString ( std::string && data ) {
+	static std::unique_ptr < abstraction::OperationAbstraction > abstractionFromString ( std::string && data ) {
 		return abstraction::StringReaderRegistry::getAbstraction ( ext::to_string < Group > ( ), data );
 	}
 
@@ -19,7 +19,7 @@ public:
 class Compose {
 public:
 	template < class Type >
-	static std::shared_ptr < abstraction::OperationAbstraction > abstractionFromType ( const Type & ) {
+	static std::unique_ptr < abstraction::OperationAbstraction > abstractionFromType ( const Type & ) {
 		return abstraction::StringWriterRegistry::getAbstraction ( ext::to_string < Type > ( ) );
 	}
 
diff --git a/alib2str/src/registry/StringReaderRegistry.cpp b/alib2str/src/registry/StringReaderRegistry.cpp
index c10257a83671ca35e5981bb85c163a885fa4d31e..73eded43f3bd0e638e906a961aa28961550545b2 100644
--- a/alib2str/src/registry/StringReaderRegistry.cpp
+++ b/alib2str/src/registry/StringReaderRegistry.cpp
@@ -23,7 +23,7 @@ ext::list < std::pair < std::function < bool ( ext::istream & ) >, std::unique_p
 	return collection.insert ( collection.end ( ), std::make_pair ( std::move ( first ), std::move ( entry ) ) );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > StringReaderRegistry::getAbstraction ( const std::string & group, const std::string & str ) {
+std::unique_ptr < abstraction::OperationAbstraction > StringReaderRegistry::getAbstraction ( const std::string & group, const std::string & str ) {
 	ext::istringstream ss ( str );
 	while ( ext::isspace ( ss.peek ( ) ) )
 		ss.get ( );
diff --git a/alib2str/src/registry/StringReaderRegistry.hpp b/alib2str/src/registry/StringReaderRegistry.hpp
index b496e62c7180ac3bc7d0e68ec4e1ed1f5ccc9f7f..c94abced9b276e2e9a57999759b9d0a13d212ee7 100644
--- a/alib2str/src/registry/StringReaderRegistry.hpp
+++ b/alib2str/src/registry/StringReaderRegistry.hpp
@@ -18,7 +18,7 @@ class StringReaderRegistry {
 public:
 	class Entry {
 	public:
-		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
+		virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
 
 		virtual ~Entry ( ) = default;
 	};
@@ -29,7 +29,7 @@ private:
 	public:
 		EntryImpl ( ) = default;
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, ext::list < std::pair < std::function < bool ( ext::istream & ) >, std::unique_ptr < Entry > > > > & getEntries ( );
@@ -50,7 +50,7 @@ public:
 		return registerStringReader ( ext::to_string < Group > ( ), core::stringApi < ReturnType >::first, std::unique_ptr < Entry > ( new EntryImpl < ReturnType > ( ) ) );
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & group, const std::string & str );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & group, const std::string & str );
 };
 
 } /* namespace abstraction */
@@ -60,8 +60,8 @@ public:
 namespace abstraction {
 
 template < class Return >
-std::shared_ptr < abstraction::OperationAbstraction > StringReaderRegistry::EntryImpl < Return >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::StringReaderAbstraction < Return > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > StringReaderRegistry::EntryImpl < Return >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::StringReaderAbstraction < Return > > ( );
 }
 
 } /* namespace abstraction */
diff --git a/alib2str/src/registry/StringWriterRegistry.cpp b/alib2str/src/registry/StringWriterRegistry.cpp
index 9b0480f606d1e5c4a45c0cb7ff3f3490bdb2aa84..7eb8ac60e5f099597b38a750665c92c05cd1726f 100644
--- a/alib2str/src/registry/StringWriterRegistry.cpp
+++ b/alib2str/src/registry/StringWriterRegistry.cpp
@@ -19,7 +19,7 @@ void StringWriterRegistry::registerStringWriter ( std::string param, std::unique
 		throw std::invalid_argument ( "Entry " + iter.first->first + " already registered." );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > StringWriterRegistry::getAbstraction ( const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > StringWriterRegistry::getAbstraction ( const std::string & param ) {
 	auto type = getEntries ( ).find ( param );
 	if ( type == getEntries ( ).end ( ) )
 		throw exception::CommonException ( "Entry " + param + " not available." );
diff --git a/alib2str/src/registry/StringWriterRegistry.hpp b/alib2str/src/registry/StringWriterRegistry.hpp
index 688b7eeeaab721f0ae75170d148325bc8f446632..b56df719dfc4e8c0179f081a4d2ae5af26463d36 100644
--- a/alib2str/src/registry/StringWriterRegistry.hpp
+++ b/alib2str/src/registry/StringWriterRegistry.hpp
@@ -15,7 +15,7 @@ class StringWriterRegistry {
 public:
 	class Entry {
 	public:
-		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
+		virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
 
 		virtual ~Entry ( ) = default;
 
@@ -27,7 +27,7 @@ private:
 	public:
 		EntryImpl ( ) = default;
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, std::unique_ptr < Entry > > & getEntries ( );
@@ -54,7 +54,7 @@ public:
 		registerStringWriter < ParamType > ( std::move ( param ) );
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
 };
 
 } /* namespace abstraction */
@@ -64,8 +64,8 @@ public:
 namespace abstraction {
 
 template < class Param >
-std::shared_ptr < abstraction::OperationAbstraction > StringWriterRegistry::EntryImpl < Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::StringWriterAbstraction < const Param & > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > StringWriterRegistry::EntryImpl < Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::StringWriterAbstraction < const Param & > > ( );
 }
 
 
diff --git a/alib2str_cli_integration/src/InputFileTypeRegistration.cpp b/alib2str_cli_integration/src/InputFileTypeRegistration.cpp
index f16a97232dadd47d5fdf9c179aa8fddad1d739ef..2e32a39979e452e40d0d53b4d9196826930a0487 100644
--- a/alib2str_cli_integration/src/InputFileTypeRegistration.cpp
+++ b/alib2str_cli_integration/src/InputFileTypeRegistration.cpp
@@ -10,7 +10,7 @@
 
 namespace {
 
-	std::shared_ptr < abstraction::OperationAbstraction > dummy3 ( const std::string & typehint, const ext::vector < std::string > & ) {
+	std::unique_ptr < abstraction::OperationAbstraction > dummy3 ( const std::string & typehint, const ext::vector < std::string > & ) {
 		ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions;
 
 		ext::vector < std::string > templateParams;
@@ -24,9 +24,9 @@ namespace {
 			return abstraction::StringReaderRegistry::getAbstraction ( typehint, data );
 		};
 
-		abstractions.push_back ( std::make_shared < abstraction::WrapperAbstraction < std::string && > > ( stringParserAbstractionFinder ) );
+		abstractions.push_back ( std::make_unique < abstraction::WrapperAbstraction < std::string && > > ( stringParserAbstractionFinder ) );
 
-		std::shared_ptr < abstraction::PackingAbstraction < 1 > > res = std::make_shared < abstraction::PackingAbstraction < 1 > > ( abstractions, 1 );
+		std::unique_ptr < abstraction::PackingAbstraction < 1 > > res = std::make_unique < abstraction::PackingAbstraction < 1 > > ( abstractions, 1 );
 		res->setInnerConnection ( 0, 1, 0 );
 		res->setOuterConnection ( 0, 0, 0 );
 
diff --git a/alib2str_cli_integration/src/OutputFileTypeRegistration.cpp b/alib2str_cli_integration/src/OutputFileTypeRegistration.cpp
index 47bc0ee3b1069bc9e1d046ba476f29ef3a12c7de..f367156aa2d1132f7cdd838323ee3238c31e9335 100644
--- a/alib2str_cli_integration/src/OutputFileTypeRegistration.cpp
+++ b/alib2str_cli_integration/src/OutputFileTypeRegistration.cpp
@@ -9,7 +9,7 @@
 
 namespace {
 
-	std::shared_ptr < abstraction::OperationAbstraction > dummy3 ( const std::string & typehint ) {
+	std::unique_ptr < abstraction::OperationAbstraction > dummy3 ( const std::string & typehint ) {
 		ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions;
 
 		abstractions.push_back ( abstraction::StringWriterRegistry::getAbstraction ( typehint ) );
@@ -21,7 +21,7 @@ namespace {
 
 		abstractions.push_back ( abstraction::Registry::getAlgorithmAbstraction ( "cli::builtin::WriteFile", templateParams, paramTypes, paramTypeQualifiers, category ) );
 
-		std::shared_ptr < abstraction::PackingAbstraction < 2 > > res = std::make_shared < abstraction::PackingAbstraction < 2 > > ( abstractions, 1 );
+		std::unique_ptr < abstraction::PackingAbstraction < 2 > > res = std::make_unique < abstraction::PackingAbstraction < 2 > > ( abstractions, 1 );
 		res->setInnerConnection ( 0, 1, 1 );
 		res->setOuterConnection ( 0, 1, 0 ); // filename
 		res->setOuterConnection ( 1, 0, 0 ); // data
diff --git a/alib2xml/src/registration/XmlRegistration.hpp b/alib2xml/src/registration/XmlRegistration.hpp
index 9afff749b71c3844accbe0603cf067cfd3414a87..04bba20ea1482173901d43110662d404129e5edc 100644
--- a/alib2xml/src/registration/XmlRegistration.hpp
+++ b/alib2xml/src/registration/XmlRegistration.hpp
@@ -12,7 +12,7 @@ namespace xml {
 
 class Parse {
 public:
-	static std::shared_ptr < abstraction::OperationAbstraction > abstractionFromTokens ( ext::deque < sax::Token > && tokens ) {
+	static std::unique_ptr < abstraction::OperationAbstraction > abstractionFromTokens ( ext::deque < sax::Token > && tokens ) {
 		return abstraction::XmlRegistry::getXmlParserAbstraction ( tokens [ 0 ].getData ( ) );
 	}
 
@@ -21,7 +21,7 @@ public:
 class Compose {
 public:
 	template < class Type >
-	static std::shared_ptr < abstraction::OperationAbstraction > abstractionFromType ( const Type & ) {
+	static std::unique_ptr < abstraction::OperationAbstraction > abstractionFromType ( const Type & ) {
 		return abstraction::XmlRegistry::getXmlComposerAbstraction ( ext::to_string < Type > ( ) );
 	}
 
diff --git a/alib2xml/src/registry/XmlComposerRegistry.cpp b/alib2xml/src/registry/XmlComposerRegistry.cpp
index ce017b5e4409116e9cc6fed87872e462c16960ff..e7066314c47663525449dad225f1f84acf656c41 100644
--- a/alib2xml/src/registry/XmlComposerRegistry.cpp
+++ b/alib2xml/src/registry/XmlComposerRegistry.cpp
@@ -19,7 +19,7 @@ void XmlComposerRegistry::registerXmlComposer ( std::string param, std::unique_p
 		throw std::invalid_argument ( "Entry " + iter.first->first + " already registered." );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > XmlComposerRegistry::getAbstraction ( const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > XmlComposerRegistry::getAbstraction ( const std::string & param ) {
 	auto res = getEntries ( ).find ( param );
 	if ( res == getEntries ( ).end ( ) )
 		throw exception::CommonException ( "Entry " + param + " not available." );
diff --git a/alib2xml/src/registry/XmlComposerRegistry.hpp b/alib2xml/src/registry/XmlComposerRegistry.hpp
index 620abb4cc8170a63650fbb452864e7407a4ae800..fc4150447b06abd373e6abf4ed9b46a4c03507e3 100644
--- a/alib2xml/src/registry/XmlComposerRegistry.hpp
+++ b/alib2xml/src/registry/XmlComposerRegistry.hpp
@@ -15,7 +15,7 @@ class XmlComposerRegistry {
 public:
 	class Entry {
 	public:
-		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
+		virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
 
 		virtual ~Entry ( ) = default;
 	};
@@ -26,7 +26,7 @@ private:
 	public:
 		EntryImpl ( ) = default;
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, std::unique_ptr < Entry > > & getEntries ( );
@@ -53,7 +53,7 @@ public:
 		registerXmlComposer < ParamType > ( std::move ( param ) );
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
 
 	static ext::set < std::string > listGroup ( const std::string & group );
 
@@ -67,8 +67,8 @@ public:
 namespace abstraction {
 
 template < class Param >
-std::shared_ptr < abstraction::OperationAbstraction > XmlComposerRegistry::EntryImpl < Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::XmlComposerAbstraction < const Param & > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > XmlComposerRegistry::EntryImpl < Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::XmlComposerAbstraction < const Param & > > ( );
 }
 
 
diff --git a/alib2xml/src/registry/XmlContainerParserRegistry.cpp b/alib2xml/src/registry/XmlContainerParserRegistry.cpp
index cd4e4ae4f548f0e771b60aa3a069f8e07d62cc50..2ee66187957cabd401af874fe962150abd6eef9b 100644
--- a/alib2xml/src/registry/XmlContainerParserRegistry.cpp
+++ b/alib2xml/src/registry/XmlContainerParserRegistry.cpp
@@ -41,7 +41,7 @@ bool XmlContainerParserRegistry::hasAbstraction ( const std::string & container
 	return getEntries ( ).contains ( container );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > XmlContainerParserRegistry::getAbstraction ( const std::string & container, const std::string & type ) {
+std::unique_ptr < abstraction::OperationAbstraction > XmlContainerParserRegistry::getAbstraction ( const std::string & container, const std::string & type ) {
 	auto group = getEntries ( ).find ( container );
 	if ( group == getEntries ( ).end ( ) )
 		throw exception::CommonException ( "Entry " + container + " not available" );
diff --git a/alib2xml/src/registry/XmlContainerParserRegistry.hpp b/alib2xml/src/registry/XmlContainerParserRegistry.hpp
index b0a0c27459203bcfe4e1733042d87d5725e5c3e2..8b8c06439c4c6d6ec150ff2808e7fbaf0a10aefe 100644
--- a/alib2xml/src/registry/XmlContainerParserRegistry.hpp
+++ b/alib2xml/src/registry/XmlContainerParserRegistry.hpp
@@ -18,7 +18,7 @@ class XmlContainerParserRegistry {
 public:
 	class Entry {
 	public:
-		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
+		virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
 
 		virtual ~Entry ( ) = default;
 	};
@@ -27,7 +27,7 @@ private:
 	template < class Params >
 	class SetEntryImpl : public Entry {
 	public:
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, ext::list < ext::pair < std::string, std::unique_ptr < Entry > > > > & getEntries ( );
@@ -56,7 +56,7 @@ public:
 
 	static bool hasAbstraction ( const std::string & container );
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & container, const std::string & type );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & container, const std::string & type );
 
 	static ext::set < std::string > listOverloads ( const std::string & container );
 
@@ -70,8 +70,8 @@ public:
 namespace abstraction {
 
 template < class Param >
-std::shared_ptr < abstraction::OperationAbstraction > XmlContainerParserRegistry::SetEntryImpl < Param >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::XmlParserAbstraction < ext::set < Param > > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > XmlContainerParserRegistry::SetEntryImpl < Param >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::XmlParserAbstraction < ext::set < Param > > > ( );
 }
 
 } /* namespace abstraction */
diff --git a/alib2xml/src/registry/XmlParserRegistry.cpp b/alib2xml/src/registry/XmlParserRegistry.cpp
index adfbf3271f2c22a8e07d3a47fb494eef8c614a50..982c592533def3df474aac6ada0e75233ed4cac2 100644
--- a/alib2xml/src/registry/XmlParserRegistry.cpp
+++ b/alib2xml/src/registry/XmlParserRegistry.cpp
@@ -20,7 +20,7 @@ void XmlParserRegistry::registerXmlParser ( std::string result, std::unique_ptr
 		throw std::invalid_argument ( "Entry " + iter.first->first + " already registered." );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > XmlParserRegistry::getAbstraction ( const std::string & typeName ) {
+std::unique_ptr < abstraction::OperationAbstraction > XmlParserRegistry::getAbstraction ( const std::string & typeName ) {
 	auto type = getEntries ( ).find ( typeName );
 	if ( type == getEntries ( ).end ( ) )
 		throw exception::CommonException ( "Entry " + typeName + " not available." );
diff --git a/alib2xml/src/registry/XmlParserRegistry.hpp b/alib2xml/src/registry/XmlParserRegistry.hpp
index e019f04eb1edb6f2f17f2dcaaeb94550c5ee91ad..d536abfe61c3cc4db94078fd01587e08f19f58cb 100644
--- a/alib2xml/src/registry/XmlParserRegistry.hpp
+++ b/alib2xml/src/registry/XmlParserRegistry.hpp
@@ -15,7 +15,7 @@ class XmlParserRegistry {
 public:
 	class Entry {
 	public:
-		virtual std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
+		virtual std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const = 0;
 
 		virtual ~Entry ( ) = default;
 	};
@@ -26,7 +26,7 @@ private:
 	public:
 		EntryImpl ( ) = default;
 
-		std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
+		std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( ) const override;
 	};
 
 	static ext::map < std::string, std::unique_ptr < Entry > > & getEntries ( );
@@ -53,7 +53,7 @@ public:
 		registerXmlParser < ReturnType > ( std::move ( ret ) );
 	}
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & typeName );
+	static std::unique_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & typeName );
 };
 
 } /* namespace abstraction */
@@ -63,8 +63,8 @@ public:
 namespace abstraction {
 
 template < class Return >
-std::shared_ptr < abstraction::OperationAbstraction > XmlParserRegistry::EntryImpl < Return >::getAbstraction ( ) const {
-	return std::make_shared < abstraction::XmlParserAbstraction < Return > > ( );
+std::unique_ptr < abstraction::OperationAbstraction > XmlParserRegistry::EntryImpl < Return >::getAbstraction ( ) const {
+	return std::make_unique < abstraction::XmlParserAbstraction < Return > > ( );
 }
 
 } /* namespace abstraction */
diff --git a/alib2xml/src/registry/XmlRegistry.cpp b/alib2xml/src/registry/XmlRegistry.cpp
index d4cd3f1e6f6cb5b63eb5731185018be19c6ae550..be1ec104772bc2ce774290e63f497c4f8f66a2f1 100644
--- a/alib2xml/src/registry/XmlRegistry.cpp
+++ b/alib2xml/src/registry/XmlRegistry.cpp
@@ -14,15 +14,15 @@ ext::set < std::string > XmlRegistry::listDataTypeGroup ( const std::string & gr
 	return XmlComposerRegistry::listGroup ( group );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > XmlRegistry::getXmlComposerAbstraction ( const std::string & param ) {
+std::unique_ptr < abstraction::OperationAbstraction > XmlRegistry::getXmlComposerAbstraction ( const std::string & param ) {
 	return XmlComposerRegistry::getAbstraction ( param );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > XmlRegistry::getXmlParserAbstraction ( const std::string & type ) {
+std::unique_ptr < abstraction::OperationAbstraction > XmlRegistry::getXmlParserAbstraction ( const std::string & type ) {
 	return XmlParserRegistry::getAbstraction ( type );
 }
 
-std::shared_ptr < abstraction::OperationAbstraction > XmlRegistry::getXmlContainerParserAbstraction ( const std::string & container, const std::string & type ) {
+std::unique_ptr < abstraction::OperationAbstraction > XmlRegistry::getXmlContainerParserAbstraction ( const std::string & container, const std::string & type ) {
 	return XmlContainerParserRegistry::getAbstraction ( container, type );
 }
 
diff --git a/alib2xml/src/registry/XmlRegistry.h b/alib2xml/src/registry/XmlRegistry.h
index a6c59064ee010885bdaaecb979c3170110c616f1..04858138f30fb238b3a76a4cc3e9230b1afb6561 100644
--- a/alib2xml/src/registry/XmlRegistry.h
+++ b/alib2xml/src/registry/XmlRegistry.h
@@ -12,10 +12,10 @@ public:
 	static ext::set < std::string > listDataTypes ( );
 	static ext::set < std::string > listDataTypeGroup ( const std::string & group );
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getXmlComposerAbstraction ( const std::string & param );
-	static std::shared_ptr < abstraction::OperationAbstraction > getXmlParserAbstraction ( const std::string & type );
+	static std::unique_ptr < abstraction::OperationAbstraction > getXmlComposerAbstraction ( const std::string & param );
+	static std::unique_ptr < abstraction::OperationAbstraction > getXmlParserAbstraction ( const std::string & type );
 
-	static std::shared_ptr < abstraction::OperationAbstraction > getXmlContainerParserAbstraction ( const std::string & container, const std::string & type );
+	static std::unique_ptr < abstraction::OperationAbstraction > getXmlContainerParserAbstraction ( const std::string & container, const std::string & type );
 };
 
 } /* namespace abstraction */