diff --git a/alib2common/src/core/components.hpp b/alib2common/src/core/components.hpp
index 64f38a79703636eb32106db91054350ee3a5b89c..b3f420a5cffb3291b62553e6b35030845ff55a70 100644
--- a/alib2common/src/core/components.hpp
+++ b/alib2common/src/core/components.hpp
@@ -15,7 +15,7 @@
 #include <typeinfo>
 #include "../exception/CommonException.h"
 
-namespace std {
+namespace alib {
 
 template < class Derived, class DataType, class SetType >
 class ComponentConstraint {
@@ -304,13 +304,13 @@ struct ComponentAux;
  * Specialisation for tuple.
  */
 template < class Derived, class DataType, class ... SetTypes >
-struct ComponentAux < Derived, DataType, tuple < SetTypes ... > > : public Component < Derived, DataType, SetTypes > ... {
+struct ComponentAux < Derived, DataType, std::tuple < SetTypes ... > > : public Component < Derived, DataType, SetTypes > ... {
 
 	/**
 	 * Constructor
 	 */
 	template < class ... RealSetTypes, size_t ... Indexes >
-	ComponentAux ( tuple < RealSetTypes ... > params, std::index_sequence < Indexes ... > ) : Component < Derived, DataType, SetTypes > ( std::move ( get < Indexes > ( params ) ) ) ... {
+	ComponentAux ( std::tuple < RealSetTypes ... > params, std::index_sequence < Indexes ... > ) : Component < Derived, DataType, SetTypes > ( std::move ( std::get < Indexes > ( params ) ) ) ... {
 		( void ) params; // No-op
 	}
 
@@ -354,13 +354,13 @@ struct ElementAux;
  * Specialisation for tuple.
  */
 template < class Derived, class DataType, class ... ElementTypes >
-struct ElementAux < Derived, DataType, tuple < ElementTypes ... > > : public Element < Derived, DataType, ElementTypes > ... {
+struct ElementAux < Derived, DataType, std::tuple < ElementTypes ... > > : public Element < Derived, DataType, ElementTypes > ... {
 
 	/**
 	 * Constructor
 	 */
 	template < class ... RealElementTypes, size_t ... Indexes >
-	ElementAux ( tuple < RealElementTypes ... > params, std::index_sequence < Indexes ... > ) : Element < Derived, DataType, ElementTypes > ( std::move ( get < Indexes > ( params ) ) ) ... {
+	ElementAux ( std::tuple < RealElementTypes ... > params, std::index_sequence < Indexes ... > ) : Element < Derived, DataType, ElementTypes > ( std::move ( std::get < Indexes > ( params ) ) ) ... {
 		( void ) params; // No-op
 	}
 
@@ -495,6 +495,6 @@ public:
 	using Components < Derived, NextGroup ... >::accessElement;
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* COMPONENTS2_HPP_ */
diff --git a/alib2common/test-src/core/ComponentsTest.cpp b/alib2common/test-src/core/ComponentsTest.cpp
index 5c496a7e02b051f7e08a1fc1524837d23708e7da..7bc4b4fa8f48053fd9c29b82fbc2da1ad54fc71b 100644
--- a/alib2common/test-src/core/ComponentsTest.cpp
+++ b/alib2common/test-src/core/ComponentsTest.cpp
@@ -13,13 +13,13 @@ struct NonlinearAlphabet {
 struct SubtreeWildcard {
 };
 
-class A : public std::Components < A, std::string, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
+class A : public alib::Components < A, std::string, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
 public:
-	A ( std::string string ) : std::Components < A, std::string, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::set < std::string > { string, "aaa" }, std::set < std::string > { "aaa" } ), std::make_tuple ( string ) ) {
+	A ( std::string string ) : alib::Components < A, std::string, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::set < std::string > { string, "aaa" }, std::set < std::string > { "aaa" } ), std::make_tuple ( string ) ) {
 	}
 };
 
-namespace std {
+namespace alib {
 
 template < >
 class ComponentConstraint< A, std::string, GeneralAlphabet > {
@@ -66,12 +66,12 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
-class B : public std::Components < B, std::string, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < > > {
+class B : public alib::Components < B, std::string, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < > > {
 };
 
-namespace std {
+namespace alib {
 
 template < >
 class ComponentConstraint< B, std::string, GeneralAlphabet > {
@@ -103,7 +103,7 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 void ComponentsTest::setUp ( ) {
 }
diff --git a/alib2data/src/automaton/FSM/CompactNFA.h b/alib2data/src/automaton/FSM/CompactNFA.h
index 9c3173f1bed96e1195f894168bf7eaf3617a21fb..f72042cba5dc019dfd0273547b471d4e4292c591 100644
--- a/alib2data/src/automaton/FSM/CompactNFA.h
+++ b/alib2data/src/automaton/FSM/CompactNFA.h
@@ -40,7 +40,7 @@ class FinalStates;
 class InitialState;
 
 template < class SymbolType, class StateType >
-class CompactNFA final : public AutomatonBase, public std::Components < CompactNFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class CompactNFA final : public AutomatonBase, public alib::Components < CompactNFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, std::vector < SymbolType > >, std::set < StateType > > transitions;
 
@@ -218,7 +218,7 @@ public:
 namespace automaton {
 
 template < class SymbolType, class StateType >
-CompactNFA < SymbolType, StateType >::CompactNFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : std::Components < CompactNFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+CompactNFA < SymbolType, StateType >::CompactNFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : alib::Components < CompactNFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class SymbolType, class StateType >
@@ -452,7 +452,7 @@ alib::ObjectBase* CompactNFA < SymbolType, StateType >::inc() && {
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class StateType >
 class ComponentConstraint< automaton::CompactNFA < SymbolType, StateType >, SymbolType, automaton::InputAlphabet > {
@@ -526,6 +526,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* COMPACT_DFA_H_ */
diff --git a/alib2data/src/automaton/FSM/DFA.h b/alib2data/src/automaton/FSM/DFA.h
index fd51ce2a8cf3937ce18ec21dc929cffb74d36d74..e4f47b0908e54ee9f99a3d6cee2324a1a88785a2 100644
--- a/alib2data/src/automaton/FSM/DFA.h
+++ b/alib2data/src/automaton/FSM/DFA.h
@@ -37,7 +37,7 @@ class FinalStates;
 class InitialState;
 
 template<class SymbolType, class StateType >
-class DFA final : public AutomatonBase, public std::Components < DFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class DFA final : public AutomatonBase, public alib::Components < DFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, SymbolType >, StateType > transitions;
 
@@ -201,7 +201,7 @@ public:
 };
 
 template<class SymbolType, class StateType >
-DFA<SymbolType, StateType>::DFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : std::Components < DFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+DFA<SymbolType, StateType>::DFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : alib::Components < DFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template<class SymbolType, class StateType >
@@ -413,7 +413,7 @@ alib::ObjectBase* DFA < SymbolType, StateType >::inc() && {
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template<class SymbolType, class StateType >
 class ComponentConstraint< automaton::DFA<SymbolType, StateType>, SymbolType, automaton::InputAlphabet > {
@@ -489,6 +489,6 @@ public:
 
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* DFA_H_ */
diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.h b/alib2data/src/automaton/FSM/EpsilonNFA.h
index afb69a51b2161b404b39458976f1b8e5c7172cf7..0a22a4fc0c478b79688d56820eece5999aadabbd 100644
--- a/alib2data/src/automaton/FSM/EpsilonNFA.h
+++ b/alib2data/src/automaton/FSM/EpsilonNFA.h
@@ -40,7 +40,7 @@ class FinalStates;
 class InitialState;
 
 template<class SymbolType, class EpsilonType, class StateType >
-class EpsilonNFA final : public AutomatonBase, public std::Components < EpsilonNFA < SymbolType, EpsilonType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class EpsilonNFA final : public AutomatonBase, public alib::Components < EpsilonNFA < SymbolType, EpsilonType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, std::variant < EpsilonType, SymbolType > >, std::set < StateType > > transitions;
 
@@ -310,7 +310,7 @@ public:
 namespace automaton {
 
 template<class SymbolType, class EpsilonType, class StateType >
-EpsilonNFA < SymbolType, EpsilonType, StateType >::EpsilonNFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : std::Components < EpsilonNFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+EpsilonNFA < SymbolType, EpsilonType, StateType >::EpsilonNFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : alib::Components < EpsilonNFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template<class SymbolType, class EpsilonType, class StateType >
@@ -666,7 +666,7 @@ alib::ObjectBase* EpsilonNFA < SymbolType, EpsilonType, StateType >::inc() && {
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template<class SymbolType, class EpsilonType, class StateType >
 class ComponentConstraint< automaton::EpsilonNFA < SymbolType, EpsilonType, StateType >, SymbolType, automaton::InputAlphabet > {
@@ -738,6 +738,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* EPSILON_NFA_H_ */
diff --git a/alib2data/src/automaton/FSM/ExtendedNFA.h b/alib2data/src/automaton/FSM/ExtendedNFA.h
index 3e05615eced580f269a467308bd216946bb51c47..ab45f5564d20ae6f38a42e47a8be28fe0f127aaa 100644
--- a/alib2data/src/automaton/FSM/ExtendedNFA.h
+++ b/alib2data/src/automaton/FSM/ExtendedNFA.h
@@ -43,7 +43,7 @@ class FinalStates;
 class InitialState;
 
 template<class SymbolType, class StateType >
-class ExtendedNFA final : public AutomatonBase, public std::Components < ExtendedNFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class ExtendedNFA final : public AutomatonBase, public alib::Components < ExtendedNFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, regexp::UnboundedRegExpStructure < SymbolType > >, std::set < StateType > > transitions;
 
@@ -223,7 +223,7 @@ public:
 namespace automaton {
 
 template<class SymbolType, class StateType >
-ExtendedNFA < SymbolType, StateType >::ExtendedNFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : std::Components < ExtendedNFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+ExtendedNFA < SymbolType, StateType >::ExtendedNFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : alib::Components < ExtendedNFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template<class SymbolType, class StateType >
@@ -470,7 +470,7 @@ alib::ObjectBase* ExtendedNFA < SymbolType, StateType >::inc() && {
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template<class SymbolType, class StateType >
 class ComponentConstraint< automaton::ExtendedNFA < SymbolType, StateType >, SymbolType, automaton::InputAlphabet > {
@@ -544,6 +544,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* EXTENDED_NFA_H_ */
diff --git a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
index 8f246ef0bfca0dd4e662a476c0b12868e121fb4f..ce09b0a8122d381bbc22c8ef5aa59e353d372963 100644
--- a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
+++ b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
@@ -36,7 +36,7 @@ class FinalStates;
 class InitialStates;
 
 template < class SymbolType, class StateType >
-class MultiInitialStateNFA final : public AutomatonBase, public std::Components < MultiInitialStateNFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
+class MultiInitialStateNFA final : public AutomatonBase, public alib::Components < MultiInitialStateNFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
 protected:
 	std::map < std::pair < StateType, SymbolType >, std::set < StateType > > transitions;
 
@@ -234,7 +234,7 @@ public:
 namespace automaton {
 
 template < class SymbolType, class StateType >
-MultiInitialStateNFA < SymbolType, StateType >::MultiInitialStateNFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, std::set < StateType > initialStates, std::set < StateType > finalStates ) : std::Components < MultiInitialStateNFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+MultiInitialStateNFA < SymbolType, StateType >::MultiInitialStateNFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, std::set < StateType > initialStates, std::set < StateType > finalStates ) : alib::Components < MultiInitialStateNFA, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
 template < class SymbolType, class StateType >
@@ -458,7 +458,7 @@ alib::ObjectBase* MultiInitialStateNFA < SymbolType, StateType >::inc() && {
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class StateType >
 class ComponentConstraint< automaton::MultiInitialStateNFA < SymbolType, StateType >, SymbolType, automaton::InputAlphabet > {
@@ -534,6 +534,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* MULTI_INITIAL_STATE_NFA_H_ */
diff --git a/alib2data/src/automaton/FSM/NFA.h b/alib2data/src/automaton/FSM/NFA.h
index b203a31815555a80a779aca17ec7201c1e227fff..8c18eb9049cc0e160c7f93772a28454e0fbb554f 100644
--- a/alib2data/src/automaton/FSM/NFA.h
+++ b/alib2data/src/automaton/FSM/NFA.h
@@ -34,7 +34,7 @@ class FinalStates;
 class InitialState;
 
 template<class SymbolType, class StateType >
-class NFA final : public AutomatonBase, public std::Components < NFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class NFA final : public AutomatonBase, public alib::Components < NFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, SymbolType >, std::set < StateType > > transitions;
 
@@ -225,7 +225,7 @@ public:
 namespace automaton {
 
 template<class SymbolType, class StateType >
-NFA < SymbolType, StateType >::NFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : std::Components < NFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+NFA < SymbolType, StateType >::NFA ( std::set < StateType > states, std::set < SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : alib::Components < NFA < SymbolType, StateType >, SymbolType, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template<class SymbolType, class StateType >
@@ -442,7 +442,7 @@ alib::ObjectBase* NFA < SymbolType, StateType >::inc() && {
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template<class SymbolType, class StateType >
 class ComponentConstraint< automaton::NFA < SymbolType, StateType >, SymbolType, automaton::InputAlphabet > {
@@ -514,6 +514,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* NFA_H_ */
diff --git a/alib2data/src/automaton/PDA/DPDA.h b/alib2data/src/automaton/PDA/DPDA.h
index 661450059ce75298647fb7ade05ee43d16aeb558..181de622dd5cbdd97f2576a685ef13ee37741dae 100644
--- a/alib2data/src/automaton/PDA/DPDA.h
+++ b/alib2data/src/automaton/PDA/DPDA.h
@@ -44,7 +44,7 @@ class InitialState;
  * if $\delta(q, a, \alpha) \neq \emptyset$, $\delta (q, \varepsilon, \beta) \neq \emptyset$, then $\alpha$ is not suffix of $\beta$ and $\beta$ is not suffix of $\alpha$ (fornally $\gamma \alpha \neq \beta and \alpha \neq \gamma \beta$).
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-class DPDA final : public AutomatonBase, public std::Components < DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet>, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class DPDA final : public AutomatonBase, public alib::Components < DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet>, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > transitions;
 
@@ -239,7 +239,7 @@ public:
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::DPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : std::Components < DPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::DPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : alib::Components < DPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -521,7 +521,7 @@ alib::ObjectBase* DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType,
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
@@ -629,6 +629,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* DPDA_H_ */
diff --git a/alib2data/src/automaton/PDA/InputDrivenDPDA.h b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
index 388180cd9f694f35f55a8f4ce3ea34c908ef5995..ddf0984502cfc9f10b21244d5ef1fa4fdfca1b49 100644
--- a/alib2data/src/automaton/PDA/InputDrivenDPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
@@ -40,7 +40,7 @@ class InitialState;
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-class InputDrivenDPDA final : public AutomatonBase, public std::Components < InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class InputDrivenDPDA final : public AutomatonBase, public alib::Components < InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, InputSymbolType >, StateType > transitions;
 	std::map < InputSymbolType, std::pair < std::vector < PushdownStoreSymbolType >, std::vector < PushdownStoreSymbolType > > > inputSymbolToPushdownStoreOperation;
@@ -249,7 +249,7 @@ public:
 };
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::InputDrivenDPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : std::Components < InputDrivenDPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::InputDrivenDPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : alib::Components < InputDrivenDPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
@@ -502,7 +502,7 @@ alib::ObjectBase* InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, St
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
@@ -610,6 +610,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* INPUT_DRIVEN_DPDA_H_ */
diff --git a/alib2data/src/automaton/PDA/InputDrivenNPDA.h b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
index ba34eef3d3c45243656358fcdb0eb9c30062f916..c8b2312451b45dc0ea02aad292389af8edabeaa0 100644
--- a/alib2data/src/automaton/PDA/InputDrivenNPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
@@ -40,7 +40,7 @@ class InitialState;
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-class InputDrivenNPDA final : public AutomatonBase, public std::Components < InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class InputDrivenNPDA final : public AutomatonBase, public alib::Components < InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, InputSymbolType >, std::set < StateType > > transitions;
 	std::map < InputSymbolType, std::pair < std::vector < PushdownStoreSymbolType >, std::vector < PushdownStoreSymbolType > > > inputSymbolToPushdownStoreOperation;
@@ -258,7 +258,7 @@ public:
 };
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::InputDrivenNPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : std::Components < InputDrivenNPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::InputDrivenNPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : alib::Components < InputDrivenNPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
@@ -527,7 +527,7 @@ alib::ObjectBase* InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, St
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
@@ -635,6 +635,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* INPUT_DRIVEN_NPDA_H_ */
diff --git a/alib2data/src/automaton/PDA/NPDA.h b/alib2data/src/automaton/PDA/NPDA.h
index d78123a88057372259506d18207a22c39cf2a6de..11432ab7e3734f084f3de7fbe9eed0482fca99e1 100644
--- a/alib2data/src/automaton/PDA/NPDA.h
+++ b/alib2data/src/automaton/PDA/NPDA.h
@@ -40,7 +40,7 @@ class InitialState;
  * Push Down Automaton
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-class NPDA final : public AutomatonBase, public std::Components < NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class NPDA final : public AutomatonBase, public alib::Components < NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > transitions;
 
@@ -238,7 +238,7 @@ public:
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::NPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : std::Components < NPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::NPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : alib::Components < NPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -462,7 +462,7 @@ alib::ObjectBase* NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType,
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
@@ -577,6 +577,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* NPDA_H_ */
diff --git a/alib2data/src/automaton/PDA/NPDTA.h b/alib2data/src/automaton/PDA/NPDTA.h
index acdfe4526ad2aae68cb9a0956373551127774c93..9d8e433759046feba87ef0728f242fb3e10a719b 100644
--- a/alib2data/src/automaton/PDA/NPDTA.h
+++ b/alib2data/src/automaton/PDA/NPDTA.h
@@ -41,7 +41,7 @@ class InitialState;
  * Push Down Translation Automaton
  */
 template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-class NPDTA final : public AutomatonBase, public std::Components < NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, OutputSymbolType, std::tuple < OutputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class NPDTA final : public AutomatonBase, public alib::Components < NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, OutputSymbolType, std::tuple < OutputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >, std::set < std::tuple < StateType, std::vector < PushdownStoreSymbolType >, std::vector < OutputSymbolType > > > > transitions;
 
@@ -263,7 +263,7 @@ public:
 };
 
 template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::NPDTA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < OutputSymbolType > outputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : std::Components < NPDTA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, OutputSymbolType, std::tuple < OutputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( outputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::NPDTA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < OutputSymbolType > outputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : alib::Components < NPDTA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, OutputSymbolType, std::tuple < OutputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( outputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -528,7 +528,7 @@ alib::ObjectBase* NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, Pushdo
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
@@ -664,6 +664,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* NPDTA_H_ */
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
index ab201c873a8d8e59ec7e8df8d98a9b79a7ea53ae..42648253d92dc97c8d5128bc831ecea495a37016 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
@@ -40,7 +40,7 @@ class InitialState;
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-class RealTimeHeightDeterministicDPDA final : public AutomatonBase, public std::Components < RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class RealTimeHeightDeterministicDPDA final : public AutomatonBase, public alib::Components < RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::pair < StateType, PushdownStoreSymbolType > > callTransitions;
 	std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, StateType > returnTransitions;
@@ -282,7 +282,7 @@ public:
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::RealTimeHeightDeterministicDPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates ) : std::Components < RealTimeHeightDeterministicDPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::RealTimeHeightDeterministicDPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates ) : alib::Components < RealTimeHeightDeterministicDPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -730,7 +730,7 @@ alib::ObjectBase* RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
@@ -855,6 +855,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* REAL_TIME_HEIGHT_DETERMINISTIC_DPDA_H_ */
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
index 08b8ed642adedd1613b4296ffc73cb0eb6639840..8e455e5c3c95c476ba3ddcb4acd93e1ab6769578 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
@@ -40,7 +40,7 @@ class InitialStates;
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-class RealTimeHeightDeterministicNPDA final : public AutomatonBase, public std::Components < RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
+class RealTimeHeightDeterministicNPDA final : public AutomatonBase, public alib::Components < RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
 protected:
 	std::map < std::pair < StateType, std::variant < EpsilonType, InputSymbolType > >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > callTransitions;
 	std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < StateType > > returnTransitions;
@@ -324,7 +324,7 @@ public:
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::RealTimeHeightDeterministicNPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, std::set < StateType > initialStates, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates ) : std::Components < RealTimeHeightDeterministicNPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > { } ) {
+RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::RealTimeHeightDeterministicNPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, std::set < StateType > initialStates, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates ) : alib::Components < RealTimeHeightDeterministicNPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > { } ) {
 }
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -754,7 +754,7 @@ alib::ObjectBase* RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
@@ -899,6 +899,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* REAL_TIME_HEIGHT_DETERMINISTIC_NPDA_H_ */
diff --git a/alib2data/src/automaton/PDA/SinglePopDPDA.h b/alib2data/src/automaton/PDA/SinglePopDPDA.h
index b7d6221712a42525995669b78ee916b7b2022b70..7202dcdd2df06a344e8a9ad4e3ce36cdde336f51 100644
--- a/alib2data/src/automaton/PDA/SinglePopDPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopDPDA.h
@@ -45,7 +45,7 @@ class InitialState;
  * if $\delta(q, a, r) \neq \emptyset$, $\delta (q, \varepsilon, s) \neq \emptyset$, then $r \neq s$.
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-class SinglePopDPDA final : public AutomatonBase, public std::Components < SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class SinglePopDPDA final : public AutomatonBase, public alib::Components < SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::pair < StateType, std::vector < PushdownStoreSymbolType > > > transitions;
 
@@ -230,7 +230,7 @@ public:
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::SinglePopDPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : std::Components < SinglePopDPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::SinglePopDPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : alib::Components < SinglePopDPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -452,7 +452,7 @@ alib::ObjectBase* SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSym
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
@@ -557,6 +557,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* SINGLE_POP_DPDA_H_ */
diff --git a/alib2data/src/automaton/PDA/SinglePopNPDA.h b/alib2data/src/automaton/PDA/SinglePopNPDA.h
index 3666d85c4d6c35fda81bac49ee8e0706677fa893..5d9a08a0233394b5b6f9e756b96ec9211858305e 100644
--- a/alib2data/src/automaton/PDA/SinglePopNPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopNPDA.h
@@ -40,7 +40,7 @@ class InitialState;
  * Push Down Automaton
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-class SinglePopNPDA final : public AutomatonBase, public std::Components < SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class SinglePopNPDA final : public AutomatonBase, public alib::Components < SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, PushdownStoreSymbolType >, std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > > > transitions;
 
@@ -238,7 +238,7 @@ public:
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::SinglePopNPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : std::Components < SinglePopNPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >::SinglePopNPDA ( std::set < StateType > states, std::set < InputSymbolType > inputAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType initialSymbol, std::set < StateType > finalStates ) : alib::Components < SinglePopNPDA, InputSymbolType, std::tuple < InputAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < InitialSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -465,7 +465,7 @@ alib::ObjectBase* SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSym
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::InputAlphabet > {
@@ -580,6 +580,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* SINGLE_POP_NPDA_H_ */
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
index c1195634ee13cc289a999211c1a4dbc22fee0f11..0ce6b128d325baaaaf5df370779875aee4f0419b 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
@@ -41,7 +41,7 @@ class InitialState;
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-class VisiblyPushdownDPDA final : public AutomatonBase, public std::Components < VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, PushdownStoreSymbolType, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class VisiblyPushdownDPDA final : public AutomatonBase, public alib::Components < VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, PushdownStoreSymbolType, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, InputSymbolType >, std::pair < StateType, PushdownStoreSymbolType > > callTransitions;
 	std::map < std::tuple < StateType, InputSymbolType, PushdownStoreSymbolType >, StateType > returnTransitions;
@@ -318,7 +318,7 @@ public:
 };
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::VisiblyPushdownDPDA ( std::set < StateType > states, std::set < InputSymbolType > callAlphabet, std::set < InputSymbolType > returnAlphabet, std::set < InputSymbolType > localAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates ) : std::Components < VisiblyPushdownDPDA, InputSymbolType, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::VisiblyPushdownDPDA ( std::set < StateType > states, std::set < InputSymbolType > callAlphabet, std::set < InputSymbolType > returnAlphabet, std::set < InputSymbolType > localAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, StateType initialState, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates ) : alib::Components < VisiblyPushdownDPDA, InputSymbolType, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
@@ -657,7 +657,7 @@ alib::ObjectBase* VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::CallAlphabet > {
@@ -824,6 +824,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* VISIBLY_PUSHDOWN_DPDA_H_ */
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
index 9fd4d5de1f7dfa6a149395b09a7f396fd1ddb335..32c32ffe9d4c5cde8d7ef56f05f43cdd927bdef7 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
@@ -41,7 +41,7 @@ class InitialStates;
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-class VisiblyPushdownNPDA final : public AutomatonBase, public std::Components < VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
+class VisiblyPushdownNPDA final : public AutomatonBase, public alib::Components < VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
 protected:
 	std::map < std::pair < StateType, InputSymbolType >, std::set < std::pair < StateType, PushdownStoreSymbolType > > > callTransitions;
 	std::map < std::tuple < StateType, InputSymbolType, PushdownStoreSymbolType >, std::set < StateType > > returnTransitions;
@@ -354,7 +354,7 @@ public:
 };
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::VisiblyPushdownNPDA ( std::set < StateType > states, std::set < InputSymbolType > callAlphabet, std::set < InputSymbolType > returnAlphabet, std::set < InputSymbolType > localAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, std::set < StateType > initialStates, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates ) : std::Components < VisiblyPushdownNPDA, InputSymbolType, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >::VisiblyPushdownNPDA ( std::set < StateType > states, std::set < InputSymbolType > callAlphabet, std::set < InputSymbolType > returnAlphabet, std::set < InputSymbolType > localAlphabet, std::set < PushdownStoreSymbolType > pushdownStoreAlphabet, std::set < StateType > initialStates, PushdownStoreSymbolType bottomOfTheStackSymbol, std::set < StateType > finalStates ) : alib::Components < VisiblyPushdownNPDA, InputSymbolType, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet >, std::tuple < >, PushdownStoreSymbolType, std::tuple < PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, StateType, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
@@ -684,7 +684,7 @@ alib::ObjectBase* VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
 class ComponentConstraint< automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, InputSymbolType, automaton::CallAlphabet > {
@@ -871,6 +871,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* VISIBLY_PUSHDOWN_NPDA_H_ */
diff --git a/alib2data/src/automaton/TA/DFTA.h b/alib2data/src/automaton/TA/DFTA.h
index ab7449a9497d1dd851d72c844cd7bd8c5c94f4bb..cea1792f3d657a6227db5d985f071420b7c34e99 100644
--- a/alib2data/src/automaton/TA/DFTA.h
+++ b/alib2data/src/automaton/TA/DFTA.h
@@ -37,7 +37,7 @@ class FinalStates;
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
 template<class SymbolType, class RankType, class StateType >
-class DFTA final : public AutomatonBase, public std::Components < DFTA < SymbolType, RankType, StateType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < > > {
+class DFTA final : public AutomatonBase, public alib::Components < DFTA < SymbolType, RankType, StateType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < > > {
 	std::map < std::pair < std::ranked_symbol < SymbolType, RankType >, std::vector < StateType > >, StateType > transitions;
 
 public:
@@ -179,7 +179,7 @@ public:
 namespace automaton {
 
 template<class SymbolType, class RankType, class StateType >
-DFTA < SymbolType, RankType, StateType >::DFTA ( std::set < StateType > states, std::set < std::ranked_symbol < SymbolType, RankType > > inputAlphabet, std::set < StateType > finalStates ) : std::Components < DFTA, std::ranked_symbol < SymbolType, RankType >, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+DFTA < SymbolType, RankType, StateType >::DFTA ( std::set < StateType > states, std::set < std::ranked_symbol < SymbolType, RankType > > inputAlphabet, std::set < StateType > finalStates ) : alib::Components < DFTA, std::ranked_symbol < SymbolType, RankType >, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
 template<class SymbolType, class RankType, class StateType >
@@ -329,7 +329,7 @@ alib::ObjectBase* DFTA < SymbolType, RankType, StateType >::inc() && {
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template<class SymbolType, class RankType, class StateType >
 class ComponentConstraint< automaton::DFTA < SymbolType, RankType, StateType >, std::ranked_symbol < SymbolType, RankType >, automaton::InputAlphabet > {
@@ -387,6 +387,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* DFTA_H_ */
diff --git a/alib2data/src/automaton/TA/NFTA.h b/alib2data/src/automaton/TA/NFTA.h
index 1c174321f173b8258d326f76bfff60f3ef69a459..ae9feb96c9a7264c99bd051dbc3eac0cff68e4cd 100644
--- a/alib2data/src/automaton/TA/NFTA.h
+++ b/alib2data/src/automaton/TA/NFTA.h
@@ -36,7 +36,7 @@ class FinalStates;
  * Can store nondeterministic finite tree automaton without epsilon transitions.
  */
 template < class SymbolType, class RankType, class StateType >
-class NFTA final : public AutomatonBase, public std::Components < NFTA < SymbolType, RankType, StateType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < > > {
+class NFTA final : public AutomatonBase, public alib::Components < NFTA < SymbolType, RankType, StateType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < > > {
 	std::map < std::pair < std::ranked_symbol < SymbolType, RankType >, std::vector < StateType > >, std::set < StateType > > transitions;
 
 public:
@@ -199,7 +199,7 @@ public:
 namespace automaton {
 
 template < class SymbolType, class RankType, class StateType >
-NFTA < SymbolType, RankType, StateType >::NFTA ( std::set < StateType > states, std::set < std::ranked_symbol < SymbolType, RankType > > inputAlphabet, std::set < StateType > finalStates ) : std::Components < NFTA, std::ranked_symbol < SymbolType, RankType >, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+NFTA < SymbolType, RankType, StateType >::NFTA ( std::set < StateType > states, std::set < std::ranked_symbol < SymbolType, RankType > > inputAlphabet, std::set < StateType > finalStates ) : alib::Components < NFTA, std::ranked_symbol < SymbolType, RankType >, std::tuple < InputAlphabet >, std::tuple < >, StateType, std::tuple < States, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
 template < class SymbolType, class RankType, class StateType >
@@ -381,7 +381,7 @@ alib::ObjectBase* NFTA < SymbolType, RankType, StateType >::inc() && {
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType, class StateType >
 class ComponentConstraint< automaton::NFTA < SymbolType, RankType, StateType >, std::ranked_symbol < SymbolType, RankType >, automaton::InputAlphabet > {
@@ -439,6 +439,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* NFTA_H_ */
diff --git a/alib2data/src/automaton/TM/OneTapeDTM.h b/alib2data/src/automaton/TM/OneTapeDTM.h
index 0661b2f9dd8e4486b243558e96b74f8089553be5..edd3dd16d50500b0a68bb3253baa750c9af96c02 100644
--- a/alib2data/src/automaton/TM/OneTapeDTM.h
+++ b/alib2data/src/automaton/TM/OneTapeDTM.h
@@ -40,7 +40,7 @@ class InitialState;
  * One tape turing machine
  */
 template<class SymbolType, class StateType >
-class OneTapeDTM final : public AutomatonBase, public std::Components < OneTapeDTM < SymbolType, StateType >, SymbolType, std::tuple < TapeAlphabet, InputAlphabet >, std::tuple < BlankSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class OneTapeDTM final : public AutomatonBase, public alib::Components < OneTapeDTM < SymbolType, StateType >, SymbolType, std::tuple < TapeAlphabet, InputAlphabet >, std::tuple < BlankSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < StateType, SymbolType >, std::tuple < StateType, SymbolType, Shift > > transitions;
 
@@ -216,7 +216,7 @@ public:
 };
 
 template<class SymbolType, class StateType >
-OneTapeDTM<SymbolType, StateType>::OneTapeDTM ( std::set < StateType > states, std::set < SymbolType > tapeAlphabet, SymbolType blankSymbol, std::set< SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : std::Components < OneTapeDTM, SymbolType, std::tuple < TapeAlphabet, InputAlphabet >, std::tuple < BlankSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( tapeAlphabet), std::move ( inputAlphabet ) ), std::make_tuple ( blankSymbol ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+OneTapeDTM<SymbolType, StateType>::OneTapeDTM ( std::set < StateType > states, std::set < SymbolType > tapeAlphabet, SymbolType blankSymbol, std::set< SymbolType > inputAlphabet, StateType initialState, std::set < StateType > finalStates ) : alib::Components < OneTapeDTM, SymbolType, std::tuple < TapeAlphabet, InputAlphabet >, std::tuple < BlankSymbol >, StateType, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( tapeAlphabet), std::move ( inputAlphabet ) ), std::make_tuple ( blankSymbol ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 
 }
 
@@ -393,7 +393,7 @@ alib::ObjectBase* OneTapeDTM < SymbolType, StateType >::inc() && {
 
 } /* namespace automaton */
 
-namespace std {
+namespace alib {
 
 template<class SymbolType, class StateType >
 class ComponentConstraint< automaton::OneTapeDTM<SymbolType, StateType>, SymbolType, automaton::TapeAlphabet > {
@@ -503,6 +503,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* ONE_TAPE_DTM_H_ */
diff --git a/alib2data/src/grammar/ContextFree/CFG.h b/alib2data/src/grammar/ContextFree/CFG.h
index ae72cab7c482d68f22a58c15663bbe33ad58c9a9..bdff28a537d56a58cdbae6f728aa799578bc772a 100644
--- a/alib2data/src/grammar/ContextFree/CFG.h
+++ b/alib2data/src/grammar/ContextFree/CFG.h
@@ -35,7 +35,7 @@ class NonterminalAlphabet;
 class InitialSymbol;
 
 template < class SymbolType >
-class CFG final : public GrammarBase, public std::Components < CFG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class CFG final : public GrammarBase, public alib::Components < CFG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	std::map < SymbolType, std::set < std::vector < SymbolType > > > rules;
 
 public:
@@ -159,7 +159,7 @@ CFG < SymbolType >::CFG ( SymbolType initialSymbol ) : CFG ( std::set < SymbolTy
 }
 
 template < class SymbolType >
-CFG < SymbolType >::CFG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < CFG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
+CFG < SymbolType >::CFG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < CFG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
 }
 
 template < class SymbolType >
@@ -322,7 +322,7 @@ alib::ObjectBase* CFG < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< grammar::CFG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
@@ -387,6 +387,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* CFG_H_ */
diff --git a/alib2data/src/grammar/ContextFree/CNF.h b/alib2data/src/grammar/ContextFree/CNF.h
index 007f33f3ffe4635686af31f23ab04b6573dd3f0b..551e74384fe8e1464b6bf3044e49773eaa2047ce 100644
--- a/alib2data/src/grammar/ContextFree/CNF.h
+++ b/alib2data/src/grammar/ContextFree/CNF.h
@@ -36,7 +36,7 @@ class NonterminalAlphabet;
 class InitialSymbol;
 
 template < class SymbolType >
-class CNF final : public GrammarBase, public std::Components < CNF < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class CNF final : public GrammarBase, public alib::Components < CNF < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	std::map < SymbolType, std::set < std::variant < SymbolType, std::pair < SymbolType, SymbolType > > > > rules;
 	bool generatesEpsilon;
 
@@ -162,7 +162,7 @@ CNF < SymbolType >::CNF ( SymbolType initialSymbol ) : CNF ( std::set < SymbolTy
 }
 
 template < class SymbolType >
-CNF < SymbolType >::CNF ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < CNF, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
+CNF < SymbolType >::CNF ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < CNF, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
 }
 
 template < class SymbolType >
@@ -418,7 +418,7 @@ alib::ObjectBase* CNF < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< grammar::CNF < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
@@ -483,6 +483,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* CNF_H_ */
diff --git a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
index 33f0e6545d13f3051ba1625b29c7b72191ecf3a9..cb92e3d17b98118a11730ca11e3f69829b365dca 100644
--- a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
+++ b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
@@ -35,7 +35,7 @@ class NonterminalAlphabet;
 class InitialSymbol;
 
 template < class SymbolType >
-class EpsilonFreeCFG final : public GrammarBase, public std::Components < EpsilonFreeCFG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class EpsilonFreeCFG final : public GrammarBase, public alib::Components < EpsilonFreeCFG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	std::map < SymbolType, std::set < std::vector < SymbolType > > > rules;
 	bool generatesEpsilon;
 
@@ -157,7 +157,7 @@ EpsilonFreeCFG < SymbolType >::EpsilonFreeCFG ( SymbolType initialSymbol ) : Eps
 }
 
 template < class SymbolType >
-EpsilonFreeCFG < SymbolType >::EpsilonFreeCFG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < EpsilonFreeCFG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
+EpsilonFreeCFG < SymbolType >::EpsilonFreeCFG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < EpsilonFreeCFG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
 }
 
 template < class SymbolType >
@@ -353,7 +353,7 @@ alib::ObjectBase* EpsilonFreeCFG < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< grammar::EpsilonFreeCFG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
@@ -418,6 +418,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* EPSILON_FREE_CFG_H_ */
diff --git a/alib2data/src/grammar/ContextFree/GNF.h b/alib2data/src/grammar/ContextFree/GNF.h
index b0d9c56d03962add6c6f50fb8be73c4b4d9e5a42..5dd596d7695b7004647b9cd087fb80904486d9a1 100644
--- a/alib2data/src/grammar/ContextFree/GNF.h
+++ b/alib2data/src/grammar/ContextFree/GNF.h
@@ -35,7 +35,7 @@ class NonterminalAlphabet;
 class InitialSymbol;
 
 template < class SymbolType >
-class GNF final : public GrammarBase, public std::Components < GNF < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class GNF final : public GrammarBase, public alib::Components < GNF < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	std::map < SymbolType, std::set < std::pair < SymbolType, std::vector < SymbolType > > > > rules;
 	bool generatesEpsilon;
 
@@ -158,7 +158,7 @@ GNF < SymbolType >::GNF ( SymbolType initialSymbol ) : GNF ( std::set < SymbolTy
 }
 
 template < class SymbolType >
-GNF < SymbolType >::GNF ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < GNF, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
+GNF < SymbolType >::GNF ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < GNF, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
 }
 
 template < class SymbolType >
@@ -364,7 +364,7 @@ alib::ObjectBase* GNF < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< grammar::GNF < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
@@ -428,6 +428,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* GNF_H_ */
diff --git a/alib2data/src/grammar/ContextFree/LG.h b/alib2data/src/grammar/ContextFree/LG.h
index a2b672fca674bcc63aabe3cc2604157e7b8b7cfb..b2451b81c8ecaf70635f6e135a12b2ee29c0254d 100644
--- a/alib2data/src/grammar/ContextFree/LG.h
+++ b/alib2data/src/grammar/ContextFree/LG.h
@@ -37,7 +37,7 @@ class NonterminalAlphabet;
 class InitialSymbol;
 
 template < class SymbolType >
-class LG final : public GrammarBase, public std::Components < LG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class LG final : public GrammarBase, public alib::Components < LG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > rules;
 
 public:
@@ -157,7 +157,7 @@ LG < SymbolType >::LG ( SymbolType initialSymbol ) : LG ( std::set < SymbolType
 }
 
 template < class SymbolType >
-LG < SymbolType >::LG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < LG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
+LG < SymbolType >::LG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < LG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
 }
 
 template < class SymbolType >
@@ -404,7 +404,7 @@ alib::ObjectBase* LG < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< grammar::LG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
@@ -491,6 +491,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* LG_H_ */
diff --git a/alib2data/src/grammar/ContextSensitive/CSG.h b/alib2data/src/grammar/ContextSensitive/CSG.h
index 7ee139d84e51072c83372661b5b634947e85ec70..0e2feb1c2f9820ed768e49575d7d6a00c1c02de0 100644
--- a/alib2data/src/grammar/ContextSensitive/CSG.h
+++ b/alib2data/src/grammar/ContextSensitive/CSG.h
@@ -35,7 +35,7 @@ class NonterminalAlphabet;
 class InitialSymbol;
 
 template < class SymbolType >
-class CSG final : public GrammarBase, public std::Components < CSG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class CSG final : public GrammarBase, public alib::Components < CSG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	std::map < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > >, std::set < std::vector < SymbolType > > > rules;
 	bool generatesEpsilon;
 
@@ -153,7 +153,7 @@ CSG < SymbolType >::CSG ( SymbolType initialSymbol ) : CSG ( std::set < SymbolTy
 }
 
 template < class SymbolType >
-CSG < SymbolType >::CSG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < CSG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
+CSG < SymbolType >::CSG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < CSG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
 }
 
 template < class SymbolType >
@@ -335,7 +335,7 @@ alib::ObjectBase* CSG < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< grammar::CSG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
@@ -418,6 +418,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* CSG_H_ */
diff --git a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
index 53ab9db9f264b1d00af41867a360c819f2af3141..dfc18b4e9e3ac8a0b6b4b82dd5acd6f73fff7d80 100644
--- a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
+++ b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
@@ -35,7 +35,7 @@ class NonterminalAlphabet;
 class InitialSymbol;
 
 template < class SymbolType >
-class NonContractingGrammar final : public GrammarBase, public std::Components < NonContractingGrammar < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class NonContractingGrammar final : public GrammarBase, public alib::Components < NonContractingGrammar < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	std::map < std::vector < SymbolType >, std::set < std::vector < SymbolType > > > rules;
 	bool generatesEpsilon;
 
@@ -151,7 +151,7 @@ NonContractingGrammar < SymbolType >::NonContractingGrammar ( SymbolType initial
 }
 
 template < class SymbolType >
-NonContractingGrammar < SymbolType >::NonContractingGrammar ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < NonContractingGrammar, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
+NonContractingGrammar < SymbolType >::NonContractingGrammar ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < NonContractingGrammar, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
 }
 
 template < class SymbolType >
@@ -332,7 +332,7 @@ alib::ObjectBase* NonContractingGrammar < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< grammar::NonContractingGrammar < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
@@ -402,6 +402,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* NON_CONTRACTING_GRAMMAR_H_ */
diff --git a/alib2data/src/grammar/Regular/LeftLG.h b/alib2data/src/grammar/Regular/LeftLG.h
index 6e39409400dd98b8dbbe854350e64008cd68fa84..6aa0f619082b01d293194982739b9bcc1515f392 100644
--- a/alib2data/src/grammar/Regular/LeftLG.h
+++ b/alib2data/src/grammar/Regular/LeftLG.h
@@ -63,7 +63,7 @@ class InitialSymbol;
  * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
  */
 template < class SymbolType >
-class LeftLG final : public GrammarBase, public std::Components < LeftLG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class LeftLG final : public GrammarBase, public alib::Components < LeftLG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	/**
 	 * Rules as mapping from nonterminal symbol on the left hand side to set of either sequence of terminal symbols or doublets of sequence of terminal symbols and nonterminal symbol.
 	 */
@@ -399,7 +399,7 @@ LeftLG < SymbolType >::LeftLG ( SymbolType initialSymbol ) : LeftLG ( std::set <
 }
 
 template < class SymbolType >
-LeftLG < SymbolType >::LeftLG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < LeftLG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
+LeftLG < SymbolType >::LeftLG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < LeftLG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
 }
 
 template < class SymbolType >
@@ -629,7 +629,7 @@ alib::ObjectBase* LeftLG < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 /**
  * Helper class specifying constraints for the grammar's internal terminal alphabet component.
@@ -777,6 +777,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* LEFT_LG_H_ */
diff --git a/alib2data/src/grammar/Regular/LeftRG.h b/alib2data/src/grammar/Regular/LeftRG.h
index ac2f6712ee8ae2ce02afc562d5d722587fd25fab..031c98b0eb8da2e5431dbc6983104a64827b2273 100644
--- a/alib2data/src/grammar/Regular/LeftRG.h
+++ b/alib2data/src/grammar/Regular/LeftRG.h
@@ -67,7 +67,7 @@ class InitialSymbol;
  * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
  */
 template < class SymbolType >
-class LeftRG final : public GrammarBase, public std::Components < LeftRG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class LeftRG final : public GrammarBase, public alib::Components < LeftRG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	/**
 	 * Rules as mapping from nonterminal symbol on the left hand side to set of either terminal symbols or doublets of terminal symbol and nonterminal symbol.
 	 */
@@ -423,7 +423,7 @@ LeftRG < SymbolType >::LeftRG ( SymbolType initialSymbol ) : LeftRG ( std::set <
 }
 
 template < class SymbolType >
-LeftRG < SymbolType >::LeftRG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < LeftRG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
+LeftRG < SymbolType >::LeftRG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < LeftRG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
 }
 
 template < class SymbolType >
@@ -678,7 +678,7 @@ alib::ObjectBase* LeftRG < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 /**
  * Helper class specifying constraints for the grammar's internal terminal alphabet component.
@@ -811,6 +811,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* LEFT_RG_H_ */
diff --git a/alib2data/src/grammar/Regular/RightLG.h b/alib2data/src/grammar/Regular/RightLG.h
index a6dcb8dbae37769cff918493ee542543e0c90a15..796c430daf82e0afffa72772546bd5c2e73aa988 100644
--- a/alib2data/src/grammar/Regular/RightLG.h
+++ b/alib2data/src/grammar/Regular/RightLG.h
@@ -63,7 +63,7 @@ class InitialSymbol;
  * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
  */
 template < class SymbolType >
-class RightLG final : public GrammarBase, public std::Components < RightLG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class RightLG final : public GrammarBase, public alib::Components < RightLG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	/**
 	 * Rules as mapping from nonterminal symbol on the left hand side to set of either sequence of terminal symbols or doublets of sequence of nonterminal symbol and terminal symbols.
 	 */
@@ -398,7 +398,7 @@ RightLG < SymbolType >::RightLG ( SymbolType initialSymbol ) : RightLG ( std::se
 }
 
 template < class SymbolType >
-RightLG < SymbolType >::RightLG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < RightLG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
+RightLG < SymbolType >::RightLG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < RightLG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
 }
 
 template < class SymbolType >
@@ -626,7 +626,7 @@ alib::ObjectBase* RightLG < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 /**
  * Helper class specifying constraints for the grammar's internal terminal alphabet component.
@@ -774,6 +774,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* RIGHT_LG_H_ */
diff --git a/alib2data/src/grammar/Regular/RightRG.h b/alib2data/src/grammar/Regular/RightRG.h
index 3dae1b25e4eefced3cbd09e16655d6e1b331ed6c..e1e56e6c516b61f513dbb2da7698444dc8ed75dd 100644
--- a/alib2data/src/grammar/Regular/RightRG.h
+++ b/alib2data/src/grammar/Regular/RightRG.h
@@ -67,7 +67,7 @@ class InitialSymbol;
  * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
  */
 template < class SymbolType >
-class RightRG final : public GrammarBase, public std::Components < RightRG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class RightRG final : public GrammarBase, public alib::Components < RightRG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	/**
 	 * Rules function as mapping from nonterminal symbol on the left hand side to set of either terminal symbols or doublets of nonterminal symbol and terminal symbol.
 	 */
@@ -423,7 +423,7 @@ RightRG < SymbolType >::RightRG ( SymbolType initialSymbol ) : RightRG ( std::se
 }
 
 template < class SymbolType >
-RightRG < SymbolType >::RightRG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < RightRG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
+RightRG < SymbolType >::RightRG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < RightRG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ), generatesEpsilon ( false ) {
 }
 
 template < class SymbolType >
@@ -675,7 +675,7 @@ alib::ObjectBase* RightRG < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 /**
  * Helper class specifying constraints for the grammar's internal terminal alphabet component.
@@ -808,6 +808,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* RIGHT_RG_H_ */
diff --git a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
index 90bc2da2738184b0acbb994f909e13ffe6207973..2eae7c71a70d033e0b3e1bbe4e6821eb00153127 100644
--- a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
@@ -35,7 +35,7 @@ class NonterminalAlphabet;
 class InitialSymbol;
 
 template < class SymbolType >
-class ContextPreservingUnrestrictedGrammar final : public GrammarBase, public std::Components < ContextPreservingUnrestrictedGrammar < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class ContextPreservingUnrestrictedGrammar final : public GrammarBase, public alib::Components < ContextPreservingUnrestrictedGrammar < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	std::map < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > >, std::set < std::vector < SymbolType > > > rules;
 
 public:
@@ -147,7 +147,7 @@ ContextPreservingUnrestrictedGrammar < SymbolType >::ContextPreservingUnrestrict
 }
 
 template < class SymbolType >
-ContextPreservingUnrestrictedGrammar < SymbolType >::ContextPreservingUnrestrictedGrammar ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < ContextPreservingUnrestrictedGrammar, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
+ContextPreservingUnrestrictedGrammar < SymbolType >::ContextPreservingUnrestrictedGrammar ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < ContextPreservingUnrestrictedGrammar, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
 }
 
 template < class SymbolType >
@@ -305,7 +305,7 @@ alib::ObjectBase* ContextPreservingUnrestrictedGrammar < SymbolType >::inc() &&
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< grammar::ContextPreservingUnrestrictedGrammar < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
@@ -388,6 +388,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR_H_ */
diff --git a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
index 41327f194f9183bc35fd418607deecea1485ac4a..de74c5835ccf65fd9a0895b5b1eb326bf29274ea 100644
--- a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
@@ -35,7 +35,7 @@ class NonterminalAlphabet;
 class InitialSymbol;
 
 template < class SymbolType >
-class UnrestrictedGrammar final : public GrammarBase, public std::Components < UnrestrictedGrammar < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+class UnrestrictedGrammar final : public GrammarBase, public alib::Components < UnrestrictedGrammar < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
 	std::map < std::vector < SymbolType >, std::set < std::vector < SymbolType > > > rules;
 
 public:
@@ -145,7 +145,7 @@ UnrestrictedGrammar < SymbolType >::UnrestrictedGrammar ( SymbolType initialSymb
 }
 
 template < class SymbolType >
-UnrestrictedGrammar < SymbolType >::UnrestrictedGrammar ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < UnrestrictedGrammar, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
+UnrestrictedGrammar < SymbolType >::UnrestrictedGrammar ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : alib::Components < UnrestrictedGrammar, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
 }
 
 template < class SymbolType >
@@ -295,7 +295,7 @@ alib::ObjectBase* UnrestrictedGrammar < SymbolType >::inc() && {
 
 } /* namespace grammar */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< grammar::UnrestrictedGrammar < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
@@ -365,6 +365,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* UNRESTRICTED_GRAMMAR_H_ */
diff --git a/alib2data/src/indexes/arbology/CompressedBitParallelTreeIndex.h b/alib2data/src/indexes/arbology/CompressedBitParallelTreeIndex.h
index f4f225695537ba71a623559031dde8ebef09fdb0..ee3e4d676d69a0d503cd5cf0bd9777aad469ba2e 100644
--- a/alib2data/src/indexes/arbology/CompressedBitParallelTreeIndex.h
+++ b/alib2data/src/indexes/arbology/CompressedBitParallelTreeIndex.h
@@ -42,7 +42,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType = DefaultSymbolType >
-class CompressedBitParallelTreeIndex final : public alib::ObjectBase, public std::Components < CompressedBitParallelTreeIndex < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class CompressedBitParallelTreeIndex final : public alib::ObjectBase, public alib::Components < CompressedBitParallelTreeIndex < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 protected:
 	std::map < SymbolType, common::SparseBoolVector > m_vectors;
 	std::vector < int > m_jumpTable;
@@ -143,7 +143,7 @@ namespace indexes {
 namespace arbology {
 
 template < class SymbolType >
-CompressedBitParallelTreeIndex < SymbolType >::CompressedBitParallelTreeIndex ( std::set < SymbolType > alphabet, std::map < SymbolType, common::SparseBoolVector > vectors, std::vector < int > jumpTable ) : std::Components < CompressedBitParallelTreeIndex, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_vectors ( std::move ( vectors ) ), m_jumpTable ( jumpTable ) {
+CompressedBitParallelTreeIndex < SymbolType >::CompressedBitParallelTreeIndex ( std::set < SymbolType > alphabet, std::map < SymbolType, common::SparseBoolVector > vectors, std::vector < int > jumpTable ) : alib::Components < CompressedBitParallelTreeIndex, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_vectors ( std::move ( vectors ) ), m_jumpTable ( jumpTable ) {
 }
 
 template < class SymbolType >
@@ -242,7 +242,7 @@ alib::ObjectBase * CompressedBitParallelTreeIndex < SymbolType >::inc ( ) && {
 
 } /* namespace indexes */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint < indexes::arbology::CompressedBitParallelTreeIndex < SymbolType >, SymbolType, indexes::arbology::GeneralAlphabet > {
@@ -262,6 +262,6 @@ public:
 
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* ARBOLOGY_COMPRESSED_BIT_PARALLEL_INDEX_H_ */
diff --git a/alib2data/src/indexes/stringology/BNDMMatcher.h b/alib2data/src/indexes/stringology/BNDMMatcher.h
index cb8dda4e255b18ef7fbbb142cd81c6aa3d136042..0f0bb5cb803d14874eb261476fb57145dfe0d9a4 100644
--- a/alib2data/src/indexes/stringology/BNDMMatcher.h
+++ b/alib2data/src/indexes/stringology/BNDMMatcher.h
@@ -43,7 +43,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType = DefaultSymbolType, size_t BitmaskBitCount = 64 >
-class BNDMMatcher final : public alib::ObjectBase, public std::Components < BNDMMatcher < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class BNDMMatcher final : public alib::ObjectBase, public alib::Components < BNDMMatcher < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 protected:
 	std::map < SymbolType, std::bitset < BitmaskBitCount > > m_vectors;
 	std::vector < SymbolType > m_string;
@@ -142,7 +142,7 @@ namespace indexes {
 namespace stringology {
 
 template < class SymbolType, size_t BitmaskBitCount >
-BNDMMatcher < SymbolType, BitmaskBitCount >::BNDMMatcher ( std::set < SymbolType > alphabet, std::map < SymbolType, std::bitset < BitmaskBitCount > > vectors, std::vector < SymbolType > string ) : std::Components < BNDMMatcher, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_vectors ( std::move ( vectors ) ), m_string ( std::move ( string ) ) {
+BNDMMatcher < SymbolType, BitmaskBitCount >::BNDMMatcher ( std::set < SymbolType > alphabet, std::map < SymbolType, std::bitset < BitmaskBitCount > > vectors, std::vector < SymbolType > string ) : alib::Components < BNDMMatcher, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_vectors ( std::move ( vectors ) ), m_string ( std::move ( string ) ) {
 }
 
 template < class SymbolType, size_t BitmaskBitCount >
@@ -222,7 +222,7 @@ alib::ObjectBase* BNDMMatcher < SymbolType, BitmaskBitCount >::inc() && {
 
 } /* namespace indexes */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, size_t BitmaskBitCount >
 class ComponentConstraint < indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount >, SymbolType, indexes::stringology::GeneralAlphabet > {
@@ -240,6 +240,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* BNDM_MATCHER_H_ */
diff --git a/alib2data/src/indexes/stringology/BitParallelIndex.h b/alib2data/src/indexes/stringology/BitParallelIndex.h
index 4a5ab3c6c7416dadaeeedcabc898d151d78384bf..f7cf21c9ddac44f801f1a62b4fe527a63de9b189 100644
--- a/alib2data/src/indexes/stringology/BitParallelIndex.h
+++ b/alib2data/src/indexes/stringology/BitParallelIndex.h
@@ -41,7 +41,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType = DefaultSymbolType >
-class BitParallelIndex final : public alib::ObjectBase, public std::Components < BitParallelIndex < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class BitParallelIndex final : public alib::ObjectBase, public alib::Components < BitParallelIndex < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 protected:
 	std::map < SymbolType, std::vector < bool > > m_vectors;
 
@@ -136,7 +136,7 @@ namespace indexes {
 namespace stringology {
 
 template < class SymbolType >
-BitParallelIndex < SymbolType >::BitParallelIndex ( std::set < SymbolType > alphabet, std::map < SymbolType, std::vector < bool > > vectors ) : std::Components < BitParallelIndex, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_vectors ( std::move ( vectors ) ) {
+BitParallelIndex < SymbolType >::BitParallelIndex ( std::set < SymbolType > alphabet, std::map < SymbolType, std::vector < bool > > vectors ) : alib::Components < BitParallelIndex, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_vectors ( std::move ( vectors ) ) {
 }
 
 template < class SymbolType >
@@ -226,7 +226,7 @@ alib::ObjectBase* BitParallelIndex < SymbolType >::inc() && {
 
 } /* namespace indexes */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint < indexes::stringology::BitParallelIndex < SymbolType >, SymbolType, indexes::stringology::GeneralAlphabet > {
@@ -244,6 +244,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* BIT_PARALLEL_INDEX_H_ */
diff --git a/alib2data/src/indexes/stringology/CompressedBitParallelIndex.h b/alib2data/src/indexes/stringology/CompressedBitParallelIndex.h
index a6616ea9db861211bcd2a1784c723537acc5d7ad..9f41152eb4d38308bc6ee7b55560604e35e262cc 100644
--- a/alib2data/src/indexes/stringology/CompressedBitParallelIndex.h
+++ b/alib2data/src/indexes/stringology/CompressedBitParallelIndex.h
@@ -41,7 +41,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType = DefaultSymbolType >
-class CompressedBitParallelIndex final : public alib::ObjectBase, public std::Components < CompressedBitParallelIndex < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class CompressedBitParallelIndex final : public alib::ObjectBase, public alib::Components < CompressedBitParallelIndex < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 protected:
 	std::map < SymbolType, common::SparseBoolVector > m_vectors;
 
@@ -136,7 +136,7 @@ namespace indexes {
 namespace stringology {
 
 template < class SymbolType >
-CompressedBitParallelIndex < SymbolType >::CompressedBitParallelIndex ( std::set < SymbolType > alphabet, std::map < SymbolType, common::SparseBoolVector > vectors ) : std::Components < CompressedBitParallelIndex, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_vectors ( std::move ( vectors ) ) {
+CompressedBitParallelIndex < SymbolType >::CompressedBitParallelIndex ( std::set < SymbolType > alphabet, std::map < SymbolType, common::SparseBoolVector > vectors ) : alib::Components < CompressedBitParallelIndex, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_vectors ( std::move ( vectors ) ) {
 }
 
 template < class SymbolType >
@@ -226,7 +226,7 @@ alib::ObjectBase* CompressedBitParallelIndex < SymbolType >::inc() && {
 
 } /* namespace indexes */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint < indexes::stringology::CompressedBitParallelIndex < SymbolType >, SymbolType, indexes::stringology::GeneralAlphabet > {
@@ -244,6 +244,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* COMPRESSED_BIT_PARALLEL_INDEX_H_ */
diff --git a/alib2data/src/indexes/stringology/PositionHeap.h b/alib2data/src/indexes/stringology/PositionHeap.h
index 09d479d03304c0961910a5a80365802b2d5c021e..1507cf461b3f54f22ca9676f0888988b05ac4df1 100644
--- a/alib2data/src/indexes/stringology/PositionHeap.h
+++ b/alib2data/src/indexes/stringology/PositionHeap.h
@@ -47,7 +47,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType = DefaultSymbolType >
-class PositionHeap final : public alib::ObjectBase, public std::Components < PositionHeap < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class PositionHeap final : public alib::ObjectBase, public alib::Components < PositionHeap < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 protected:
 	std::trie < SymbolType, unsigned > m_trie;
 	std::vector < SymbolType > m_string;
@@ -149,7 +149,7 @@ namespace indexes {
 namespace stringology {
 
 template < class SymbolType >
-PositionHeap < SymbolType >::PositionHeap ( std::set < SymbolType > edgeAlphabet, std::trie < SymbolType, unsigned > trie, std::vector < SymbolType > string ) : std::Components < PositionHeap, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( edgeAlphabet ) ), std::tuple < > ( ) ), m_trie ( std::move ( trie ) ), m_string ( std::move ( string ) ) {
+PositionHeap < SymbolType >::PositionHeap ( std::set < SymbolType > edgeAlphabet, std::trie < SymbolType, unsigned > trie, std::vector < SymbolType > string ) : alib::Components < PositionHeap, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( edgeAlphabet ) ), std::tuple < > ( ) ), m_trie ( std::move ( trie ) ), m_string ( std::move ( string ) ) {
 	checkTrie ( this->m_trie );
 	// TODO check validity of the string like in LinearString
 }
@@ -245,7 +245,7 @@ alib::ObjectBase* PositionHeap < SymbolType >::inc() && {
 
 } /* namespace indexes */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint < indexes::stringology::PositionHeap < SymbolType >, SymbolType, indexes::stringology::GeneralAlphabet > {
@@ -272,6 +272,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* POSITION_HEAP_H_ */
diff --git a/alib2data/src/indexes/stringology/SuffixArray.h b/alib2data/src/indexes/stringology/SuffixArray.h
index dc95fa046d9a8ccaaf57e7b7bb478c36e6ecb553..403ae09217e8e00e2b3cc455c0d2e8d433ce7e99 100644
--- a/alib2data/src/indexes/stringology/SuffixArray.h
+++ b/alib2data/src/indexes/stringology/SuffixArray.h
@@ -44,7 +44,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType = DefaultSymbolType >
-class SuffixArray final : public alib::ObjectBase, public std::Components < SuffixArray < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class SuffixArray final : public alib::ObjectBase, public alib::Components < SuffixArray < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 protected:
 	std::vector < unsigned > m_data;
 	std::vector < SymbolType > m_string;
@@ -138,7 +138,7 @@ namespace indexes {
 namespace stringology {
 
 template < class SymbolType >
-SuffixArray < SymbolType >::SuffixArray ( std::set < SymbolType > alphabet, std::vector < unsigned > data, std::vector < SymbolType > string ) : std::Components < SuffixArray, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_data ( std::move ( data ) ), m_string ( std::move ( string ) ) {
+SuffixArray < SymbolType >::SuffixArray ( std::set < SymbolType > alphabet, std::vector < unsigned > data, std::vector < SymbolType > string ) : alib::Components < SuffixArray, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_data ( std::move ( data ) ), m_string ( std::move ( string ) ) {
 	// TODO check validity of the string like in LinearString
 }
 
@@ -219,7 +219,7 @@ alib::ObjectBase* SuffixArray < SymbolType >::inc() && {
 
 } /* namespace indexes */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint < indexes::stringology::SuffixArray < SymbolType >, SymbolType, indexes::stringology::GeneralAlphabet > {
@@ -237,6 +237,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* SUFFIX_ARRAY_H_ */
diff --git a/alib2data/src/indexes/stringology/SuffixTrie.h b/alib2data/src/indexes/stringology/SuffixTrie.h
index 239430a798eb7e8198d0d58710fcd0998e84183e..b85884b42c60fee5ad1af1c840bd37070e25ea08 100644
--- a/alib2data/src/indexes/stringology/SuffixTrie.h
+++ b/alib2data/src/indexes/stringology/SuffixTrie.h
@@ -49,7 +49,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType = DefaultSymbolType >
-class SuffixTrie final : public alib::ObjectBase, public std::Components < SuffixTrie < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class SuffixTrie final : public alib::ObjectBase, public alib::Components < SuffixTrie < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 protected:
 	std::trie < SymbolType, std::variant < void, unsigned > > m_trie;
 
@@ -148,7 +148,7 @@ SuffixTrie < SymbolType >::SuffixTrie ( std::set < SymbolType > edgeAlphabet ) :
 }
 
 template < class SymbolType >
-SuffixTrie < SymbolType >::SuffixTrie ( std::set < SymbolType > edgeAlphabet, std::trie < SymbolType, std::variant < void, unsigned > > trie ) : std::Components < SuffixTrie, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( edgeAlphabet ) ), std::tuple < > ( ) ), m_trie ( std::move ( trie ) ) {
+SuffixTrie < SymbolType >::SuffixTrie ( std::set < SymbolType > edgeAlphabet, std::trie < SymbolType, std::variant < void, unsigned > > trie ) : alib::Components < SuffixTrie, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( edgeAlphabet ) ), std::tuple < > ( ) ), m_trie ( std::move ( trie ) ) {
 	checkTrie ( this->m_trie );
 }
 
@@ -236,7 +236,7 @@ alib::ObjectBase* SuffixTrie < SymbolType >::inc() && {
 
 } /* namespace indexes */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint < indexes::stringology::SuffixTrie < SymbolType >, SymbolType, indexes::stringology::GeneralAlphabet > {
@@ -262,6 +262,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* SUFFIX_TRIE_H_ */
diff --git a/alib2data/src/regexp/formal/FormalRegExp.h b/alib2data/src/regexp/formal/FormalRegExp.h
index 896786a15086547e5d8707e0addf250f4edb626b..86c4413b16cd46601ee52e4b99ac2d235f32b727 100644
--- a/alib2data/src/regexp/formal/FormalRegExp.h
+++ b/alib2data/src/regexp/formal/FormalRegExp.h
@@ -35,7 +35,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType >
-class FormalRegExp final : public RegExpBase, public std::Components < FormalRegExp < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class FormalRegExp final : public RegExpBase, public alib::Components < FormalRegExp < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 protected:
 	FormalRegExpStructure < SymbolType > m_regExp;
 
@@ -122,7 +122,7 @@ public:
 namespace regexp {
 
 template < class SymbolType >
-FormalRegExp < SymbolType >::FormalRegExp ( std::set < SymbolType > alphabet, FormalRegExpStructure < SymbolType > regExp ) : std::Components < FormalRegExp < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_regExp ( std::move ( regExp ) ) {
+FormalRegExp < SymbolType >::FormalRegExp ( std::set < SymbolType > alphabet, FormalRegExpStructure < SymbolType > regExp ) : alib::Components < FormalRegExp < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_regExp ( std::move ( regExp ) ) {
 	if ( !this->m_regExp.getStructure ( ).checkAlphabet ( getAlphabet ( ) ) )
 		throw exception::CommonException ( "Input symbols not in the alphabet." );
 }
@@ -218,7 +218,7 @@ alib::ObjectBase* FormalRegExp < SymbolType >::inc() && {
 
 } /* namespace regexp */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< regexp::FormalRegExp < SymbolType >, SymbolType, regexp::GeneralAlphabet > {
@@ -235,6 +235,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* FORMAL_REG_EXP_H_ */
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExp.h b/alib2data/src/regexp/unbounded/UnboundedRegExp.h
index e8b76a24c26c87ebd94057af1f7682b8ec23c025..ff5d6074de252dcf3d62b70990d5a7b61ca052cf 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExp.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExp.h
@@ -35,7 +35,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType >
-class UnboundedRegExp final : public RegExpBase, public std::Components < UnboundedRegExp < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class UnboundedRegExp final : public RegExpBase, public alib::Components < UnboundedRegExp < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 protected:
 	UnboundedRegExpStructure < SymbolType > m_regExp;
 
@@ -122,7 +122,7 @@ public:
 namespace regexp {
 
 template < class SymbolType >
-UnboundedRegExp < SymbolType >::UnboundedRegExp ( std::set < SymbolType > alphabet, UnboundedRegExpStructure < SymbolType > regExp ) : std::Components < UnboundedRegExp, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_regExp ( std::move ( regExp ) ) {
+UnboundedRegExp < SymbolType >::UnboundedRegExp ( std::set < SymbolType > alphabet, UnboundedRegExpStructure < SymbolType > regExp ) : alib::Components < UnboundedRegExp, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_regExp ( std::move ( regExp ) ) {
 	if ( !this->m_regExp.getStructure ( ).checkAlphabet ( getAlphabet ( ) ) )
 		throw exception::CommonException ( "Input symbols not in the alphabet." );
 }
@@ -218,7 +218,7 @@ alib::ObjectBase* UnboundedRegExp < SymbolType >::inc() && {
 
 } /* namespace regexp */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< regexp::UnboundedRegExp < SymbolType >, SymbolType, regexp::GeneralAlphabet > {
@@ -235,6 +235,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* UNBOUNDED_REG_EXP_H_ */
diff --git a/alib2data/src/rte/formal/FormalRTE.h b/alib2data/src/rte/formal/FormalRTE.h
index 09a447d9c43b578e653ed7b3049b554695d5affe..00550475b01287bef0e1aac30df5b3a538b04209 100644
--- a/alib2data/src/rte/formal/FormalRTE.h
+++ b/alib2data/src/rte/formal/FormalRTE.h
@@ -36,7 +36,7 @@ class ConstantAlphabet;
  * as a tree of RTEElement elements.
  */
 template < class SymbolType, class RankType >
-class FormalRTE final : public RTEBase, public std::Components < FormalRTE < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, ConstantAlphabet >, std::tuple < > > {
+class FormalRTE final : public RTEBase, public alib::Components < FormalRTE < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, ConstantAlphabet >, std::tuple < > > {
 protected:
 	FormalRTEStructure < SymbolType, RankType > m_rte;
 
@@ -153,7 +153,7 @@ public:
 };
 
 template < class SymbolType, class RankType >
-FormalRTE < SymbolType, RankType >::FormalRTE ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabetF, std::set < std::ranked_symbol < SymbolType, RankType > > alphabetK, FormalRTEStructure < SymbolType, RankType > rte ) : std::Components < FormalRTE, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, ConstantAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabetF ), std::move ( alphabetK ) ), std::tuple < > ( ) ), m_rte ( std::move ( rte ) ) {
+FormalRTE < SymbolType, RankType >::FormalRTE ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabetF, std::set < std::ranked_symbol < SymbolType, RankType > > alphabetK, FormalRTEStructure < SymbolType, RankType > rte ) : alib::Components < FormalRTE, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, ConstantAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabetF ), std::move ( alphabetK ) ), std::tuple < > ( ) ), m_rte ( std::move ( rte ) ) {
 	if ( !this->m_rte.getStructure ( ).checkAlphabet ( getAlphabet ( ), getSubstitutionAlphabet ( ) ) )
 		throw exception::CommonException ( "Input symbols not in the alphabet." );
 }
@@ -247,7 +247,7 @@ alib::ObjectBase* FormalRTE < SymbolType, RankType >::inc() && {
 
 } /* namespace rte */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< rte::FormalRTE < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, rte::GeneralAlphabet > {
@@ -283,6 +283,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* FORMAL_RTE_H_ */
diff --git a/alib2data/src/string/CyclicString.h b/alib2data/src/string/CyclicString.h
index c5e35e790ce052e8f9f8fe98b060c59e6ea51e71..aac588a355de202a2de09babc67d894287abb609 100644
--- a/alib2data/src/string/CyclicString.h
+++ b/alib2data/src/string/CyclicString.h
@@ -33,7 +33,7 @@ class GeneralAlphabet;
  * as a tree of CyclicStringElement.
  */
 template < class SymbolType >
-class CyclicString final : public StringBase, public std::Components < CyclicString < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class CyclicString final : public StringBase, public alib::Components < CyclicString < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	std::vector < SymbolType > m_Data;
 
 public:
@@ -110,7 +110,7 @@ public:
 namespace string {
 
 template < class SymbolType >
-CyclicString < SymbolType >::CyclicString(std::set<SymbolType> alphabet, std::vector<SymbolType> str) : std::Components < CyclicString < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
+CyclicString < SymbolType >::CyclicString(std::set<SymbolType> alphabet, std::vector<SymbolType> str) : alib::Components < CyclicString < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
 	setContent(std::move(str));
 }
 
@@ -218,7 +218,7 @@ alib::ObjectBase* CyclicString < SymbolType >::inc() && {
 
 } /* namespace string */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< ::string::CyclicString < SymbolType >, SymbolType, ::string::GeneralAlphabet > {
@@ -236,6 +236,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* CYCLIC_STRING_H_ */
diff --git a/alib2data/src/string/Epsilon.h b/alib2data/src/string/Epsilon.h
index e474825cf35d7a914d9c7d6824dba7ddebd0453a..157db424e96477ee32f556ea100a1b98ebcf21c5 100644
--- a/alib2data/src/string/Epsilon.h
+++ b/alib2data/src/string/Epsilon.h
@@ -30,7 +30,7 @@ class GeneralAlphabet;
  * as a tree of EpsilonElement.
  */
 template < class SymbolType >
-class Epsilon final : public StringBase, public std::Components < Epsilon < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class Epsilon final : public StringBase, public alib::Components < Epsilon < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	static const std::vector < SymbolType > content;
 
 public:
@@ -97,7 +97,7 @@ public:
 };
 
 template < class SymbolType >
-Epsilon < SymbolType >::Epsilon(std::set<SymbolType> alphabet) : std::Components < Epsilon < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
+Epsilon < SymbolType >::Epsilon(std::set<SymbolType> alphabet) : alib::Components < Epsilon < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
 }
 
 template < class SymbolType >
@@ -168,7 +168,7 @@ alib::ObjectBase* Epsilon < SymbolType >::inc() && {
 
 } /* namespace string */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< ::string::Epsilon < SymbolType >, SymbolType, ::string::GeneralAlphabet > {
@@ -185,6 +185,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* EPSILON_H_ */
diff --git a/alib2data/src/string/LinearString.h b/alib2data/src/string/LinearString.h
index 503d9cd04fa621b94a734b1ad6567c6db85074d3..267bca99f9a4f269101b1861fa21973a6fe630aa 100644
--- a/alib2data/src/string/LinearString.h
+++ b/alib2data/src/string/LinearString.h
@@ -35,7 +35,7 @@ class GeneralAlphabet;
  * as a tree of LinearStringElement.
  */
 template < class SymbolType >
-class LinearString final : public StringBase, public std::Components < LinearString < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class LinearString final : public StringBase, public alib::Components < LinearString < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	std::vector < SymbolType > m_Data;
 
 public:
@@ -138,7 +138,7 @@ public:
 namespace string {
 
 template < class SymbolType >
-LinearString < SymbolType >::LinearString(std::set<SymbolType> alphabet, std::vector<SymbolType> str) : std::Components < LinearString < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
+LinearString < SymbolType >::LinearString(std::set<SymbolType> alphabet, std::vector<SymbolType> str) : alib::Components < LinearString < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
 	setContent(std::move(str));
 }
 
@@ -293,7 +293,7 @@ alib::ObjectBase* LinearString < SymbolType >::inc() && {
 
 } /* namespace string */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< ::string::LinearString < SymbolType >, SymbolType, ::string::GeneralAlphabet > {
@@ -311,6 +311,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* LINEAR_STRING_H_ */
diff --git a/alib2data/src/tree/ranked/PostfixRankedTree.h b/alib2data/src/tree/ranked/PostfixRankedTree.h
index f3fe6bf19fd2394ab1aaf0757ecc3a2230d59529..128a8c4a49f8a495266a504d7446685ec6c579d4 100644
--- a/alib2data/src/tree/ranked/PostfixRankedTree.h
+++ b/alib2data/src/tree/ranked/PostfixRankedTree.h
@@ -36,7 +36,7 @@ class GeneralAlphabet;
  * as a tree of LinearStringElement.
  */
 template < class SymbolType, class RankType >
-class PostfixRankedTree final : public RankedTreeBase, public std::Components < PostfixRankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class PostfixRankedTree final : public RankedTreeBase, public alib::Components < PostfixRankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	std::vector < std::ranked_symbol < SymbolType, RankType > > m_Data;
 
 	static std::vector < std::ranked_symbol < SymbolType, RankType > > toPostfixRanked ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & tree );
@@ -116,7 +116,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-PostfixRankedTree < SymbolType, RankType >::PostfixRankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : std::Components < PostfixRankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
+PostfixRankedTree < SymbolType, RankType >::PostfixRankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : alib::Components < PostfixRankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -241,7 +241,7 @@ alib::ObjectBase * PostfixRankedTree < SymbolType, RankType >::inc ( ) && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint < ::tree::PostfixRankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -261,6 +261,6 @@ public:
 
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* POSTFIX_RANKED_TREE_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
index dabebdcb1315b44a60b047a6d08d82ddefb95d22..8434914713523bacdc1b29febdd52d7e9464445e 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
@@ -45,7 +45,7 @@ class NonlinearAlphabet;
  * as a tree of LinearStringElement.
  */
 template < class SymbolType, class RankType >
-class PrefixRankedBarNonlinearPattern final : public RankedTreeBase, public std::Components < PrefixRankedBarNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > {
+class PrefixRankedBarNonlinearPattern final : public RankedTreeBase, public alib::Components < PrefixRankedBarNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > {
 	std::vector < std::ranked_symbol < SymbolType, RankType > > m_Data;
 
 	static std::vector < std::ranked_symbol < SymbolType, RankType > > toPrefixRankedBar ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & node, const std::ranked_symbol < SymbolType, RankType > & subtreeWildcard, const std::set < std::ranked_symbol < SymbolType, RankType > > & nonlinearVariables, const SymbolType & barBase, const std::ranked_symbol < SymbolType, RankType > & variablesBar );
@@ -156,7 +156,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-PrefixRankedBarNonlinearPattern < SymbolType, RankType >::PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : std::Components < PrefixRankedBarNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ), std::move ( bars ) ), std::make_tuple ( std::move ( subtreeWildcard ), std::move ( variablesBar ) ) ) {
+PrefixRankedBarNonlinearPattern < SymbolType, RankType >::PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : alib::Components < PrefixRankedBarNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ), std::move ( bars ) ), std::make_tuple ( std::move ( subtreeWildcard ), std::move ( variablesBar ) ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -337,7 +337,7 @@ alib::ObjectBase* PrefixRankedBarNonlinearPattern < SymbolType, RankType >::inc(
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::PrefixRankedBarNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -422,6 +422,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* PREFIX_RANKED_BAR_NONLINEAR_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
index a66ef94e8ae7278bb663ab82760dbae56b50089b..3f74434a6bee07553afb2a57921bfbf746e25a63 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
@@ -44,7 +44,7 @@ class VariablesBarSymbol;
  * as a tree of LinearStringElement.
  */
 template < class SymbolType, class RankType >
-class PrefixRankedBarPattern final : public RankedTreeBase, public std::Components < PrefixRankedBarPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > {
+class PrefixRankedBarPattern final : public RankedTreeBase, public alib::Components < PrefixRankedBarPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > {
 	std::vector < std::ranked_symbol < SymbolType, RankType > > m_Data;
 
 	static std::vector < std::ranked_symbol < SymbolType, RankType > > toPrefixRankedBar ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & node, const std::ranked_symbol < SymbolType, RankType > & subtreeWildcard, const SymbolType & barBase, const std::ranked_symbol < SymbolType, RankType > & variablesBar );
@@ -141,7 +141,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-PrefixRankedBarPattern < SymbolType, RankType >::PrefixRankedBarPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : std::Components < PrefixRankedBarPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > ( std::make_tuple ( std::move ( alphabet ), std::move ( bars ) ), std::make_tuple ( std::move ( subtreeWildcard ), std::move ( variablesBar ) ) ) {
+PrefixRankedBarPattern < SymbolType, RankType >::PrefixRankedBarPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : alib::Components < PrefixRankedBarPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < SubtreeWildcard, VariablesBarSymbol > > ( std::make_tuple ( std::move ( alphabet ), std::move ( bars ) ), std::make_tuple ( std::move ( subtreeWildcard ), std::move ( variablesBar ) ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -300,7 +300,7 @@ alib::ObjectBase* PrefixRankedBarPattern < SymbolType, RankType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::PrefixRankedBarPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -362,6 +362,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* PREFIX_RANKED_BAR_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarTree.h b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
index 77ca82b7e0c23c0b53c73b5d4527eef408ceeb62..e5c654aee267be2cd3e147558c3b8474e3bd77b2 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
@@ -40,7 +40,7 @@ class BarSymbols;
  * as a tree of LinearStringElement.
  */
 template < class SymbolType, class RankType >
-class PrefixRankedBarTree final : public RankedTreeBase, public std::Components < PrefixRankedBarTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < > > {
+class PrefixRankedBarTree final : public RankedTreeBase, public alib::Components < PrefixRankedBarTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < > > {
 	std::vector < std::ranked_symbol < SymbolType, RankType > > m_Data;
 
 	static std::vector < std::ranked_symbol < SymbolType, RankType > > toPrefixRankedBar ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & node, const SymbolType & barBase );
@@ -125,7 +125,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-PrefixRankedBarTree < SymbolType, RankType >::PrefixRankedBarTree ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : std::Components < PrefixRankedBarTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ), std::move ( bars ) ), std::tuple < > ( ) ) {
+PrefixRankedBarTree < SymbolType, RankType >::PrefixRankedBarTree ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : alib::Components < PrefixRankedBarTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ), std::move ( bars ) ), std::tuple < > ( ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -268,7 +268,7 @@ alib::ObjectBase* PrefixRankedBarTree < SymbolType, RankType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::PrefixRankedBarTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -304,6 +304,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* PREFIX_RANKED_BAR_TREE_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
index 20b795e028fdacfa004f1822f81838cde64a315d..6ed98c2b1901174f4ee18e5ef9d028f80756a565 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
@@ -40,7 +40,7 @@ class NonlinearAlphabet;
  * as a tree of LinearStringElement.
  */
 template < class SymbolType, class RankType >
-class PrefixRankedNonlinearPattern final : public RankedTreeBase, public std::Components < PrefixRankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
+class PrefixRankedNonlinearPattern final : public RankedTreeBase, public alib::Components < PrefixRankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::vector < std::ranked_symbol < SymbolType, RankType > > m_Data;
 
 	static std::vector < std::ranked_symbol < SymbolType, RankType > > toPrefixRanked ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & tree );
@@ -138,7 +138,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-PrefixRankedNonlinearPattern < SymbolType, RankType >::PrefixRankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : std::Components < PrefixRankedNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( subtreeWildcard ) ) {
+PrefixRankedNonlinearPattern < SymbolType, RankType >::PrefixRankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : alib::Components < PrefixRankedNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( subtreeWildcard ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -287,7 +287,7 @@ alib::ObjectBase* PrefixRankedNonlinearPattern < SymbolType, RankType >::inc() &
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::PrefixRankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -342,6 +342,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* PREFIX_RANKED_NONLINEAR_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.h b/alib2data/src/tree/ranked/PrefixRankedPattern.h
index 3ebb6e323645463fa57408d611961ebd63b55b9b..766a37c36b195362e3fa60db1d43f5d261067c37 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.h
@@ -39,7 +39,7 @@ class SubtreeWildcard;
  * as a tree of LinearStringElement.
  */
 template < class SymbolType, class RankType >
-class PrefixRankedPattern final : public RankedTreeBase, public std::Components < PrefixRankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
+class PrefixRankedPattern final : public RankedTreeBase, public alib::Components < PrefixRankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::vector < std::ranked_symbol < SymbolType, RankType > > m_Data;
 
 	static std::vector < std::ranked_symbol < SymbolType, RankType > > toPrefixRanked ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & tree );
@@ -125,7 +125,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-PrefixRankedPattern < SymbolType, RankType >::PrefixRankedPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : std::Components < PrefixRankedPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( subtreeWildcard ) ) {
+PrefixRankedPattern < SymbolType, RankType >::PrefixRankedPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : alib::Components < PrefixRankedPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( subtreeWildcard ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -256,7 +256,7 @@ alib::ObjectBase* PrefixRankedPattern < SymbolType, RankType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::PrefixRankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -288,6 +288,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* PREFIX_RANKED_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.h b/alib2data/src/tree/ranked/PrefixRankedTree.h
index ad8f65de1de5aa4b53f49b016ce3e8b90ee96729..a7bf9b3ee3beeef3a31d9174d06ef584b0d42d09 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.h
@@ -36,7 +36,7 @@ class GeneralAlphabet;
  * as a tree of LinearStringElement.
  */
 template < class SymbolType, class RankType >
-class PrefixRankedTree final : public RankedTreeBase, public std::Components < PrefixRankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class PrefixRankedTree final : public RankedTreeBase, public alib::Components < PrefixRankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	std::vector < std::ranked_symbol < SymbolType, RankType > > m_Data;
 
 	static std::vector < std::ranked_symbol < SymbolType, RankType > > toPrefixRanked ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & tree );
@@ -115,7 +115,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-PrefixRankedTree < SymbolType, RankType >::PrefixRankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : std::Components < PrefixRankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
+PrefixRankedTree < SymbolType, RankType >::PrefixRankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data ) : alib::Components < PrefixRankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -240,7 +240,7 @@ alib::ObjectBase* PrefixRankedTree < SymbolType, RankType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::PrefixRankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -259,6 +259,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* PREFIX_RANKED_TREE_H_ */
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.h b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
index fb8d7c9515f07afb0fefa63daf84e86b59624b9a..b67d51430ce2ba2a65ae03368989e69d1b4af83b 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
@@ -39,7 +39,7 @@ class NonlinearAlphabet;
  * as a pattern of RegExpElement.
  */
 template < class SymbolType, class RankType >
-class RankedNonlinearPattern final : public RankedTreeBase, public std::Components < RankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
+class RankedNonlinearPattern final : public RankedTreeBase, public alib::Components < RankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::tree < std::ranked_symbol < SymbolType, RankType > > m_content;
 
 	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
@@ -142,7 +142,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-RankedNonlinearPattern < SymbolType, RankType >::RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+RankedNonlinearPattern < SymbolType, RankType >::RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : alib::Components < RankedNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
 	checkAlphabet ( m_content );
 	checkArities ( m_content );
 }
@@ -258,7 +258,7 @@ alib::ObjectBase* RankedNonlinearPattern < SymbolType, RankType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::RankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -312,6 +312,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* RANKED_NONLINEAR_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/RankedPattern.h b/alib2data/src/tree/ranked/RankedPattern.h
index 32d69d0a4247243c14a0c8b894feb55d6c64a94f..3aca741567f174d8241ce81a290ad690a7c3a539 100644
--- a/alib2data/src/tree/ranked/RankedPattern.h
+++ b/alib2data/src/tree/ranked/RankedPattern.h
@@ -38,7 +38,7 @@ class SubtreeWildcard;
  * as a pattern of RegExpElement.
  */
 template < class SymbolType, class RankType >
-class RankedPattern final : public RankedTreeBase, public std::Components < RankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
+class RankedPattern final : public RankedTreeBase, public alib::Components < RankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::tree < std::ranked_symbol < SymbolType, RankType > > m_content;
 
 	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
@@ -135,7 +135,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-RankedPattern < SymbolType, RankType >::RankedPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+RankedPattern < SymbolType, RankType >::RankedPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : alib::Components < RankedPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
 	checkAlphabet ( m_content );
 	checkArities ( m_content );
 }
@@ -245,7 +245,7 @@ alib::ObjectBase* RankedPattern < SymbolType, RankType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::RankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -276,6 +276,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* RANKED_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/RankedTree.h b/alib2data/src/tree/ranked/RankedTree.h
index f8850f34b9066d21659fb86a80427cf1f86dc439..689db2abc0798d88d1b5ddd123bf42626832261e 100644
--- a/alib2data/src/tree/ranked/RankedTree.h
+++ b/alib2data/src/tree/ranked/RankedTree.h
@@ -38,7 +38,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType, class RankType >
-class RankedTree final : public RankedTreeBase, public std::Components < RankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class RankedTree final : public RankedTreeBase, public alib::Components < RankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	std::tree < std::ranked_symbol < SymbolType, RankType > > m_content;
 
 	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
@@ -132,7 +132,7 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-RankedTree < SymbolType, RankType >::RankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > tree ) : std::Components < RankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_content ( std::move ( tree ) ) {
+RankedTree < SymbolType, RankType >::RankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > tree ) : alib::Components < RankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_content ( std::move ( tree ) ) {
 	checkAlphabet ( m_content );
 	checkArities ( m_content );
 }
@@ -244,7 +244,7 @@ alib::ObjectBase* RankedTree < SymbolType, RankType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::RankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
@@ -262,6 +262,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* RANKED_TREE_H_ */
diff --git a/alib2data/src/tree/unranked/PrefixBarTree.h b/alib2data/src/tree/unranked/PrefixBarTree.h
index ca89691a1ec198572128e2d8eddd51adca743681..8bc87d62c3585ed17fef3ff2ef2d3ee78f54f05d 100644
--- a/alib2data/src/tree/unranked/PrefixBarTree.h
+++ b/alib2data/src/tree/unranked/PrefixBarTree.h
@@ -37,7 +37,7 @@ class BarSymbol;
  * Represents a tree in prefix bar notation.
  */
 template < class SymbolType >
-class PrefixBarTree final : public UnrankedTreeBase, public std::Components < PrefixBarTree < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < BarSymbol > > {
+class PrefixBarTree final : public UnrankedTreeBase, public alib::Components < PrefixBarTree < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < BarSymbol > > {
 	std::vector < SymbolType > m_Data;
 
 	static std::vector < SymbolType > toPrefixBar ( const std::tree < SymbolType > & tree, const SymbolType & bar );
@@ -122,7 +122,7 @@ public:
 namespace tree {
 
 template < class SymbolType >
-PrefixBarTree < SymbolType >::PrefixBarTree ( SymbolType bar, std::set < SymbolType > alphabet, std::vector < SymbolType > data ) : std::Components < PrefixBarTree, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < BarSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( bar ) ) ) {
+PrefixBarTree < SymbolType >::PrefixBarTree ( SymbolType bar, std::set < SymbolType > alphabet, std::vector < SymbolType > data ) : alib::Components < PrefixBarTree, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < BarSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( bar ) ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -258,7 +258,7 @@ alib::ObjectBase* PrefixBarTree < SymbolType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< ::tree::PrefixBarTree < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
@@ -288,6 +288,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* PREFIX_BAR_TREE_H_ */
diff --git a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
index fd9ef44d20040bc78388348b3187c2b590dac929..634ca65417c99f0d650fec83c4206ed69e8d8009 100644
--- a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
@@ -38,7 +38,7 @@ class NonlinearAlphabet;
  * as a pattern of RegExpElement.
  */
 template < class SymbolType >
-class UnrankedNonlinearPattern final : public UnrankedTreeBase, public std::Components < UnrankedNonlinearPattern < SymbolType >, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
+class UnrankedNonlinearPattern final : public UnrankedTreeBase, public alib::Components < UnrankedNonlinearPattern < SymbolType >, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::tree < SymbolType > m_content;
 
 	void checkAlphabet ( const std::tree < SymbolType > & pattern ) const;
@@ -146,7 +146,7 @@ public:
 namespace tree {
 
 template < class SymbolType >
-UnrankedNonlinearPattern < SymbolType >::UnrankedNonlinearPattern ( SymbolType subtreeWildcard, std::set < SymbolType > nonlinearVariables, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedNonlinearPattern, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+UnrankedNonlinearPattern < SymbolType >::UnrankedNonlinearPattern ( SymbolType subtreeWildcard, std::set < SymbolType > nonlinearVariables, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : alib::Components < UnrankedNonlinearPattern, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
 	checkAlphabet ( m_content );
 }
 
@@ -252,7 +252,7 @@ alib::ObjectBase* UnrankedNonlinearPattern < SymbolType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< ::tree::UnrankedNonlinearPattern < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
@@ -300,6 +300,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* UNRANKED_NONLINEAR_PATTERN_H_ */
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.h b/alib2data/src/tree/unranked/UnrankedPattern.h
index 37ff7123b0cfc4f6edfa0403b1d9f72b98bf2cdb..b61ebbbc0620b7a650c4108a8e92f4bf1d6e555d 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedPattern.h
@@ -37,7 +37,7 @@ class SubtreeWildcard;
  * as a pattern of RegExpElement.
  */
 template < class SymbolType >
-class UnrankedPattern final : public UnrankedTreeBase, public std::Components < UnrankedPattern < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
+class UnrankedPattern final : public UnrankedTreeBase, public alib::Components < UnrankedPattern < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::tree < SymbolType > m_content;
 
 	void checkAlphabet ( const std::tree < SymbolType > & pattern ) const;
@@ -133,7 +133,7 @@ public:
 namespace tree {
 
 template < class SymbolType >
-UnrankedPattern < SymbolType >::UnrankedPattern ( SymbolType subtreeWildcard, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedPattern, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+UnrankedPattern < SymbolType >::UnrankedPattern ( SymbolType subtreeWildcard, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : alib::Components < UnrankedPattern, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
 	checkAlphabet ( m_content );
 }
 
@@ -233,7 +233,7 @@ alib::ObjectBase* UnrankedPattern < SymbolType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< ::tree::UnrankedPattern < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
@@ -262,6 +262,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* UNRANKED_PATTERN_H_ */
diff --git a/alib2data/src/tree/unranked/UnrankedTree.h b/alib2data/src/tree/unranked/UnrankedTree.h
index 8fc4c752b3d3310f093aae6005a16827375c75bd..9031b747e5280fecb8ba3ec60eef8db88785c012 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.h
+++ b/alib2data/src/tree/unranked/UnrankedTree.h
@@ -36,7 +36,7 @@ class GeneralAlphabet;
  * as a tree of RegExpElement.
  */
 template < class SymbolType >
-class UnrankedTree final : public UnrankedTreeBase, public std::Components < UnrankedTree < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class UnrankedTree final : public UnrankedTreeBase, public alib::Components < UnrankedTree < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	std::tree < SymbolType > m_content;
 
 	void checkAlphabet ( const std::tree < SymbolType > & pattern ) const;
@@ -127,7 +127,7 @@ public:
 namespace tree {
 
 template < class SymbolType >
-UnrankedTree < SymbolType >::UnrankedTree ( std::set < SymbolType > alphabet, std::tree < SymbolType > tree ) : std::Components < UnrankedTree, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_content ( std::move ( tree ) ) {
+UnrankedTree < SymbolType >::UnrankedTree ( std::set < SymbolType > alphabet, std::tree < SymbolType > tree ) : alib::Components < UnrankedTree, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_content ( std::move ( tree ) ) {
 	checkAlphabet ( m_content );
 }
 
@@ -225,7 +225,7 @@ alib::ObjectBase* UnrankedTree < SymbolType >::inc() && {
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < class SymbolType >
 class ComponentConstraint< ::tree::UnrankedTree < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
@@ -243,6 +243,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* UNRANKED_TREE_H_ */
diff --git a/alib2data_experimental/src/graph/Graph.h b/alib2data_experimental/src/graph/Graph.h
index 9694bf7746c93567b82bdb4d6b4d5460cc09b9f8..a0981ba822fc49aee522fbba3e41343ebcb96748 100644
--- a/alib2data_experimental/src/graph/Graph.h
+++ b/alib2data_experimental/src/graph/Graph.h
@@ -31,6 +31,6 @@ struct compare < graph::Graph > {
 
 };
 
-} // namespace
+} // namespace std
 
 #endif // GRAPH_H_
diff --git a/alib2data_experimental/src/indexes/suffixTrie/SuffixTrieTerminatingSymbol.cpp b/alib2data_experimental/src/indexes/suffixTrie/SuffixTrieTerminatingSymbol.cpp
index f2f1bdff320431f97c557f4c5322395ac3fb8fb5..9e99eac899a1256aa9e7ba25c11cbe567cfe3fb0 100644
--- a/alib2data_experimental/src/indexes/suffixTrie/SuffixTrieTerminatingSymbol.cpp
+++ b/alib2data_experimental/src/indexes/suffixTrie/SuffixTrieTerminatingSymbol.cpp
@@ -24,18 +24,18 @@ namespace indexes {
 SuffixTrieTerminatingSymbol::SuffixTrieTerminatingSymbol ( std::set < DefaultSymbolType > alphabet, DefaultSymbolType terminatingSymbol ) : SuffixTrieTerminatingSymbol ( std::move ( alphabet ), std::move ( terminatingSymbol ), SuffixTrieNodeTerminatingSymbol ( { } ) ) {
 }
 
-SuffixTrieTerminatingSymbol::SuffixTrieTerminatingSymbol ( std::set < DefaultSymbolType > alphabet, DefaultSymbolType terminatingSymbol, SuffixTrieNodeTerminatingSymbol tree ) : std::Components < SuffixTrieTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( terminatingSymbol ) ) ), m_tree ( NULL ) {
+SuffixTrieTerminatingSymbol::SuffixTrieTerminatingSymbol ( std::set < DefaultSymbolType > alphabet, DefaultSymbolType terminatingSymbol, SuffixTrieNodeTerminatingSymbol tree ) : alib::Components < SuffixTrieTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( terminatingSymbol ) ) ), m_tree ( NULL ) {
 	setTree ( std::move ( tree ) );
 }
 
 SuffixTrieTerminatingSymbol::SuffixTrieTerminatingSymbol ( DefaultSymbolType terminatingSymbol, SuffixTrieNodeTerminatingSymbol tree ) : SuffixTrieTerminatingSymbol ( tree.computeMinimalAlphabet ( ) + std::set < DefaultSymbolType > { terminatingSymbol }, terminatingSymbol, tree ) {
 }
 
-SuffixTrieTerminatingSymbol::SuffixTrieTerminatingSymbol ( const SuffixTrieTerminatingSymbol & other ) : std::Components < SuffixTrieTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( other.getAlphabet ( ) ), std::make_tuple ( other.getTerminatingSymbol ( ) ) ), m_tree ( other.m_tree->clone ( ) ) {
+SuffixTrieTerminatingSymbol::SuffixTrieTerminatingSymbol ( const SuffixTrieTerminatingSymbol & other ) : alib::Components < SuffixTrieTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( other.getAlphabet ( ) ), std::make_tuple ( other.getTerminatingSymbol ( ) ) ), m_tree ( other.m_tree->clone ( ) ) {
 	this->m_tree->attachTree ( this );
 }
 
-SuffixTrieTerminatingSymbol::SuffixTrieTerminatingSymbol ( SuffixTrieTerminatingSymbol && other ) noexcept : std::Components < SuffixTrieTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < TerminatingSymbol > ( ).get ( ) ) ) ), m_tree ( other.m_tree ) {
+SuffixTrieTerminatingSymbol::SuffixTrieTerminatingSymbol ( SuffixTrieTerminatingSymbol && other ) noexcept : alib::Components < SuffixTrieTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < TerminatingSymbol > ( ).get ( ) ) ) ), m_tree ( other.m_tree ) {
 	this->m_tree->attachTree ( this );
 	other.m_tree = NULL;
 }
diff --git a/alib2data_experimental/src/indexes/suffixTrie/SuffixTrieTerminatingSymbol.h b/alib2data_experimental/src/indexes/suffixTrie/SuffixTrieTerminatingSymbol.h
index e6f2a531d45bbe0302c8718d747b99972d8f462e..400625bd7cb0c2703a9542d7ac9181e4f0cb59f0 100644
--- a/alib2data_experimental/src/indexes/suffixTrie/SuffixTrieTerminatingSymbol.h
+++ b/alib2data_experimental/src/indexes/suffixTrie/SuffixTrieTerminatingSymbol.h
@@ -25,7 +25,7 @@ class TerminatingSymbol;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of RegExpElement.
  */
-class SuffixTrieTerminatingSymbol final : public alib::ObjectBase, public std::Components < SuffixTrieTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > {
+class SuffixTrieTerminatingSymbol final : public alib::ObjectBase, public alib::Components < SuffixTrieTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > {
 protected:
 	SuffixTrieNodeTerminatingSymbol * m_tree;
 
@@ -118,7 +118,7 @@ public:
 
 } /* namespace tree */
 
-namespace std {
+namespace alib {
 
 template < >
 class ComponentConstraint< indexes::SuffixTrieTerminatingSymbol, DefaultSymbolType, indexes::GeneralAlphabet > {
@@ -146,6 +146,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* SUFFIX_TRIE_TERMINATING_SYMBOL_H_ */
diff --git a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp
index 018cc143ee08495266b5e29c7b37442061824769..6a3984bce722b8c2bf95682b99e9a2c26ad19f0b 100644
--- a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp
+++ b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.cpp
@@ -23,7 +23,7 @@
 
 namespace string {
 
-LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( std::set < DefaultSymbolType > alphabet, DefaultSymbolType terminatingSymbol, std::vector < DefaultSymbolType > data ) : std::Components < LinearStringTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( terminatingSymbol ) ) ) {
+LinearStringTerminatingSymbol::LinearStringTerminatingSymbol ( std::set < DefaultSymbolType > alphabet, DefaultSymbolType terminatingSymbol, std::vector < DefaultSymbolType > data ) : alib::Components < LinearStringTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( terminatingSymbol ) ) ) {
 	setContent ( std::move ( data ) );
 }
 
diff --git a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
index c380fa4ae3bd21728890e385da3f142c2cb72d5d..64f0d2dd04285afd78940ce143a929d868e5c46b 100644
--- a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
+++ b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
@@ -27,7 +27,7 @@ class TerminatingSymbol;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class LinearStringTerminatingSymbol final : public StringBase, public std::Components < LinearStringTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > {
+class LinearStringTerminatingSymbol final : public StringBase, public alib::Components < LinearStringTerminatingSymbol, DefaultSymbolType, std::tuple < GeneralAlphabet >, std::tuple < TerminatingSymbol > > {
 	std::vector < DefaultSymbolType > m_Data;
 
 public:
@@ -101,7 +101,7 @@ public:
 
 } /* namespace string */
 
-namespace std {
+namespace alib {
 
 template < >
 class ComponentConstraint< ::string::LinearStringTerminatingSymbol, DefaultSymbolType, ::string::GeneralAlphabet > {
@@ -130,6 +130,6 @@ public:
 	}
 };
 
-} /* namespace std */
+} /* namespace alib */
 
 #endif /* LINEAR_STRING_TERMINATING_SYMBOL_H_ */