diff --git a/alib2common/src/core/multipleDispatch.hpp b/alib2common/src/core/multipleDispatch.hpp
index 789d7d63d47ec1dedb9dcc67ef17352eb8d53405..c3e23662b76bf85391c2b812fc775c2a1f862bc4 100644
--- a/alib2common/src/core/multipleDispatch.hpp
+++ b/alib2common/src/core/multipleDispatch.hpp
@@ -24,7 +24,7 @@ template < class Algorithm, class ReturnType, class ... Params >
 class MultipleDispatch;
 
 template < class Algorithm, class ReturnType, class ... FrontStaticParamTypes, class ... DispatchedParameterTypes, class ... BackStaticParamTypes >
-class MultipleDispatch < Algorithm, ReturnType, tuple < FrontStaticParamTypes ... >, tuple < DispatchedParameterTypes ... >, tuple < BackStaticParamTypes ... > > {
+class MultipleDispatch < Algorithm, ReturnType, std::tuple < FrontStaticParamTypes ... >, std::tuple < DispatchedParameterTypes ... >, std::tuple < BackStaticParamTypes ... > > {
 public:
 	class RegistratorWrapperBase {
 	public:
@@ -32,10 +32,10 @@ public:
 	};
 
 private:
-	map < typename TupleBuilder < type_index, sizeof ... ( DispatchedParameterTypes ) >::type, RegistratorWrapperBase * > registeredFunctions;
+	std::map < typename std::TupleBuilder < std::type_index, sizeof ... ( DispatchedParameterTypes ) >::type, RegistratorWrapperBase * > registeredFunctions;
 
-	static MultipleDispatch < Algorithm, ReturnType, tuple < FrontStaticParamTypes ... >, tuple < DispatchedParameterTypes ... >, tuple < BackStaticParamTypes ... > > & getInstance ( ) {
-		static MultipleDispatch < Algorithm, ReturnType, tuple < FrontStaticParamTypes ... >, tuple < DispatchedParameterTypes ... >, tuple < BackStaticParamTypes ... > > res;
+	static MultipleDispatch < Algorithm, ReturnType, std::tuple < FrontStaticParamTypes ... >, std::tuple < DispatchedParameterTypes ... >, std::tuple < BackStaticParamTypes ... > > & getInstance ( ) {
+		static MultipleDispatch < Algorithm, ReturnType, std::tuple < FrontStaticParamTypes ... >, std::tuple < DispatchedParameterTypes ... >, std::tuple < BackStaticParamTypes ... > > res;
 
 		return res;
 	}
@@ -43,19 +43,19 @@ private:
 public:
 	template < class RealReturnType, class ... RealParameterTypeBases >
 	class RegistratorWrapper : public RegistratorWrapperBase {
-		function < RealReturnType ( FrontStaticParamTypes ..., typename match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && ..., BackStaticParamTypes ... ) > callback;
+		std::function < RealReturnType ( FrontStaticParamTypes ..., typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && ..., BackStaticParamTypes ... ) > callback;
 
 	public:
 		ReturnType eval ( FrontStaticParamTypes ... front, DispatchedParameterTypes && ... dispatched, BackStaticParamTypes ... back ) {
-			return ReturnType ( callback ( front ..., forward < typename match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type > ( static_cast < typename match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && > ( dispatched ) ) ..., back ... ) );
+			return ReturnType ( callback ( front ..., std::forward < typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type > ( static_cast < typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && > ( dispatched ) ) ..., back ... ) );
 		}
 
-		RegistratorWrapper ( RealReturnType ( * callback ) ( FrontStaticParamTypes ..., typename match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && ..., BackStaticParamTypes ... ) ) : callback ( callback ) {
-			if ( !getInstance ( ).registeredFunctions.insert ( make_pair ( make_tuple ( type_index ( typeid ( typename match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type ) ) ... ), this ) ).second ) {
-				stringstream ss;
-				( void ) initializer_list < int > { ( ss << cstringToString ( type_name < typename match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type > ( ) ), 0 ) ... };
+		RegistratorWrapper ( RealReturnType ( * callback ) ( FrontStaticParamTypes ..., typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && ..., BackStaticParamTypes ... ) ) : callback ( callback ) {
+			if ( !getInstance ( ).registeredFunctions.insert ( std::make_pair ( std::make_tuple ( std::type_index ( typeid ( typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type ) ) ... ), this ) ).second ) {
+				std::stringstream ss;
+				( void ) initializer_list < int > { ( ss << cstringToString ( std::type_name < typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type > ( ) ), 0 ) ... };
 
-				string classType = cstringToString ( type_name < Algorithm > ( ) );
+				std::string classType = cstringToString ( std::type_name < Algorithm > ( ) );
 
 				throw::exception::CommonException ( "Callback for " + ss.str ( ) + " already registered on " + classType + "." );
 			}
@@ -64,18 +64,18 @@ public:
 	};
 
 	static ReturnType dispatch ( FrontStaticParamTypes ... front, DispatchedParameterTypes && ... dispatched, BackStaticParamTypes ... back ) {
-		typename map < typename TupleBuilder < type_index, sizeof ... ( DispatchedParameterTypes ) >::type, RegistratorWrapperBase * >::iterator callback = getInstance ( ).registeredFunctions.find ( make_tuple ( type_index ( typeid ( dispatched ) ) ... ) );
+		typename std::map < typename std::TupleBuilder < std::type_index, sizeof ... ( DispatchedParameterTypes ) >::type, RegistratorWrapperBase * >::iterator callback = getInstance ( ).registeredFunctions.find ( std::make_tuple ( std::type_index ( typeid ( dispatched ) ) ... ) );
 
 		if ( callback == getInstance ( ).registeredFunctions.end ( ) ) {
-			stringstream ss;
-			( void ) initializer_list < int > { ( ss << cstringToString ( type_name ( typeid ( dispatched ) ) ), 0 ) ... };
+			std::stringstream ss;
+			( void ) initializer_list < int > { ( ss << cstringToString ( std::type_name ( typeid ( dispatched ) ) ), 0 ) ... };
 
-			string classType = cstringToString ( type_name < Algorithm > ( ) );
+			std::string classType = cstringToString ( std::type_name < Algorithm > ( ) );
 
 			throw::exception::CommonException ( "Callback for " + ss.str ( ) + " not registered on " + classType + "." );
 		}
 
-		return callback->second->eval ( front ..., forward < DispatchedParameterTypes > ( dispatched ) ..., back ... );
+		return callback->second->eval ( front ..., std::forward < DispatchedParameterTypes > ( dispatched ) ..., back ... );
 	}
 
 };
@@ -83,16 +83,16 @@ public:
 // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
 template < class Algorithm, class ReturnType, class FirstParameterType, class ... StaticParamTypes >
-using SingleDispatch = MultipleDispatch < Algorithm, ReturnType, tuple < >, tuple < FirstParameterType >, tuple < StaticParamTypes ... > >;
+using SingleDispatch = MultipleDispatch < Algorithm, ReturnType, std::tuple < >, std::tuple < FirstParameterType >, std::tuple < StaticParamTypes ... > >;
 
 template < class Algorithm, class ReturnType, class StaticParamType, class FirstParameterType >
-using SingleDispatchFirstStaticParam = MultipleDispatch < Algorithm, ReturnType, tuple < StaticParamType >, tuple < FirstParameterType >, tuple < > >;
+using SingleDispatchFirstStaticParam = MultipleDispatch < Algorithm, ReturnType, std::tuple < StaticParamType >, std::tuple < FirstParameterType >, std::tuple < > >;
 
 template < class Algorithm, class ReturnType, class FirstParameterType, class SecondParameterType, class ... StaticParamTypes >
-using DoubleDispatch = MultipleDispatch < Algorithm, ReturnType, tuple < >, tuple < FirstParameterType, SecondParameterType >, tuple < StaticParamTypes ... > >;
+using DoubleDispatch = MultipleDispatch < Algorithm, ReturnType, std::tuple < >, std::tuple < FirstParameterType, SecondParameterType >, std::tuple < StaticParamTypes ... > >;
 
 template < class Algorithm, class ReturnType, class StaticParamType, class FirstParameterType, class SecondParameterType >
-using DoubleDispatchFirstStaticParam = MultipleDispatch < Algorithm, ReturnType, tuple < StaticParamType >, tuple < FirstParameterType, SecondParameterType >, tuple < > >;
+using DoubleDispatchFirstStaticParam = MultipleDispatch < Algorithm, ReturnType, std::tuple < StaticParamType >, std::tuple < FirstParameterType, SecondParameterType >, std::tuple < > >;
 
 // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
@@ -117,21 +117,21 @@ private:
 public:
 	template < class RealReturnType, class RealParametersTypeBase >
 	class RegistratorWrapper : public RegistratorWrapperBase {
-		typedef typename match_cv_ref < ParametersType, RealParametersTypeBase >::type RealParametersType;
+		typedef typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type RealParametersType;
 
 		std::function < RealReturnType ( RealParametersType &&, RealParametersType && ) > callback;
 
 	public:
 		ReturnType eval ( bool firstAttempt, ParametersType && first, ParametersType && second ) {
 			if ( std::type_index ( typeid ( first ) ) == std::type_index ( typeid ( second ) ) )
-				return ReturnType ( callback ( forward < RealParametersType > ( static_cast < RealParametersType && > ( first ) ), forward < RealParametersType > ( static_cast < RealParametersType && > ( second ) ) ) );
+				return ReturnType ( callback ( std::forward < RealParametersType > ( static_cast < RealParametersType && > ( first ) ), std::forward < RealParametersType > ( static_cast < RealParametersType && > ( second ) ) ) );
 
 			if ( firstAttempt ) {
-				alib::Object casted = alib::castApi::getCastPool ( std::type_index ( typeid ( first ) ) ).cast ( forward < ParametersType > ( second ) );
-				return ReturnType ( callback ( forward < RealParametersType > ( static_cast < RealParametersType && > ( first ) ), forward < RealParametersType > ( static_cast < RealParametersType && > ( casted.getData ( ) ) ) ) );
+				alib::Object casted = alib::castApi::getCastPool ( std::type_index ( typeid ( first ) ) ).cast ( std::forward < ParametersType > ( second ) );
+				return ReturnType ( callback ( std::forward < RealParametersType > ( static_cast < RealParametersType && > ( first ) ), std::forward < RealParametersType > ( static_cast < RealParametersType && > ( casted.getData ( ) ) ) ) );
 			} else {
-				alib::Object casted = alib::castApi::getCastPool ( std::type_index ( typeid ( second ) ) ).cast ( forward < ParametersType > ( first ) );
-				return ReturnType ( callback ( forward < RealParametersType > ( static_cast < RealParametersType && > ( casted.getData ( ) ) ), forward < RealParametersType > ( static_cast < RealParametersType && > ( second ) ) ) );
+				alib::Object casted = alib::castApi::getCastPool ( std::type_index ( typeid ( second ) ) ).cast ( std::forward < ParametersType > ( first ) );
+				return ReturnType ( callback ( std::forward < RealParametersType > ( static_cast < RealParametersType && > ( casted.getData ( ) ) ), std::forward < RealParametersType > ( static_cast < RealParametersType && > ( second ) ) ) );
 			}
 		}
 
@@ -160,12 +160,12 @@ public:
 		typename std::map < std::type_index, RegistratorWrapperBase * >::iterator callback = getInstance ( ).registeredFunctions.find ( std::type_index ( typeid ( first ) ) );
 
 		if ( ( callback != getInstance ( ).registeredFunctions.end ( ) ) && callback->second->available ( true, std::type_index ( typeid ( first ) ), std::type_index ( typeid ( second ) ) ) )
-			return callback->second->eval ( true, forward < ParametersType > ( first ), forward < ParametersType > ( second ) );
+			return callback->second->eval ( true, std::forward < ParametersType > ( first ), std::forward < ParametersType > ( second ) );
 
 		callback = getInstance ( ).registeredFunctions.find ( std::type_index ( typeid ( second ) ) );
 
 		if ( ( callback != getInstance ( ).registeredFunctions.end ( ) ) && callback->second->available ( false, std::type_index ( typeid ( first ) ), std::type_index ( typeid ( second ) ) ) )
-			return callback->second->eval ( false, forward < ParametersType > ( first ), forward < ParametersType > ( second ) );
+			return callback->second->eval ( false, std::forward < ParametersType > ( first ), std::forward < ParametersType > ( second ) );
 
 		std::string firstType = std::cstringToString ( std::type_name ( typeid ( first ) ) );