From 3804db044468654918a2c8599986a60d33316c9a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Tr=C3=A1vn=C3=AD=C4=8Dek?= <jan.travnicek@fit.cvut.cz>
Date: Thu, 13 Jan 2022 11:49:37 +0100
Subject: [PATCH] abstraction: decrease use of shared_ptr

unique ptr is convertible to shared ptr natively. It makes sense to construct
unique_ptr first and convert it to shared_ptr if it is needed.
---
 .../src/common/OverloadResolution.hpp         |  2 +-
 .../src/registration/AlgoRegistration.hpp     |  2 +-
 .../src/registry/AlgorithmRegistry.cpp        |  6 ++--
 .../src/registry/AlgorithmRegistry.hpp        | 28 +++++++++----------
 .../src/registry/AlgorithmRegistryInfo.cpp    |  2 +-
 .../src/registry/BaseRegistryEntry.hpp        |  2 +-
 .../src/registry/CastRegistry.cpp             |  2 +-
 .../src/registry/CastRegistry.hpp             | 14 +++++-----
 .../src/registry/ContainerRegistry.cpp        |  2 +-
 .../src/registry/ContainerRegistry.hpp        |  8 +++---
 .../src/registry/NormalizeRegistry.cpp        |  2 +-
 .../src/registry/NormalizeRegistry.hpp        |  8 +++---
 .../src/registry/OperatorRegistry.cpp         |  6 ++--
 .../src/registry/OperatorRegistry.hpp         | 24 ++++++++--------
 alib2abstraction/src/registry/Registry.cpp    | 16 +++++------
 alib2abstraction/src/registry/Registry.h      | 16 +++++------
 .../src/registry/ValuePrinterRegistry.cpp     |  6 ++--
 .../src/registry/ValuePrinterRegistry.hpp     | 10 +++----
 .../InputFileTypeRegistration.cpp             | 14 +++++-----
 .../InputFileTypeRegistration.hpp             |  2 +-
 .../OutputFileTypeRegistration.cpp            |  8 +++---
 .../OutputFileTypeRegistration.hpp            |  2 +-
 alib2cli/src/registry/InputFileRegistry.cpp   |  6 ++--
 alib2cli/src/registry/InputFileRegistry.hpp   | 12 ++++----
 alib2cli/src/registry/OutputFileRegistry.cpp  |  6 ++--
 alib2cli/src/registry/OutputFileRegistry.hpp  | 12 ++++----
 alib2raw/src/registration/RawRegistration.hpp |  4 +--
 alib2raw/src/registry/RawReaderRegistry.cpp   |  2 +-
 alib2raw/src/registry/RawReaderRegistry.hpp   | 10 +++----
 alib2raw/src/registry/RawWriterRegistry.cpp   |  2 +-
 alib2raw/src/registry/RawWriterRegistry.hpp   | 10 +++----
 .../src/InputFileTypeRegistration.cpp         |  6 ++--
 .../src/OutputFileTypeRegistration.cpp        |  4 +--
 .../src/registration/StringRegistration.hpp   |  4 +--
 .../src/registry/StringReaderRegistry.cpp     |  2 +-
 .../src/registry/StringReaderRegistry.hpp     | 10 +++----
 .../src/registry/StringWriterRegistry.cpp     |  2 +-
 .../src/registry/StringWriterRegistry.hpp     | 10 +++----
 .../src/InputFileTypeRegistration.cpp         |  6 ++--
 .../src/OutputFileTypeRegistration.cpp        |  4 +--
 alib2xml/src/registration/XmlRegistration.hpp |  4 +--
 alib2xml/src/registry/XmlComposerRegistry.cpp |  2 +-
 alib2xml/src/registry/XmlComposerRegistry.hpp | 10 +++----
 .../registry/XmlContainerParserRegistry.cpp   |  2 +-
 .../registry/XmlContainerParserRegistry.hpp   | 10 +++----
 alib2xml/src/registry/XmlParserRegistry.cpp   |  2 +-
 alib2xml/src/registry/XmlParserRegistry.hpp   | 10 +++----
 alib2xml/src/registry/XmlRegistry.cpp         |  6 ++--
 alib2xml/src/registry/XmlRegistry.h           |  6 ++--
 49 files changed, 173 insertions(+), 173 deletions(-)

diff --git a/alib2abstraction/src/common/OverloadResolution.hpp b/alib2abstraction/src/common/OverloadResolution.hpp
index 8e09668e8c..9fdc29a9c6 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 f5cdc33aaf..3035972c88 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 1cd0da449e..5c882886f4 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 61d53cf43e..d9795eefd5 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 0545ce0ff8..491be96658 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 31bb1532e8..6b62fc934b 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 47a54c9437..c3d6ffb832 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 da83da39a8..5faaaa0759 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 a02d61e93b..9373a98c9a 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 06a338aacf..9b659c95fa 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 6db5787ed7..4fb66eda9a 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 f0bb128ef1..aef24b2889 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 fe81c2ed37..38ca79957c 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 4a04530b8d..e6efc14bf3 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 c211ae1c8b..d66ec41a00 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 d177672da5..2221356dd6 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 91a70cd956..8cf65aabe3 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 9f59bd43a1..1e9523dfcc 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 12692dd6c6..8c95103d1a 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 46c5bba7e4..211789ae7c 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 55ce715c09..72bbaf1b01 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 e2fe84dad4..482e02126a 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 e4b0a4b82b..3d12a14c4c 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 2e33eb7949..e27b2704f1 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 5585d8df0e..6d7444dbad 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 772b94d1e1..6ddaa4a781 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 8cf60329a1..5e74b7a128 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 ec6d334db9..7f48633a33 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 c5e093588c..146dffab06 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 dd3a46afb7..502689eb17 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 0cf7145ec7..0a1d4bc033 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 290059f655..241d5c1361 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 f053d04d34..bb9e1be827 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 2fda2ea328..b3cfb50e9d 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 c10257a836..73eded43f3 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 b496e62c71..c94abced9b 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 9b0480f606..7eb8ac60e5 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 688b7eeeaa..b56df719df 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 f16a97232d..2e32a39979 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 47bc0ee3b1..f367156aa2 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 9afff749b7..04bba20ea1 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 ce017b5e44..e7066314c4 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 620abb4cc8..fc4150447b 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 cd4e4ae4f5..2ee6618795 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 b0a0c27459..8b8c06439c 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 adfbf3271f..982c592533 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 e019f04eb1..d536abfe61 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 d4cd3f1e6f..be1ec10477 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 a6c59064ee..04858138f3 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 */
-- 
GitLab