diff --git a/alib2algo/src/automaton/convert/ToGrammar.h b/alib2algo/src/automaton/convert/ToGrammar.h
index ecc050680c7fbf59fb3019915f3ed0ae3861cd68..c0def5d6df19433299564afe08c78597400ce06a 100644
--- a/alib2algo/src/automaton/convert/ToGrammar.h
+++ b/alib2algo/src/automaton/convert/ToGrammar.h
@@ -21,6 +21,8 @@ namespace convert {
 
 class ToGrammar : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	ToGrammar() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/automaton/convert/ToGrammarLeftRG.h b/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
index 26e7f96752801e4e64d3172026879e10694fb0b7..462d4bf8663d8f828db16296d98b18f38bce7f68 100644
--- a/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
+++ b/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
@@ -25,6 +25,8 @@ namespace convert {
  */
 class ToGrammarLeftRG : public automaton::VisitableConstFSMBase {
 public:
+	ToGrammarLeftRG() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
@@ -35,6 +37,8 @@ public:
 	static grammar::LeftRG convert(const automaton::DFA& automaton);
 
 private:
+	using automaton::VisitableConstFSMBase::Visit;
+
 	void Visit(void*, const automaton::EpsilonNFA& automaton) const;
 	void Visit(void*, const automaton::MultiInitialStateNFA& automaton) const;
 	void Visit(void*, const automaton::NFA& automaton) const;
diff --git a/alib2algo/src/automaton/convert/ToGrammarRightRG.h b/alib2algo/src/automaton/convert/ToGrammarRightRG.h
index 448e32e38cb9f9282e733e859da2a37484020b57..4807e826c606e26025e5d4cbb8d70084e7684719 100644
--- a/alib2algo/src/automaton/convert/ToGrammarRightRG.h
+++ b/alib2algo/src/automaton/convert/ToGrammarRightRG.h
@@ -25,6 +25,8 @@ namespace convert {
  */
 class ToGrammarRightRG : public automaton::VisitableConstFSMBase {
 public:
+	ToGrammarRightRG() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
@@ -35,6 +37,8 @@ public:
 	static grammar::RightRG convert(const automaton::DFA& automaton);
 
 private:
+	using automaton::VisitableConstFSMBase::Visit;
+
 	void Visit(void*, const automaton::EpsilonNFA& automaton) const;
 	void Visit(void*, const automaton::MultiInitialStateNFA& automaton) const;
 	void Visit(void*, const automaton::NFA& automaton) const;
diff --git a/alib2algo/src/automaton/convert/ToRegExp.h b/alib2algo/src/automaton/convert/ToRegExp.h
index 3718c38af0b436c463bba249566c8f84f7e26a47..a50bcdfbcde10cb06f1550136159aafe80fc6aba 100644
--- a/alib2algo/src/automaton/convert/ToRegExp.h
+++ b/alib2algo/src/automaton/convert/ToRegExp.h
@@ -22,6 +22,8 @@ namespace convert {
 
 class ToRegExp  : public automaton::VisitableConstFSMBase {
 public:
+	ToRegExp() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
@@ -29,6 +31,8 @@ public:
 	static regexp::RegExp convert(const automaton::Automaton& automaton);
 
 private:
+	using automaton::VisitableConstFSMBase::Visit;
+
 	void Visit(void*, const EpsilonNFA& automaton) const;
 	void Visit(void*, const MultiInitialStateNFA& automaton) const;
 	void Visit(void*, const NFA& automaton) const;
diff --git a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h
index 54d1f89f7bf7c424d2b0d1033c7dc49c4b6b408b..dd158a7893571974fee8c9976f7d43d5a83ee4b4 100644
--- a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h
+++ b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h
@@ -29,6 +29,8 @@ namespace convert {
  */
 class ToRegExpAlgebraic : public automaton::VisitableConstFSMBase {
 public:
+	ToRegExpAlgebraic() {}
+
 	/**
 	 * Performs conversion.
 	 * @return regular expression equivalent to input automaton.
@@ -41,6 +43,8 @@ public:
 	static regexp::UnboundedRegExp convert(const automaton::DFA& automaton);
 
 private:
+	using automaton::VisitableConstFSMBase::Visit;
+
 	void Visit(void*, const automaton::EpsilonNFA&) const;
 	void Visit(void*, const automaton::MultiInitialStateNFA&) const;
 	void Visit(void*, const automaton::NFA&) const;
diff --git a/alib2algo/src/automaton/convert/ToRegExpStateElimination.h b/alib2algo/src/automaton/convert/ToRegExpStateElimination.h
index f11cd297928a127670375bbef134fc5029613df4..5a7962995b4e51286f927ee46d9b4656d320c0d5 100644
--- a/alib2algo/src/automaton/convert/ToRegExpStateElimination.h
+++ b/alib2algo/src/automaton/convert/ToRegExpStateElimination.h
@@ -28,6 +28,8 @@ namespace convert {
  */
 class ToRegExpStateElimination : public automaton::VisitableConstFSMBase {
 public:
+	ToRegExpStateElimination() {}
+
 	/**
 	 * Performs conversion.
 	 * @param automaton automaton to convert
@@ -39,6 +41,8 @@ public:
 	static regexp::RegExp convert(const T& automaton);
 
 private:
+	using automaton::VisitableConstFSMBase::Visit;
+
 	void Visit(void*, const automaton::EpsilonNFA& automaton) const;
 	void Visit(void*, const automaton::MultiInitialStateNFA& automaton) const;
 	void Visit(void*, const automaton::NFA& automaton) const;
diff --git a/alib2algo/src/automaton/determinize/Determinize.h b/alib2algo/src/automaton/determinize/Determinize.h
index 94f936c5f084021345dc073ca89e2ff8522c648c..ef939cbe808461d8fc8eb3e1e8356f42e17fa8f1 100644
--- a/alib2algo/src/automaton/determinize/Determinize.h
+++ b/alib2algo/src/automaton/determinize/Determinize.h
@@ -31,6 +31,9 @@ namespace determinize {
  * Class for running determinization algorithm on fsm.
  */
 class Determinize : public automaton::VisitableAutomatonBase::const_visitor_type {
+public:
+	Determinize() {}
+
 private:
 	void Visit(void*, const automaton::EpsilonNFA& automaton) const;
 	void Visit(void*, const automaton::MultiInitialStateNFA& automaton) const;
diff --git a/alib2algo/src/automaton/properties/AllEpsilonClosure.h b/alib2algo/src/automaton/properties/AllEpsilonClosure.h
index c7fc6bfeed590b44aa0307418d9809ca26997d9d..f3aecf94ca2e84f0f7fa227e543ce1222a1e70b7 100644
--- a/alib2algo/src/automaton/properties/AllEpsilonClosure.h
+++ b/alib2algo/src/automaton/properties/AllEpsilonClosure.h
@@ -20,6 +20,8 @@ namespace properties {
 
 class AllEpsilonClosure : public VisitableAutomatonBase::const_visitor_type {
 public:
+	AllEpsilonClosure() {}
+
 	static std::map<automaton::State, std::set<automaton::State>> allEpsilonClosure( const automaton::Automaton & automaton);
 
 	/**
diff --git a/alib2algo/src/automaton/properties/EpsilonClosure.h b/alib2algo/src/automaton/properties/EpsilonClosure.h
index f2dd9f8ab967b0e6f11fdfeafc5745099f32e7b3..fc055dd8b967701a77a26624e97e8491550e83e0 100644
--- a/alib2algo/src/automaton/properties/EpsilonClosure.h
+++ b/alib2algo/src/automaton/properties/EpsilonClosure.h
@@ -21,6 +21,7 @@ namespace properties {
 
 class EpsilonClosure : public VisitableAutomatonBase::const_visitor_type {
 public:
+	EpsilonClosure() {}
 	static std::set<automaton::State> epsilonClosure( const automaton::Automaton & automaton, const automaton::State & state );
 
 	/**
diff --git a/alib2algo/src/automaton/properties/ReachableStates.h b/alib2algo/src/automaton/properties/ReachableStates.h
index 88ede0f89d0eb7c0e91aa813b572da989ca1a319..aee2eaff8e83177e771003033c61e5ec41041c8e 100644
--- a/alib2algo/src/automaton/properties/ReachableStates.h
+++ b/alib2algo/src/automaton/properties/ReachableStates.h
@@ -21,6 +21,8 @@ namespace properties {
 
 class ReachableStates : public VisitableAutomatonBase::const_visitor_type {
 public:
+	ReachableStates() {}
+
 	static std::set<automaton::State> reachableStates( const automaton::Automaton & automaton );
 
 	/**
diff --git a/alib2algo/src/automaton/properties/UsefullStates.h b/alib2algo/src/automaton/properties/UsefullStates.h
index 3fa2b58735497d7ebd893cdb24439bd44f52e83e..d58b7e861b0ff575eedc29c5f187089e4f71b61a 100644
--- a/alib2algo/src/automaton/properties/UsefullStates.h
+++ b/alib2algo/src/automaton/properties/UsefullStates.h
@@ -21,6 +21,8 @@ namespace properties {
 
 class UsefullStates : public VisitableAutomatonBase::const_visitor_type {
 public:
+	UsefullStates() {}
+
 	static std::set<automaton::State> usefullStates( const automaton::Automaton & automaton );
 
 	/**
diff --git a/alib2algo/src/automaton/run/Accept.h b/alib2algo/src/automaton/run/Accept.h
index ed451178ce363eaddf8d5d975179f2e639eedbc0..e8cb279368f17659c573266c3da6d16361ebf900 100644
--- a/alib2algo/src/automaton/run/Accept.h
+++ b/alib2algo/src/automaton/run/Accept.h
@@ -19,6 +19,8 @@ namespace run {
 
 class Accept : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	Accept() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/automaton/run/Occurrences.h b/alib2algo/src/automaton/run/Occurrences.h
index dc15fb58485991fa00f81e2117c77ce6382e25ee..4f838ee55e4dc6f2a7827d9189e47e91efe64c19 100644
--- a/alib2algo/src/automaton/run/Occurrences.h
+++ b/alib2algo/src/automaton/run/Occurrences.h
@@ -19,6 +19,8 @@ namespace run {
 
 class Occurrences : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	Occurrences() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/automaton/run/Result.h b/alib2algo/src/automaton/run/Result.h
index acdebc95b55c449b71ec25851149afb401cfa7ed..29aac2185d5981c59b0d5a3132db37e0be796323 100644
--- a/alib2algo/src/automaton/run/Result.h
+++ b/alib2algo/src/automaton/run/Result.h
@@ -20,6 +20,8 @@ namespace run {
 
 class Result : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	Result() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h b/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h
index 8a79bb5d25ab83abcabb847f2aab047d39fb6aa8..fc96737d3d66884b9259733acb6854af6b9f34cf 100644
--- a/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h
+++ b/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.h
@@ -25,6 +25,8 @@ namespace simplify {
 
 class EpsilonRemoverIncoming : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	EpsilonRemoverIncoming() {}
+
 	static automaton::Automaton remove( const automaton::Automaton & automaton );
 
 	/**
diff --git a/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.h b/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.h
index e76b99a711172295f2b4512593c6c821202df102..99666202097e786787661b457fa081adcdecdae1 100644
--- a/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.h
+++ b/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.h
@@ -25,6 +25,8 @@ namespace simplify {
 
 class EpsilonRemoverOutgoing : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	EpsilonRemoverOutgoing() {}
+
 	static automaton::Automaton remove( const automaton::Automaton & automaton );
 
 	/**
diff --git a/alib2algo/src/automaton/simplify/Minimize.h b/alib2algo/src/automaton/simplify/Minimize.h
index d71753aa99a1d7c3896ee84e636b1444a3a24adc..0d2de230121e84734ef47272ed9f65d588848877 100644
--- a/alib2algo/src/automaton/simplify/Minimize.h
+++ b/alib2algo/src/automaton/simplify/Minimize.h
@@ -17,6 +17,8 @@ namespace simplify {
 
 class Minimize : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	Minimize() {}
+
 	/**
 	 * @param dfa automaton to minimize
 	 */
diff --git a/alib2algo/src/automaton/simplify/MinimizeBrzozowski.h b/alib2algo/src/automaton/simplify/MinimizeBrzozowski.h
index c21dc2d49b4ea58cac444d820cf6535943f6c319..4d21d0d19ebf9fdb6ed8a0517b1cca2827c1d497 100644
--- a/alib2algo/src/automaton/simplify/MinimizeBrzozowski.h
+++ b/alib2algo/src/automaton/simplify/MinimizeBrzozowski.h
@@ -17,6 +17,8 @@ namespace simplify {
 
 class MinimizeBrzozowski : public automaton::VisitableConstFSMBase {
 public:
+	MinimizeBrzozowski() {}
+
 	/**
 	 * @param dfa automaton to minimize
 	 */
@@ -26,6 +28,8 @@ public:
 	static automaton::DFA minimize(const automaton::NFA& nfa);
 
 protected:
+	using automaton::VisitableConstFSMBase::Visit;
+
 	void Visit(void*, const automaton::EpsilonNFA& automaton) const;
 	void Visit(void*, const automaton::MultiInitialStateNFA& automaton) const;
 	void Visit(void*, const automaton::NFA& automaton) const;
diff --git a/alib2algo/src/automaton/simplify/Normalize.h b/alib2algo/src/automaton/simplify/Normalize.h
index 791ae5a70dcb913b5c1e38913f68746076ebda4e..25c8b05279de248649df63217003f7cbd271970a 100644
--- a/alib2algo/src/automaton/simplify/Normalize.h
+++ b/alib2algo/src/automaton/simplify/Normalize.h
@@ -18,6 +18,8 @@ namespace simplify {
 
 class Normalize : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	Normalize() {}
+
 	/**
 	 * @param dfa automaton to normalize
 	 */
diff --git a/alib2algo/src/automaton/simplify/Rename.h b/alib2algo/src/automaton/simplify/Rename.h
index 9312f94ed88010759c627c3e577867aaddbe496b..55f9efac918ffb82f2f35de16763fe8752d01a17 100644
--- a/alib2algo/src/automaton/simplify/Rename.h
+++ b/alib2algo/src/automaton/simplify/Rename.h
@@ -22,6 +22,8 @@ namespace simplify {
 
 class Rename : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	Rename() {}
+
 	/**
 	 * @param dfa automaton to rename
 	 */
diff --git a/alib2algo/src/automaton/simplify/SingleInitialState.h b/alib2algo/src/automaton/simplify/SingleInitialState.h
index 881fe3526979ce7f2ac7b7a9e0540f7e92c13f30..e15fb9637087cab972a09b7ac5bedf941789783c 100644
--- a/alib2algo/src/automaton/simplify/SingleInitialState.h
+++ b/alib2algo/src/automaton/simplify/SingleInitialState.h
@@ -21,6 +21,8 @@ namespace simplify {
  */
 class SingleInitialState : public VisitableAutomatonBase::const_visitor_type {
 public:
+	SingleInitialState() {}
+
 	/**
 	 * Computes epsilon closure of a state in epsilon nonfree automaton
 	 */
diff --git a/alib2algo/src/automaton/simplify/Total.h b/alib2algo/src/automaton/simplify/Total.h
index 9730b0b96e28ad005665707d71f2d285695f75e1..10f817895d5ea1bc632ed83c81d5bc1dd588089c 100644
--- a/alib2algo/src/automaton/simplify/Total.h
+++ b/alib2algo/src/automaton/simplify/Total.h
@@ -23,8 +23,10 @@ namespace simplify {
  * Makes finite automaton's transition function total.
  * Source: Melichar: Algorithm 2.22
  */
-class Total : public VisitableConstFSMBase {
+class Total : public automaton::VisitableConstFSMBase {
 public:
+	Total() {}
+
 	/**
 	 * Computes epsilon closure of a state in epsilon nonfree automaton
 	 */
@@ -34,6 +36,8 @@ public:
 	static automaton::DFA total(const automaton::DFA& automaton);
 
 private:
+	using automaton::VisitableConstFSMBase::Visit;
+
 	void Visit(void*, const EpsilonNFA& automaton) const;
 	void Visit(void*, const MultiInitialStateNFA& automaton) const;
 	void Visit(void*, const NFA& automaton) const;
diff --git a/alib2algo/src/automaton/simplify/Trim.h b/alib2algo/src/automaton/simplify/Trim.h
index 2cb8fd2b5f787513f4316e51a525f35b195411e3..2cd0c10aea99b0e0a9a34d142053471b0a427b13 100644
--- a/alib2algo/src/automaton/simplify/Trim.h
+++ b/alib2algo/src/automaton/simplify/Trim.h
@@ -6,7 +6,7 @@
  */
 
 #ifndef AUTOMATON_TRIM_H_
-#define AUTOMAONT_TRIM_H_
+#define AUTOMATON_TRIM_H_
 
 #include <algorithm>
 #include <deque>
@@ -19,6 +19,7 @@ namespace simplify {
 
 class Trim : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	Trim() {}
 	static automaton::Automaton trim( const automaton::Automaton & automaton );
 
 	/**
diff --git a/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h b/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h
index b584132ddac6947a1a59cf348df23a18310de6c3..9a7877f3f3a5b0b316e32960a15b014b34866e1b 100644
--- a/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h
+++ b/alib2algo/src/automaton/simplify/UnreachableStatesRemover.h
@@ -19,6 +19,8 @@ namespace simplify {
 
 class UnreachableStatesRemover : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	UnreachableStatesRemover() {}
+
 	static automaton::Automaton remove( const automaton::Automaton & automaton );
 
 	/**
diff --git a/alib2algo/src/automaton/simplify/UselessStatesRemover.h b/alib2algo/src/automaton/simplify/UselessStatesRemover.h
index 38c86626323929881f93da667a1eccec50ad6bee..1b18987c3017a4e62f99f506694dc114c38c15fa 100644
--- a/alib2algo/src/automaton/simplify/UselessStatesRemover.h
+++ b/alib2algo/src/automaton/simplify/UselessStatesRemover.h
@@ -19,6 +19,8 @@ namespace simplify {
 
 class UselessStatesRemover : public automaton::VisitableAutomatonBase::const_visitor_type {
 public:
+	UselessStatesRemover() {}
+
 	static automaton::Automaton remove( const automaton::Automaton & automaton );
 
 	/**
diff --git a/alib2algo/src/automaton/transform/AutomataConcatenation.h b/alib2algo/src/automaton/transform/AutomataConcatenation.h
index fb4cdda014b8f27890ba6e296c569e22997e8ca0..dc1dd54b3f2106e8d26637b5c88bb2b46e41a996 100644
--- a/alib2algo/src/automaton/transform/AutomataConcatenation.h
+++ b/alib2algo/src/automaton/transform/AutomataConcatenation.h
@@ -24,6 +24,8 @@ namespace transform
 class AutomataConcatenation : public automaton::VisitableAutomatonBase::const_promoting_visitor_type
 {
 public:
+	AutomataConcatenation() {}
+
 	static automaton::Automaton concatenation(const automaton::Automaton& first, const automaton::Automaton& second);
 
 	static automaton::NFA concatenation(const automaton::DFA& first, const automaton::DFA& second);
diff --git a/alib2algo/src/automaton/transform/AutomataConcatenationEpsilonTransition.h b/alib2algo/src/automaton/transform/AutomataConcatenationEpsilonTransition.h
index 133b493f7a97ade53c498beb1efb217b31b96664..e8b27489db606020dd0a82e3881a3d0a89909063 100644
--- a/alib2algo/src/automaton/transform/AutomataConcatenationEpsilonTransition.h
+++ b/alib2algo/src/automaton/transform/AutomataConcatenationEpsilonTransition.h
@@ -24,6 +24,8 @@ namespace transform
 class AutomataConcatenationEpsilonTransition : public automaton::VisitableAutomatonBase::const_promoting_visitor_type
 {
 public:
+	AutomataConcatenationEpsilonTransition() {}
+
 	static automaton::Automaton concatenation(const automaton::Automaton& first, const automaton::Automaton& second);
 
 	static automaton::EpsilonNFA concatenation(const automaton::DFA& first, const automaton::DFA& second);
diff --git a/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.h b/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.h
index 2369fda445bb5cbdf07f0be6790e02aebe5b03cf..5cba54c245c7974f97676078cb0059a4d7861dc2 100644
--- a/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.h
+++ b/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.h
@@ -24,6 +24,8 @@ namespace transform
 class AutomataIntersectionCartesianProduct : public automaton::VisitableAutomatonBase::const_promoting_visitor_type
 {
 public:
+	AutomataIntersectionCartesianProduct() {}
+
 	static automaton::Automaton intersection(const automaton::Automaton& first, const automaton::Automaton& second);
 
 	static automaton::NFA intersection(const automaton::NFA& first, const automaton::NFA& second);
diff --git a/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.h b/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.h
index 424f6f39d85c29b6994fd9e73146321b0db3ff1a..a06aed29c39046166d46ba32300bf4256b253e22 100644
--- a/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.h
+++ b/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.h
@@ -24,6 +24,8 @@ namespace transform
 class AutomataUnionCartesianProduct : public automaton::VisitableAutomatonBase::const_promoting_visitor_type
 {
 public:
+	AutomataUnionCartesianProduct() {}
+
 	static automaton::Automaton unification(const automaton::Automaton& first, const automaton::Automaton& second);
 
 	static automaton::NFA unification(const automaton::NFA& first, const automaton::NFA& second);
diff --git a/alib2algo/src/automaton/transform/AutomataUnionEpsilonTransition.h b/alib2algo/src/automaton/transform/AutomataUnionEpsilonTransition.h
index 7a79873aed1bf7987877b4fcc1f758ef4ab5e265..c367d1d76a7607dc51992ba2fcc4e24839ceabd2 100644
--- a/alib2algo/src/automaton/transform/AutomataUnionEpsilonTransition.h
+++ b/alib2algo/src/automaton/transform/AutomataUnionEpsilonTransition.h
@@ -24,6 +24,8 @@ namespace transform
 class AutomataUnionEpsilonTransition : public automaton::VisitableAutomatonBase::const_promoting_visitor_type
 {
 public:
+	AutomataUnionEpsilonTransition() {}
+
 	static automaton::Automaton unification(const automaton::Automaton& first, const automaton::Automaton& second);
 
 	static automaton::EpsilonNFA unification(const automaton::EpsilonNFA& first, const automaton::EpsilonNFA& second);
diff --git a/alib2algo/src/automaton/transform/AutomatonIteration.h b/alib2algo/src/automaton/transform/AutomatonIteration.h
index 1a7646abd8fdb1202a783b54f937f28b9bd6922b..fb7d2728e817282db4d4330aeb23622f952235e5 100644
--- a/alib2algo/src/automaton/transform/AutomatonIteration.h
+++ b/alib2algo/src/automaton/transform/AutomatonIteration.h
@@ -24,6 +24,8 @@ namespace transform
 class AutomatonIteration : public automaton::VisitableAutomatonBase::const_visitor_type
 {
 public:
+	AutomatonIteration() {}
+
 	static automaton::Automaton iteration(const automaton::Automaton& automaton);
 
 	template<class T>
diff --git a/alib2algo/src/automaton/transform/AutomatonIterationEpsilonTransition.h b/alib2algo/src/automaton/transform/AutomatonIterationEpsilonTransition.h
index 80cf82296d5f3c462c96f877fc88f34216e3c15b..307d6c55fec5f115acaedb1d6f9d4e152bdfe2d2 100644
--- a/alib2algo/src/automaton/transform/AutomatonIterationEpsilonTransition.h
+++ b/alib2algo/src/automaton/transform/AutomatonIterationEpsilonTransition.h
@@ -24,6 +24,8 @@ namespace transform
 class AutomatonIterationEpsilonTransition : public automaton::VisitableAutomatonBase::const_visitor_type
 {
 public:
+	AutomatonIterationEpsilonTransition() {}
+
 	static automaton::Automaton iteration(const automaton::Automaton& automaton);
 
 	template<class T>
diff --git a/alib2algo/src/automaton/transform/Compaction.h b/alib2algo/src/automaton/transform/Compaction.h
index 520ad9a028d9dfb1f26b97bcfdb061a97e8a0066..e0da50de241a9bc60a33b67112a9e0b779552c99 100644
--- a/alib2algo/src/automaton/transform/Compaction.h
+++ b/alib2algo/src/automaton/transform/Compaction.h
@@ -17,8 +17,10 @@ namespace transform {
 /**
  * Transforms FSM to CompactNFA
  */
-class Compaction : public VisitableConstFSMBase {
+class Compaction : public automaton::VisitableConstFSMBase {
 public:
+	Compaction() {}
+
 	static automaton::CompactNFA convert( const automaton::DFA& automaton);
 	static automaton::CompactNFA convert( const automaton::NFA& automaton);
 	static automaton::CompactNFA convert( const automaton::CompactNFA& automaton);
@@ -31,6 +33,8 @@ public:
 	static automaton::Automaton convert( const automaton::Automaton & automaton );
 
 private:
+	using automaton::VisitableConstFSMBase::Visit;
+
 	void Visit(void*, const CompactNFA& automaton) const;
 	void Visit(void*, const DFA& automaton) const;
 	void Visit(void*, const EpsilonNFA& automaton) const;
diff --git a/alib2algo/src/automaton/transform/PDAToRHPDA.h b/alib2algo/src/automaton/transform/PDAToRHPDA.h
index d0fa1a715a2064c600dd7510554fa09224784da6..504043797daf98e566db46c2b6bde0b94ef5707b 100644
--- a/alib2algo/src/automaton/transform/PDAToRHPDA.h
+++ b/alib2algo/src/automaton/transform/PDAToRHPDA.h
@@ -17,8 +17,10 @@
 
 namespace automaton {
 
-class PDAToRHPDA : public VisitableConstPDABase {
+class PDAToRHPDA : public automaton::VisitableConstPDABase {
 public:
+	PDAToRHPDA() {}
+
 	static automaton::RealTimeHeightDeterministicDPDA convert( const automaton::RealTimeHeightDeterministicDPDA & pda);
 	static automaton::RealTimeHeightDeterministicDPDA convert( const automaton::DPDA & pda);
 	static automaton::RealTimeHeightDeterministicNPDA convert( const automaton::RealTimeHeightDeterministicNPDA & pda);
@@ -29,6 +31,8 @@ public:
 	 */
 	static automaton::Automaton convert( const automaton::Automaton & automaton );
 private:
+	using automaton::VisitableConstPDABase::Visit;
+
 	void Visit(void*, const DPDA& automaton) const;
 	void Visit(void*, const SinglePopDPDA& automaton) const;
 	void Visit(void*, const InputDrivenNPDA& automaton) const;
diff --git a/alib2algo/src/automaton/transform/RHPDAToPDA.h b/alib2algo/src/automaton/transform/RHPDAToPDA.h
index ece6eb275c7a9d454e2c199ae851768d92c259af..fe256487c7f6c94c17e5e61c22a381bdcecbcbe1 100644
--- a/alib2algo/src/automaton/transform/RHPDAToPDA.h
+++ b/alib2algo/src/automaton/transform/RHPDAToPDA.h
@@ -19,6 +19,8 @@ namespace automaton {
 
 class RHPDAToPDA : public VisitableConstPDABase {
 public:
+	RHPDAToPDA() {}
+
 	static automaton::DPDA convert( const automaton::RealTimeHeightDeterministicDPDA & pda);
 	static automaton::DPDA convert( const automaton::DPDA & pda);
 	static automaton::NPDA convert( const automaton::RealTimeHeightDeterministicNPDA & pda);
@@ -29,6 +31,8 @@ public:
 	 */
 	static automaton::Automaton convert( const automaton::Automaton & automaton );
 private:
+	using automaton::VisitableConstPDABase::Visit;
+
 	void Visit(void*, const DPDA& automaton) const;
 	void Visit(void*, const SinglePopDPDA& automaton) const;
 	void Visit(void*, const InputDrivenDPDA& automaton) const;
diff --git a/alib2algo/src/automaton/transform/Reverse.h b/alib2algo/src/automaton/transform/Reverse.h
index c8528d90914f15519223edd47a938594d600293b..de596f31a57f36796de46706a8c937e00e6532a5 100644
--- a/alib2algo/src/automaton/transform/Reverse.h
+++ b/alib2algo/src/automaton/transform/Reverse.h
@@ -15,8 +15,10 @@ namespace automaton {
 
 namespace transform {
 
-class Reverse : public VisitableConstFSMBase {
+class Reverse : public automaton::VisitableConstFSMBase {
 public:
+	Reverse() {}
+
 	static automaton::MultiInitialStateNFA convert(const automaton::DFA& automaton);
 	static automaton::MultiInitialStateNFA convert(const automaton::NFA& automaton);
 	static automaton::MultiInitialStateNFA convert(const automaton::MultiInitialStateNFA& automaton);
@@ -28,6 +30,8 @@ public:
 	 */
 	static automaton::Automaton convert( const automaton::Automaton & automaton );
 private:
+	using automaton::VisitableConstFSMBase::Visit;
+
 	void Visit(void*, const DFA& automaton) const;
 	void Visit(void*, const NFA& automaton) const;
 	void Visit(void*, const MultiInitialStateNFA& automaton) const;
diff --git a/alib2algo/src/common/StringContainerConverter.hpp b/alib2algo/src/common/StringContainerConverter.hpp
index e37a80ef87ba27b3dff31632643a7e6eaccc441e..ec62386e920daeca60e7afb07e666669df26779a 100644
--- a/alib2algo/src/common/StringContainerConverter.hpp
+++ b/alib2algo/src/common/StringContainerConverter.hpp
@@ -23,6 +23,8 @@ namespace common {
 template<class R, class S, class T>
 class StringContainerConverter : public string::VisitableStringBase::const_visitor_type {
 public:
+	StringContainerConverter() {}
+
 	/**
 	 * Performs conversion from contaier<String> to container<T>.
 	 * @return container<T>.
@@ -61,7 +63,7 @@ inline void VisitHelper(void* data, const string::Epsilon& text) {
 
 template<class R, class S, class T,
 	typename std::enable_if< ! std::is_constructible<T, string::Epsilon>::value >::type* = nullptr >
-inline void VisitHelper(void* data, const string::Epsilon& text) {
+inline void VisitHelper(void*, const string::Epsilon&) {
 	throw exception::AlibException("Unsupported string type Epsilon");
 }
 
@@ -81,7 +83,7 @@ inline void VisitHelper(void* data, const string::LinearString& text) {
 
 template<class R, class S, class T,
 	typename std::enable_if< ! std::is_constructible<T, string::LinearString>::value >::type* = nullptr >
-inline void VisitHelper(void* data, const string::LinearString& text) {
+inline void VisitHelper(void*, const string::LinearString&) {
 	throw exception::AlibException("Unsupported string type LinearString");
 }
 
diff --git a/alib2algo/src/grammar/convert/ToAutomaton.h b/alib2algo/src/grammar/convert/ToAutomaton.h
index aeea0edfbc22db86bffd7dabf90e228e9088455c..4fba464c3556258633cc3f242df26fa0605bf128 100644
--- a/alib2algo/src/grammar/convert/ToAutomaton.h
+++ b/alib2algo/src/grammar/convert/ToAutomaton.h
@@ -25,6 +25,8 @@ namespace convert {
  */
 class ToAutomaton : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	ToAutomaton() {}
+
 	/**
 	 * Performs conversion.
 	 * @param grammar Regular grammar to convert.
diff --git a/alib2algo/src/grammar/convert/ToGrammarLeftRG.h b/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
index 58648f091a7eb5a12177d5a430586a270cc6a96b..19212cb58e9b16e04b0acd3f901ec9e86631a95e 100644
--- a/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
+++ b/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
@@ -2,7 +2,7 @@
  * ToGrammarLeftRG.h
  *
  *  Created on: 8. 3. 2014
- *      Author: Tomas Pecka
+ *	  Author: Tomas Pecka
  */
 
 #ifndef TO_GRAMMAR_LEFT_RG_H_
@@ -22,21 +22,25 @@ namespace convert {
 class ToGrammarLeftRG : public grammar::VisitableConstRGBase
 {
 public:
-    /**
-     * Performs conversion.
-     * @param grammar Right regular grammar to convert
-     * @return left regular grammar which is equivalent to source right regular grammar.
-     */
-    static grammar::LeftRG convert(const grammar::Grammar& grammar);
-    static grammar::LeftRG convert(const grammar::RightRG& grammar);
+	ToGrammarLeftRG() {}
+
+	/**
+	 * Performs conversion.
+	 * @param grammar Right regular grammar to convert
+	 * @return left regular grammar which is equivalent to source right regular grammar.
+	 */
+	static grammar::LeftRG convert(const grammar::Grammar& grammar);
+	static grammar::LeftRG convert(const grammar::RightRG& grammar);
 
 private:
-    void Visit(void*, const grammar::RightRG& grammar) const;
-    void Visit(void*, const grammar::LeftRG& grammar) const;
-    void Visit(void*, const grammar::RightLG& grammar) const;
-    void Visit(void*, const grammar::LeftLG& grammar) const;
+	using grammar::VisitableConstRGBase::Visit;
+
+	void Visit(void*, const grammar::RightRG& grammar) const;
+	void Visit(void*, const grammar::LeftRG& grammar) const;
+	void Visit(void*, const grammar::RightLG& grammar) const;
+	void Visit(void*, const grammar::LeftLG& grammar) const;
 
-    static const ToGrammarLeftRG TO_GRAMMAR_LEFT_RG;
+	static const ToGrammarLeftRG TO_GRAMMAR_LEFT_RG;
 };
 
 } /* namespace convert */
diff --git a/alib2algo/src/grammar/convert/ToGrammarRightRG.h b/alib2algo/src/grammar/convert/ToGrammarRightRG.h
index 468b72aa3a8fac45598d0d68ce16fafce45ab5af..99bc56b535c5559cfd72478d34c2a52ba19a35f6 100644
--- a/alib2algo/src/grammar/convert/ToGrammarRightRG.h
+++ b/alib2algo/src/grammar/convert/ToGrammarRightRG.h
@@ -2,7 +2,7 @@
  * ToGrammarRightRG.h
  *
  *  Created on: 8. 3. 2014
- *      Author: Tomas Pecka
+ *	  Author: Tomas Pecka
  */
 
 #ifndef TO_GRAMMAR_RIGHT_RG_H_
@@ -22,21 +22,25 @@ namespace convert {
 class ToGrammarRightRG : public grammar::VisitableConstRGBase
 {
 public:
-   /**
-     * Performs conversion.
-     * @param grammar Left regular grammar to convert
-     * @return right regular grammar which is equivalent to source left regular grammar.
-     */
-    static grammar::RightRG convert(const grammar::Grammar& grammar);
-    static grammar::RightRG convert(const grammar::LeftRG& grammar);
+	ToGrammarRightRG() {}
+
+	/**
+	 * Performs conversion.
+	 * @param grammar Left regular grammar to convert
+	 * @return right regular grammar which is equivalent to source left regular grammar.
+	 */
+	static grammar::RightRG convert(const grammar::Grammar& grammar);
+	static grammar::RightRG convert(const grammar::LeftRG& grammar);
 
 private:
-    void Visit(void*, const grammar::RightRG& grammar) const;
-    void Visit(void*, const grammar::LeftRG& grammar) const;
-    void Visit(void*, const grammar::RightLG& grammar) const;
-    void Visit(void*, const grammar::LeftLG& grammar) const;
+	using grammar::VisitableConstRGBase::Visit;
+
+	void Visit(void*, const grammar::RightRG& grammar) const;
+	void Visit(void*, const grammar::LeftRG& grammar) const;
+	void Visit(void*, const grammar::RightLG& grammar) const;
+	void Visit(void*, const grammar::LeftLG& grammar) const;
 
-    static const ToGrammarRightRG TO_GRAMMAR_RIGHT_RG;
+	static const ToGrammarRightRG TO_GRAMMAR_RIGHT_RG;
 };
 
 } /* namespace convert */
diff --git a/alib2algo/src/grammar/convert/ToRegExp.cpp b/alib2algo/src/grammar/convert/ToRegExp.cpp
index fe2696f7f470e2e5c5dd274ab6bd0b2e437d3339..7f6d8587dbe8d8f20f2acc01f0b88720479440b2 100644
--- a/alib2algo/src/grammar/convert/ToRegExp.cpp
+++ b/alib2algo/src/grammar/convert/ToRegExp.cpp
@@ -44,42 +44,6 @@ void ToRegExp::Visit(void*, const grammar::LeftLG&) const
 	throw exception::AlibException("Unsupported grammar type LeftLG");
 }
 
-void ToRegExp::Visit(void*, const grammar::LG& ) const {
-	throw exception::AlibException("Unsupported grammar type LG");
-}
-
-void ToRegExp::Visit(void*, const grammar::CFG& ) const {
-	throw exception::AlibException("Unsupported grammar type CFG");
-}
-
-void ToRegExp::Visit(void*, const grammar::EpsilonFreeCFG& ) const {
-	throw exception::AlibException("Unsupported grammar type EpsilonFreeCFG");
-}
-
-void ToRegExp::Visit(void*, const grammar::CNF& ) const {
-	throw exception::AlibException("Unsupported grammar type CFG");
-}
-
-void ToRegExp::Visit(void*, const grammar::GNF& ) const {
-	throw exception::AlibException("Unsupported grammar type GNF");
-}
-
-void ToRegExp::Visit(void*, const grammar::CSG&) const {
-	throw exception::AlibException("Unsupported grammar type CSG");
-}
-
-void ToRegExp::Visit(void*, const grammar::NonContractingGrammar&) const {
-	throw exception::AlibException("Unsupported grammar type NonConctractingGrammar");
-}
-
-void ToRegExp::Visit(void*, const grammar::ContextPreservingUnrestrictedGrammar&) const {
-	throw exception::AlibException("Unsupported grammar type ContextPreservingUnrestrictedGrammar");
-}
-
-void ToRegExp::Visit(void*, const grammar::UnrestrictedGrammar&) const {
-	throw exception::AlibException("Unsupported grammar type UnrestrictedGrammar");
-}
-
 const ToRegExp ToRegExp::TO_REG_EXP;
 
 } /* namespace convert */
diff --git a/alib2algo/src/grammar/convert/ToRegExp.h b/alib2algo/src/grammar/convert/ToRegExp.h
index aace07b45d5fbccc3876959de1977eed6b8900ba..02acd08001b9422798738a4dbf96400f1b97b53d 100644
--- a/alib2algo/src/grammar/convert/ToRegExp.h
+++ b/alib2algo/src/grammar/convert/ToRegExp.h
@@ -21,6 +21,8 @@ namespace convert {
 class ToRegExp : public grammar::VisitableConstRGBase
 {
 public:
+	ToRegExp() {}
+
 	/**
 	 * @return regexp equivalent to source right regular grammar.
 	 * @param grammar Grammar to convert
@@ -28,19 +30,12 @@ public:
 	static regexp::RegExp convert(const grammar::Grammar& grammar);
 
 protected:
+	using grammar::VisitableConstRGBase::Visit;
+
 	void Visit(void*, const grammar::RightRG& grammar) const;
 	void Visit(void*, const grammar::LeftRG& grammar) const;
 	void Visit(void*, const grammar::RightLG& grammar) const;
 	void Visit(void*, const grammar::LeftLG& grammar) const;
-	void Visit(void*, const grammar::LG& grammar) const;
-	void Visit(void*, const grammar::CFG& grammar) const;
-	void Visit(void*, const grammar::EpsilonFreeCFG& grammar) const;
-	void Visit(void*, const grammar::CNF& grammar) const;
-	void Visit(void*, const grammar::GNF& grammar) const;
-	void Visit(void*, const grammar::CSG& grammar) const;
-	void Visit(void*, const grammar::NonContractingGrammar& grammar) const;
-	void Visit(void*, const grammar::ContextPreservingUnrestrictedGrammar& grammar) const;
-	void Visit(void*, const grammar::UnrestrictedGrammar& grammar) const;
 
 	static const ToRegExp TO_REG_EXP;
 };
diff --git a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
index 3370fc3dfd51c874edf9cefb109710e21294ab74..ff75ab962bda3d9ae65f4ee24e9c1ccb2b694fff 100644
--- a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
+++ b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
@@ -2,7 +2,7 @@
  * ToRegExpAlgebraic.h
  *
  *  Created on: 4. 3. 2014
- *      Author: Tomas Pecka
+ *	  Author: Tomas Pecka
  */
 
 #ifndef GRAMMAR_TO_REG_EXP_ALGEBRAIC_H_
@@ -21,22 +21,26 @@ namespace convert {
 class ToRegExpAlgebraic : public grammar::VisitableConstRGBase
 {
 public:
-    /**
-     * @return regexp equivalent to source right regular grammar.
-     * @param grammar Grammar to convert
-     */
-    static regexp::RegExp convert(const grammar::Grammar& grammar);
+	ToRegExpAlgebraic() {}
 
-    static regexp::RegExp convert(const grammar::RightRG& grammar);
-    static regexp::RegExp convert(const grammar::LeftRG& grammar);
+	/**
+	 * @return regexp equivalent to source right regular grammar.
+	 * @param grammar Grammar to convert
+	 */
+	static regexp::RegExp convert(const grammar::Grammar& grammar);
+
+	static regexp::RegExp convert(const grammar::RightRG& grammar);
+	static regexp::RegExp convert(const grammar::LeftRG& grammar);
 
 protected:
-    void Visit(void*, const grammar::RightRG& grammar) const;
-    void Visit(void*, const grammar::LeftRG& grammar) const;
-    void Visit(void*, const grammar::RightLG& grammar) const;
-    void Visit(void*, const grammar::LeftLG& grammar) const;
+	using grammar::VisitableConstRGBase::Visit;
+
+	void Visit(void*, const grammar::RightRG& grammar) const;
+	void Visit(void*, const grammar::LeftRG& grammar) const;
+	void Visit(void*, const grammar::RightLG& grammar) const;
+	void Visit(void*, const grammar::LeftLG& grammar) const;
 
-    static const ToRegExpAlgebraic TO_REG_EXP_ALGEBRAIC;
+	static const ToRegExpAlgebraic TO_REG_EXP_ALGEBRAIC;
 };
 
 } /* namespace covert */
diff --git a/alib2algo/src/grammar/generate/GenerateUpToLength.h b/alib2algo/src/grammar/generate/GenerateUpToLength.h
index 4b89f67fbfb62ea01f7b0a8867a8ab9ffaa0d244..26b2d1fc8bd1b0febf4efc8dc5186659ea35cb04 100644
--- a/alib2algo/src/grammar/generate/GenerateUpToLength.h
+++ b/alib2algo/src/grammar/generate/GenerateUpToLength.h
@@ -21,6 +21,8 @@ namespace generate {
  */
 class GenerateUpToLength : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	GenerateUpToLength() {}
+
 	static std::set<string::LinearString> generate( const grammar::Grammar & grammar, unsigned length );
 
 	template<class T>
diff --git a/alib2algo/src/grammar/properties/IsLanguageEmpty.h b/alib2algo/src/grammar/properties/IsLanguageEmpty.h
index ccfd0b6004667c72f60a9d1e0749b41d1c1869c4..0921e4f4ad39668fcbe82a52efa7d9c512910357 100644
--- a/alib2algo/src/grammar/properties/IsLanguageEmpty.h
+++ b/alib2algo/src/grammar/properties/IsLanguageEmpty.h
@@ -19,6 +19,8 @@ namespace properties {
  */
 class IsLanguageEmpty : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	IsLanguageEmpty() {}
+
 	static bool isLanguageEmpty( const grammar::Grammar & grammar );
 
 	/*
diff --git a/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.h b/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.h
index 0eb20a75056bd97dff958b6dfc7755e3a5960b1b..ef87b98b7c62aed9cf78fba3fedd480d2fd9e3d9 100644
--- a/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.h
+++ b/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.h
@@ -19,6 +19,8 @@ namespace properties {
  */
 class IsLanguageGeneratingEpsilon : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	IsLanguageGeneratingEpsilon() {}
+
 	static bool isLanguageGeneratingEpsilon( const grammar::Grammar & grammar );
 
 	/*
diff --git a/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.h b/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.h
index 0d64caae300889f7eefd27750d41009026a61521..c5802dc48d161c931ce41eb30249aeab7666d84b 100644
--- a/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.h
+++ b/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.h
@@ -20,6 +20,8 @@ namespace properties {
  */
 class NonterminalUnitRuleCycle : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	NonterminalUnitRuleCycle() {}
+
 	static std::set<alphabet::Symbol> getNonterminalUnitRuleCycle( const grammar::Grammar & grammar, const alphabet::Symbol& nonterminal );
 
 	/**
diff --git a/alib2algo/src/grammar/properties/NullableNonterminals.h b/alib2algo/src/grammar/properties/NullableNonterminals.h
index 7c55b69614fd15bc9002ef6592bf82d92d2c6a27..85e47beb5409b8815fa14f9b6309d9d0c47fbe66 100644
--- a/alib2algo/src/grammar/properties/NullableNonterminals.h
+++ b/alib2algo/src/grammar/properties/NullableNonterminals.h
@@ -20,6 +20,8 @@ namespace properties {
  */
 class NullableNonterminals : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	NullableNonterminals() {}
+
 	static std::set<alphabet::Symbol> getNullableNonterminals( const grammar::Grammar & grammar );
 
 	/**
diff --git a/alib2algo/src/grammar/properties/ProductiveNonterminals.h b/alib2algo/src/grammar/properties/ProductiveNonterminals.h
index 317b51cd280cdb92cc57d79013c63c128aba2db1..688c011f06e17e8d57c2406081ce95ee50adb66b 100644
--- a/alib2algo/src/grammar/properties/ProductiveNonterminals.h
+++ b/alib2algo/src/grammar/properties/ProductiveNonterminals.h
@@ -20,6 +20,8 @@ namespace properties {
  */
 class ProductiveNonterminals : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	ProductiveNonterminals() {}
+
 	static std::set<alphabet::Symbol> getProductiveNonterminals( const grammar::Grammar & grammar );
 
 	/**
diff --git a/alib2algo/src/grammar/properties/UnreachableSymbols.h b/alib2algo/src/grammar/properties/UnreachableSymbols.h
index 3c9bbf976d83ffe19bedb3d45ffd0b5e8fd4a47c..a77f3421e29c259b977002c11cbaf3631736b7c5 100644
--- a/alib2algo/src/grammar/properties/UnreachableSymbols.h
+++ b/alib2algo/src/grammar/properties/UnreachableSymbols.h
@@ -20,6 +20,8 @@ namespace properties {
  */
 class UnreachableSymbols : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	UnreachableSymbols() {}
+
 	static std::set<alphabet::Symbol> getUnreachableSymbols( const grammar::Grammar & grammar );
 
 	/**
diff --git a/alib2algo/src/grammar/simplify/EpsilonRemover.h b/alib2algo/src/grammar/simplify/EpsilonRemover.h
index e67dae41439f7b06a9c34405e66516e9837832e7..dd4a59cfdb1511794da1fcf2d39a06c874d34b12 100644
--- a/alib2algo/src/grammar/simplify/EpsilonRemover.h
+++ b/alib2algo/src/grammar/simplify/EpsilonRemover.h
@@ -30,6 +30,8 @@ namespace simplify {
 
 class EpsilonRemover : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	EpsilonRemover() {}
+
 	static grammar::Grammar remove( const grammar::Grammar & grammar );
 
 	static grammar::EpsilonFreeCFG remove( const grammar::CFG & grammar );
diff --git a/alib2algo/src/grammar/simplify/LeftRecursionRemover.h b/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
index f4877c9bb6a177adab8b9f358fbbce7ffb396ae8..9b21ec16455315ead6c58cb8c6d7af79ac486e1e 100644
--- a/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
+++ b/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
@@ -30,6 +30,8 @@ namespace simplify {
 
 class LeftRecursionRemover : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	LeftRecursionRemover() {}
+
 	static grammar::Grammar remove( const grammar::Grammar & grammar );
 
 	static grammar::EpsilonFreeCFG remove( const grammar::EpsilonFreeCFG & grammar );
diff --git a/alib2algo/src/grammar/simplify/SimpleRulesRemover.h b/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
index 05c1fa88e41c7581be0a4aa37d405a1be62135ee..0f29d0c0d07e4c62b440fd446adb07c61fcd0b39 100644
--- a/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
+++ b/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
@@ -30,6 +30,8 @@ namespace simplify {
 
 class SimpleRulesRemover : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	SimpleRulesRemover() {}
+
 	static grammar::Grammar remove( const grammar::Grammar & grammar );
 
 	static grammar::CFG remove( const grammar::CFG & grammar );
diff --git a/alib2algo/src/grammar/simplify/ToCNF.h b/alib2algo/src/grammar/simplify/ToCNF.h
index 485a076e164b0648479cfa894be810e5834692d4..55f85daa8a7d1b27f1e36de3898f82583d554796 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.h
+++ b/alib2algo/src/grammar/simplify/ToCNF.h
@@ -30,6 +30,8 @@ namespace simplify {
 
 class ToCNF : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	ToCNF() {}
+
 	static grammar::Grammar convert( const grammar::Grammar & grammar );
 
 	static grammar::CNF convert( const grammar::CFG & grammar );
diff --git a/alib2algo/src/grammar/simplify/ToGNF.cpp b/alib2algo/src/grammar/simplify/ToGNF.cpp
index 71b34b7e17b3fb0b88fe88e8e0df609336c7674e..6507b2f5e91cb8b71a2d340afbd888f67fd28b3a 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToGNF.cpp
@@ -14,8 +14,6 @@
 #include "alphabet/LabeledSymbol.h"
 #include "alphabet/SymbolPairSymbol.h"
 
-#include <factory/StringDataFactory.hpp>
-
 namespace grammar {
 
 namespace simplify {
diff --git a/alib2algo/src/grammar/simplify/ToGNF.h b/alib2algo/src/grammar/simplify/ToGNF.h
index 87d9f30a2015df7972701e51591c3a01dbd8e2c8..764b4a69196e9e845d664af20cdef50cf41dca99 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.h
+++ b/alib2algo/src/grammar/simplify/ToGNF.h
@@ -30,6 +30,8 @@ namespace simplify {
 
 class ToGNF : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	ToGNF() {}
+
 	static grammar::Grammar convert( const grammar::Grammar & grammar );
 
 	static grammar::GNF convert( const grammar::CFG & grammar );
diff --git a/alib2algo/src/grammar/simplify/Trim.h b/alib2algo/src/grammar/simplify/Trim.h
index 25cb46cdd3b75d117749f2b3d3242f1ab8fab463..2c288411ed6d773c45da710fbf5c9b1d0aa61ed0 100644
--- a/alib2algo/src/grammar/simplify/Trim.h
+++ b/alib2algo/src/grammar/simplify/Trim.h
@@ -19,6 +19,8 @@ namespace simplify {
  */
 class Trim : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	Trim() {}
+
 	static grammar::Grammar trim( const grammar::Grammar & grammar );
 
 	/**
diff --git a/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.h b/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.h
index de8a17830edf1f3a94a4910f9247c3bfc978ebcf..d821b308637b6882fc799b2cba4f1fd874f3a392 100644
--- a/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.h
+++ b/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.h
@@ -25,6 +25,8 @@ namespace simplify {
  */
 class UnproductiveSymbolsRemover : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	UnproductiveSymbolsRemover() {}
+
 	static grammar::Grammar remove( const grammar::Grammar & automaton );
 
 	/**
diff --git a/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.h b/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.h
index 1144d510cc1d3c5f7bd30364e921bd8d45f15926..18ef5dc502e5ecb994a80c74c535fe9cbbb592e3 100644
--- a/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.h
+++ b/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.h
@@ -25,6 +25,8 @@ namespace simplify {
  */
 class UnreachableSymbolsRemover : public grammar::VisitableGrammarBase::const_visitor_type {
 public:
+	UnreachableSymbolsRemover() {}
+
 	static grammar::Grammar remove( const grammar::Grammar & automaton );
 
 	/*
diff --git a/alib2algo/src/graph/shortestpath/BellmanFord.h b/alib2algo/src/graph/shortestpath/BellmanFord.h
index 1c117f6a40c31b245e301ff4b86da6da25b6b926..730175966d90b4b39eae277514898ab3dfd7bf93 100644
--- a/alib2algo/src/graph/shortestpath/BellmanFord.h
+++ b/alib2algo/src/graph/shortestpath/BellmanFord.h
@@ -21,6 +21,8 @@ namespace shortestpath
 class BellmanFord : public graph::VisitableGraphBase::const_visitor_type
 {
 public:
+	BellmanFord() {}
+
 	typedef std::unordered_map<Node, int> Result;
 
 	static Result bellmanford(const Graph &graph, const Node &start);
diff --git a/alib2algo/src/graph/shortestpath/Dijkstra.h b/alib2algo/src/graph/shortestpath/Dijkstra.h
index d9373e3ca3f22a3ee807abeba75669338101de46..52cf36902b1945420a6160b60bce1ecb57a6f020 100644
--- a/alib2algo/src/graph/shortestpath/Dijkstra.h
+++ b/alib2algo/src/graph/shortestpath/Dijkstra.h
@@ -18,6 +18,8 @@ namespace shortestpath
 class Dijkstra : public graph::VisitableGraphBase::const_visitor_type
 {
 public:
+	Dijkstra() {}
+
 	typedef std::unordered_map<Node, int> Result;
 
 	static Result dijkstra(const Graph &graph, const Node &start);
diff --git a/alib2algo/src/graph/shortestpath/FloydWarshall.h b/alib2algo/src/graph/shortestpath/FloydWarshall.h
index f9a7ab1855e24f26ed544202c6d656825891ee8d..bbc16ca70802693ef9d4165de691eef55dcd1b4b 100644
--- a/alib2algo/src/graph/shortestpath/FloydWarshall.h
+++ b/alib2algo/src/graph/shortestpath/FloydWarshall.h
@@ -22,6 +22,8 @@ namespace shortestpath
 class FloydWarshall : public graph::VisitableGraphBase::const_visitor_type
 {
 public:
+	FloydWarshall() {}
+
 	typedef std::unordered_map<Node, std::unordered_map<Node, int>> Result;
 
 	static Result floydwarshall(const Graph &graph);
diff --git a/alib2algo/src/graph/sort/TopologicalSort.h b/alib2algo/src/graph/sort/TopologicalSort.h
index ec30472bc7ffe5cee35b32da51c0e1643b1dcf96..b746cb2bd5f12d6ff0e53cd0a8a8758e062df8db 100644
--- a/alib2algo/src/graph/sort/TopologicalSort.h
+++ b/alib2algo/src/graph/sort/TopologicalSort.h
@@ -16,6 +16,8 @@ namespace sort
 class TopologicalSort : public graph::VisitableGraphBase::const_visitor_type
 {
 public:
+	TopologicalSort() {}
+
 	typedef std::list<Node> Result;
 
 	static Result topologicalsort(const Graph &graph);
diff --git a/alib2algo/src/graph/spanningtree/JarnikPrim.h b/alib2algo/src/graph/spanningtree/JarnikPrim.h
index cf1273514f28f3b2e482efd17dc82ad3de861f55..8b8d11e24b7fab00d35d4272c529189ff1b97d1c 100644
--- a/alib2algo/src/graph/spanningtree/JarnikPrim.h
+++ b/alib2algo/src/graph/spanningtree/JarnikPrim.h
@@ -14,6 +14,8 @@ namespace spanningtree
 class JarnikPrim : public graph::VisitableGraphBase::const_visitor_type
 {
 public:
+	JarnikPrim() {}
+
 	static Graph jarnikprim(const Graph &graph, const Node &start);
 
 	static UndirectedGraph jarnikprim(const UndirectedGraph &graph, const Node &start);
diff --git a/alib2algo/src/graph/traverse/Bfs.h b/alib2algo/src/graph/traverse/Bfs.h
index f4a468bfe911e33812902e0b34096c27155c798a..c180b1a3230dae0d44b7e95788ff64f907755438 100644
--- a/alib2algo/src/graph/traverse/Bfs.h
+++ b/alib2algo/src/graph/traverse/Bfs.h
@@ -19,6 +19,8 @@ namespace traverse
 class Bfs : public graph::VisitableGraphBase::const_visitor_type
 {
 public:
+	Bfs() {}
+
 	typedef std::function<bool(const Node&)> Function;
 	typedef std::function<bool(const Node&, const Node&, int)> FunctionExt;
 
diff --git a/alib2algo/src/graph/traverse/Dfs.h b/alib2algo/src/graph/traverse/Dfs.h
index 7f068d4d3bac734c2e19a64f2458e7bfc04912f1..532b53ba9d4548132cfa28d6a602581735319b70 100644
--- a/alib2algo/src/graph/traverse/Dfs.h
+++ b/alib2algo/src/graph/traverse/Dfs.h
@@ -19,6 +19,8 @@ namespace traverse
 class Dfs : public graph::VisitableGraphBase::const_visitor_type
 {
 public:
+	Dfs() {}
+
 	typedef std::function<bool(const Node&)> Function;
 	typedef std::function<bool(const Node&, const Node&, int, int)> FunctionExt;
 
diff --git a/alib2algo/src/regexp/GlushkovSymbol.cpp b/alib2algo/src/regexp/GlushkovSymbol.cpp
index eebd3323579636dc74832a1f85115cf7f496e03c..0be8280ad55671c5fd73e2a38f5093c3706132fd 100644
--- a/alib2algo/src/regexp/GlushkovSymbol.cpp
+++ b/alib2algo/src/regexp/GlushkovSymbol.cpp
@@ -7,9 +7,6 @@
 
 #include "GlushkovSymbol.h"
 
-using namespace alphabet;
-using namespace regexp;
-
 namespace regexp
 {
 
@@ -29,9 +26,9 @@ int GlushkovSymbol::getId( void ) const
 	return m_i;
 }
 
-Symbol GlushkovSymbol::getInputSymbol( void ) const
+alphabet::Symbol GlushkovSymbol::getInputSymbol( void ) const
 {
-	return Symbol( m_regexpSymbol->getSymbol( ) );
+	return alphabet::Symbol( m_regexpSymbol->getSymbol( ) );
 }
 
 regexp::UnboundedRegExpSymbol const * GlushkovSymbol::getSymbolPtr( void ) const
diff --git a/alib2algo/src/regexp/GlushkovTraversal.cpp b/alib2algo/src/regexp/GlushkovTraversal.cpp
index 07060c8d358b639b5313f5e5c87b1b687e2eb61d..fa7c5bec08597dee891ebd7e5d6068cfd128d110 100644
--- a/alib2algo/src/regexp/GlushkovTraversal.cpp
+++ b/alib2algo/src/regexp/GlushkovTraversal.cpp
@@ -9,10 +9,6 @@
 
 #include "properties/RegExpEpsilon.h"
 
-using namespace alib;
-using namespace regexp;
-using namespace std;
-
 namespace regexp
 {
 
@@ -33,9 +29,9 @@ bool GlushkovTraversal::pos( GlushkovSymbol const& symbol, regexp::UnboundedRegE
 	return pos( & node->getRegExp(), symbol.getSymbolPtr( ) );
 }
 
-set<GlushkovSymbol> GlushkovTraversal::first( regexp::UnboundedRegExp const& re )
+std::set<GlushkovSymbol> GlushkovTraversal::first( regexp::UnboundedRegExp const& re )
 {
-	set<GlushkovSymbol> firstSet, symbolSet = getSymbols( re );
+	std::set<GlushkovSymbol> firstSet, symbolSet = getSymbols( re );
 
 	for( auto const& s : first( & re.getRegExp() ) )
 		firstSet.insert( findSymbol( s, symbolSet ) );
@@ -43,9 +39,9 @@ set<GlushkovSymbol> GlushkovTraversal::first( regexp::UnboundedRegExp const& re
 	return firstSet;
 }
 
-set<GlushkovSymbol> GlushkovTraversal::last( regexp::UnboundedRegExp const& re )
+std::set<GlushkovSymbol> GlushkovTraversal::last( regexp::UnboundedRegExp const& re )
 {
-	set<GlushkovSymbol> lastSet, symbolSet = getSymbols( re );
+	std::set<GlushkovSymbol> lastSet, symbolSet = getSymbols( re );
 
 	for( auto const& s : last( & re.getRegExp() ) )
 		lastSet.insert( findSymbol( s, symbolSet ) );
@@ -53,9 +49,9 @@ set<GlushkovSymbol> GlushkovTraversal::last( regexp::UnboundedRegExp const& re )
 	return lastSet;
 }
 
-set<GlushkovSymbol> GlushkovTraversal::follow( regexp::UnboundedRegExp const& re, GlushkovSymbol const& symbol )
+std::set<GlushkovSymbol> GlushkovTraversal::follow( regexp::UnboundedRegExp const& re, GlushkovSymbol const& symbol )
 {
-	set<GlushkovSymbol> followSet, symbolSet = getSymbols( re );
+	std::set<GlushkovSymbol> followSet, symbolSet = getSymbols( re );
 
 	for( auto const& s: follow( & re.getRegExp(), symbol.getSymbolPtr( ) ) )
 		followSet.insert( findSymbol( s, symbolSet ) );
@@ -65,7 +61,7 @@ set<GlushkovSymbol> GlushkovTraversal::follow( regexp::UnboundedRegExp const& re
 
 // -----------------------------------------------------------------------------
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpElement const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpElement const * const & node )
 {
 	regexp::UnboundedRegExpAlternation const * const alternation = dynamic_cast<regexp::UnboundedRegExpAlternation const * const>( node );
 	regexp::UnboundedRegExpConcatenation const * const concatenation = dynamic_cast<regexp::UnboundedRegExpConcatenation const * const>( node );
@@ -90,9 +86,9 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::Unb
 	throw exception::AlibException( "GlushkovTraversal::first - invalid RegExpElement node" );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpAlternation const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpAlternation const * const & node )
 {
-	set<regexp::UnboundedRegExpSymbol const *> ret, tmp;
+	std::set<regexp::UnboundedRegExpSymbol const *> ret, tmp;
 
 	for( auto const& element : node->getElements( ) )
 	{
@@ -103,9 +99,9 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::Unb
 	return ret;
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpConcatenation const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpConcatenation const * const & node )
 {
-	set<regexp::UnboundedRegExpSymbol const *> ret, tmp;
+	std::set<regexp::UnboundedRegExpSymbol const *> ret, tmp;
 
 	for( auto const& element : node->getElements( ) )
 	{
@@ -119,29 +115,29 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::Unb
 	return ret;
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpIteration const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpIteration const * const & node )
 {
 	return first( & node->getElement( ) );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpSymbol const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpSymbol const * const & node )
 {
-	return set<regexp::UnboundedRegExpSymbol const *> { node };
+	return std::set<regexp::UnboundedRegExpSymbol const *> { node };
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpEpsilon const * const & /* node */ )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpEpsilon const * const & /* node */ )
 {
-	return set<regexp::UnboundedRegExpSymbol const *>( );
+	return std::set<regexp::UnboundedRegExpSymbol const *>( );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpEmpty const * const &  /* node */ )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::UnboundedRegExpEmpty const * const &  /* node */ )
 {
-	return set<regexp::UnboundedRegExpSymbol const *>( );
+	return std::set<regexp::UnboundedRegExpSymbol const *>( );
 }
 
 // ----------------------------------------------------------------------------
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpElement const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpElement const * const & node )
 {
 	regexp::UnboundedRegExpAlternation const * const alternation = dynamic_cast<regexp::UnboundedRegExpAlternation const * const>( node );
 	regexp::UnboundedRegExpConcatenation const * const concatenation = dynamic_cast<regexp::UnboundedRegExpConcatenation const * const>( node );
@@ -166,22 +162,22 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::Unbo
 	 throw exception::AlibException( "GlushkovTraversal::last - invalid RegExpElement node" );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpAlternation const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpAlternation const * const & node )
 {
-	set<regexp::UnboundedRegExpSymbol const *> ret;
+	std::set<regexp::UnboundedRegExpSymbol const *> ret;
 
 	for( auto const& element : node->getElements( ) )
 	{
-		set<regexp::UnboundedRegExpSymbol const *> tmp = last( element );
+		std::set<regexp::UnboundedRegExpSymbol const *> tmp = last( element );
 		ret.insert( tmp.begin( ), tmp.end( ) );
 	}
 
 	return ret;
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpConcatenation const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpConcatenation const * const & node )
 {
-	set<regexp::UnboundedRegExpSymbol const *> ret, tmp;
+	std::set<regexp::UnboundedRegExpSymbol const *> ret, tmp;
 
 	for( auto it = node->getElements( ).rbegin( ); it != node->getElements( ).rend( ) ; it ++ )
 	{
@@ -195,29 +191,29 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::Unbo
 	return ret;
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpIteration const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpIteration const * const & node )
 {
 	return last( & node->getElement( ) );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpSymbol const * const & node )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpSymbol const * const & node )
 {
-	return set<regexp::UnboundedRegExpSymbol const *> { node };
+	return std::set<regexp::UnboundedRegExpSymbol const *> { node };
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpEpsilon const * const & /* node */ )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpEpsilon const * const & /* node */ )
 {
-	return set<regexp::UnboundedRegExpSymbol const *>( );
+	return std::set<regexp::UnboundedRegExpSymbol const *>( );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpEmpty const * const & /* node */ )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::UnboundedRegExpEmpty const * const & /* node */ )
 {
-	return set<regexp::UnboundedRegExpSymbol const *>( );
+	return std::set<regexp::UnboundedRegExpSymbol const *>( );
 }
 
 // ----------------------------------------------------------------------------
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpElement const * const & node, regexp::UnboundedRegExpSymbol const * const & symbolptr )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpElement const * const & node, regexp::UnboundedRegExpSymbol const * const & symbolptr )
 {
 	regexp::UnboundedRegExpAlternation const * const alternation = dynamic_cast<regexp::UnboundedRegExpAlternation const * const>( node );
 	regexp::UnboundedRegExpConcatenation const * const concatenation = dynamic_cast<regexp::UnboundedRegExpConcatenation const * const>( node );
@@ -247,7 +243,7 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::Un
 	throw exception::AlibException( "GlushkovTraversal::follow() - unknown RegExpElement node" );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpAlternation const * const & node, regexp::UnboundedRegExpSymbol const * const & symbolptr )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpAlternation const * const & node, regexp::UnboundedRegExpSymbol const * const & symbolptr )
 {
 	for( auto const& element : node->getElements( ) )
 		if( pos( element, symbolptr ) )
@@ -256,9 +252,9 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::Un
 	throw exception::AlibException( "GlushkovTraversal::follow(Alt)" );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpConcatenation const * const & node, regexp::UnboundedRegExpSymbol const * const & symbolptr )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpConcatenation const * const & node, regexp::UnboundedRegExpSymbol const * const & symbolptr )
 {
-	set<regexp::UnboundedRegExpSymbol const *> ret, tmp, lastSet;
+	std::set<regexp::UnboundedRegExpSymbol const *> ret, tmp, lastSet;
 
 	for( auto e = node->getElements( ).begin( ); e != node->getElements( ).end( ); e ++ )
 	{
@@ -284,33 +280,33 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::Un
 	return ret;
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpIteration const * const & node, regexp::UnboundedRegExpSymbol const * const & symbolptr )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpIteration const * const & node, regexp::UnboundedRegExpSymbol const * const & symbolptr )
 {
-	set<regexp::UnboundedRegExpSymbol const *> ret = follow( & node->getElement( ), symbolptr );
-	set<regexp::UnboundedRegExpSymbol const *> lastSet = last( & node->getElement( ) );
+	std::set<regexp::UnboundedRegExpSymbol const *> ret = follow( & node->getElement( ), symbolptr );
+	std::set<regexp::UnboundedRegExpSymbol const *> lastSet = last( & node->getElement( ) );
 
 	if( isInSet( symbolptr, lastSet ) )
 	{
-		set<regexp::UnboundedRegExpSymbol const *> firstSet = first( & node->getElement( ) );
+		std::set<regexp::UnboundedRegExpSymbol const *> firstSet = first( & node->getElement( ) );
 		ret.insert( firstSet.begin( ), firstSet.end( ) );
 	}
 
 	return ret;
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpSymbol const * const & /* node */, regexp::UnboundedRegExpSymbol const * const & /* symbolptr */ )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpSymbol const * const & /* node */, regexp::UnboundedRegExpSymbol const * const & /* symbolptr */ )
 {
-	return set<regexp::UnboundedRegExpSymbol const *>( );
+	return std::set<regexp::UnboundedRegExpSymbol const *>( );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpEmpty const * const & /* node */, regexp::UnboundedRegExpSymbol const * const & /* symbolptr */ )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpEmpty const * const & /* node */, regexp::UnboundedRegExpSymbol const * const & /* symbolptr */ )
 {
-	return set<regexp::UnboundedRegExpSymbol const *>( );
+	return std::set<regexp::UnboundedRegExpSymbol const *>( );
 }
 
-set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpEpsilon const * const & /* node */, regexp::UnboundedRegExpSymbol const * const & /* symbolptr */ )
+std::set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::UnboundedRegExpEpsilon const * const & /* node */, regexp::UnboundedRegExpSymbol const * const & /* symbolptr */ )
 {
-	return set<regexp::UnboundedRegExpSymbol const *>( );
+	return std::set<regexp::UnboundedRegExpSymbol const *>( );
 }
 
 // ----------------------------------------------------------------------------
@@ -383,9 +379,9 @@ bool GlushkovTraversal::pos( regexp::UnboundedRegExpEpsilon const * const & /* n
 
 // ----------------------------------------------------------------------------
 
-set<GlushkovSymbol> GlushkovTraversal::getSymbols( regexp::UnboundedRegExp const& re )
+std::set<GlushkovSymbol> GlushkovTraversal::getSymbols( regexp::UnboundedRegExp const& re )
 {
-	set<GlushkovSymbol> alphabet;
+	std::set<GlushkovSymbol> alphabet;
 	int i = 1;
 
 	getSymbols( & re.getRegExp( ), alphabet, i );
@@ -393,7 +389,7 @@ set<GlushkovSymbol> GlushkovTraversal::getSymbols( regexp::UnboundedRegExp const
 	return alphabet;
 }
 
-void GlushkovTraversal::getSymbols( regexp::UnboundedRegExpElement const * const & node, set<GlushkovSymbol> & alphabet, int & i )
+void GlushkovTraversal::getSymbols( regexp::UnboundedRegExpElement const * const & node, std::set<GlushkovSymbol> & alphabet, int & i )
 {
 	regexp::UnboundedRegExpAlternation const * const alternation = dynamic_cast<regexp::UnboundedRegExpAlternation const * const>( node );
 	regexp::UnboundedRegExpConcatenation const * const concatenation = dynamic_cast<regexp::UnboundedRegExpConcatenation const * const>( node );
diff --git a/alib2algo/src/regexp/convert/ToAutomaton.h b/alib2algo/src/regexp/convert/ToAutomaton.h
index 9894aff99762f91750c1da349f7353fea6b0e4e0..9e52611d371d6297b954fe6a5d8ff6e37a77f2c6 100644
--- a/alib2algo/src/regexp/convert/ToAutomaton.h
+++ b/alib2algo/src/regexp/convert/ToAutomaton.h
@@ -22,6 +22,8 @@ namespace convert {
 class ToAutomaton : public regexp::VisitableRegExpBase::const_visitor_type
 {
 public:
+	ToAutomaton() {}
+
 	/**
 	 * Performs conversion.
 	 * @return FSM equivalent to original regular expression.
diff --git a/alib2algo/src/regexp/convert/ToAutomatonDerivation.h b/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
index 7b26ff65f4d23332521b1e7e02b05748d756bf71..2c25d32cc181fb861e5534a470b07b9610bd6f66 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
@@ -26,6 +26,8 @@ namespace convert {
 class ToAutomatonDerivation : public regexp::VisitableRegExpBase::const_visitor_type
 {
 public:
+	ToAutomatonDerivation() {}
+
 	/**
 	 * Performs conversion.
 	 * @return FSM equivalent to original regular expression.
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
index edf737ad00edd4ba0ca3f0793c44b56a6eb5cdf3..e916394f7bd28755a423d3fca3c45cd9758761c7 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
@@ -26,6 +26,8 @@ namespace convert {
 class ToAutomatonGlushkov : public regexp::VisitableRegExpBase::const_visitor_type
 {
 public:
+	ToAutomatonGlushkov() {}
+
 	/**
 	 * Performs conversion.
 	 * @param re Original regular expression.
diff --git a/alib2algo/src/regexp/convert/ToAutomatonThompson.h b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
index e2608c9b1c12adccb75c390ac621a93fe5aa92a3..1c33e992e08c8426db956438d93542cc18dae104 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonThompson.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
@@ -29,6 +29,8 @@ namespace convert {
 class ToAutomatonThompson : public regexp::VisitableRegExpBase::const_visitor_type, regexp::FormalRegExpElement::const_visitor_type, regexp::UnboundedRegExpElement::const_visitor_type
 {
 public:
+	ToAutomatonThompson() {}
+
 	/**
 	 * Performs conversion.
 	 * @param regexp regexp to convert
diff --git a/alib2algo/src/regexp/convert/ToGrammar.h b/alib2algo/src/regexp/convert/ToGrammar.h
index de8438c541638213b0e98dbde6cfd691d0b6b784..02536f818d5d0b9dde3965ba3b7abe4e7ee87085 100644
--- a/alib2algo/src/regexp/convert/ToGrammar.h
+++ b/alib2algo/src/regexp/convert/ToGrammar.h
@@ -18,6 +18,8 @@ namespace convert {
 class ToGrammar : public regexp::VisitableRegExpBase::const_visitor_type
 {
 public:
+	ToGrammar() {}
+
 	/**
 	 * Performs conversion.
 	 * @return right regular grammar equivalent to source regexp.
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
index 4027f7169173a6f70cfdfa406e9e8f70e2b14818..349d490350bcdeeda338b37bff2fae1334a4da29 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
@@ -24,6 +24,8 @@ namespace convert {
 class ToGrammarRightRGDerivation : public regexp::VisitableRegExpBase::const_visitor_type
 {
 public:
+	ToGrammarRightRGDerivation() {}
+
 	/**
 	 * Performs conversion.
 	 * @return right regular grammar equivalent to source regexp.
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
index 7eec5a03077006c6350897ade7557ff6032b394e..2d03c778aa49197f145dfa9ad49d348b54d6cf18 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
@@ -26,6 +26,8 @@ namespace convert {
 class ToGrammarRightRGGlushkov : public regexp::VisitableRegExpBase::const_visitor_type
 {
 public:
+	ToGrammarRightRGGlushkov() {}
+
 	/**
 	 * Performs conversion.
 	 * @param regexp original regular expression
diff --git a/alib2algo/src/regexp/properties/RegExpEmpty.h b/alib2algo/src/regexp/properties/RegExpEmpty.h
index d76fa5fac364d1b933b73f399832cf47fc14f20e..4b68a9683256675a0d501318d81be657d562f906 100644
--- a/alib2algo/src/regexp/properties/RegExpEmpty.h
+++ b/alib2algo/src/regexp/properties/RegExpEmpty.h
@@ -23,6 +23,8 @@ namespace properties {
 class RegExpEmpty : public regexp::VisitableRegExpBase::const_visitor_type, regexp::FormalRegExpElement::const_visitor_type, regexp::UnboundedRegExpElement::const_visitor_type
 {
 public:
+	RegExpEmpty() {}
+
 	static bool languageIsEmpty(const regexp::RegExp& regexp);
 
 	static bool languageIsEmpty(const regexp::FormalRegExp& regexp);
diff --git a/alib2algo/src/regexp/properties/RegExpEpsilon.h b/alib2algo/src/regexp/properties/RegExpEpsilon.h
index c5ba4793b8a0188d0cc6a136df2b1f4e89d598fa..8b2da94bba60757ca371cc52f4e9c63df2aab811 100644
--- a/alib2algo/src/regexp/properties/RegExpEpsilon.h
+++ b/alib2algo/src/regexp/properties/RegExpEpsilon.h
@@ -18,12 +18,13 @@ namespace properties {
 
 /**
  * Checks, whether regexp (or its subtree) describes epsilon (empty string).
- * TODO: Better API?
  *
  */
 class RegExpEpsilon : public regexp::VisitableRegExpBase::const_visitor_type, regexp::FormalRegExpElement::const_visitor_type, regexp::UnboundedRegExpElement::const_visitor_type
 {
 public:
+	RegExpEpsilon() {}
+
 	static bool languageContainsEpsilon(const regexp::RegExp& regexp);
 
 	static bool languageContainsEpsilon(const regexp::FormalRegExp& regexp);
diff --git a/alib2algo/src/regexp/simplify/RegExpOptimize.h b/alib2algo/src/regexp/simplify/RegExpOptimize.h
index 3c1b3d2182983bd0a58b451e2af931c91afe1dda..db510610f9e617f6e52cff8a32762e2f1d4b3866 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimize.h
+++ b/alib2algo/src/regexp/simplify/RegExpOptimize.h
@@ -64,6 +64,8 @@ namespace simplify {
 class RegExpOptimize : public regexp::VisitableRegExpBase::const_visitor_type
 {
 public:
+	RegExpOptimize() {}
+
 	static regexp::RegExp optimize( const regexp::RegExp & regexp );
 
 	static regexp::UnboundedRegExp optimize( const regexp::UnboundedRegExp & regexp );
diff --git a/alib2algo/src/regexp/transform/RegExpAlternate.h b/alib2algo/src/regexp/transform/RegExpAlternate.h
index bb6b3b91edc42da1a347099e63a93d03ff9f91a5..21dbc776570cdf2826b10661363f26a4f5b47d4a 100644
--- a/alib2algo/src/regexp/transform/RegExpAlternate.h
+++ b/alib2algo/src/regexp/transform/RegExpAlternate.h
@@ -22,6 +22,8 @@ namespace regexp
 class RegExpAlternate : public regexp::VisitableRegExpBase::const_promoting_visitor_type
 {
 public:
+	RegExpAlternate() {}
+
 	static regexp::RegExp alternate(const regexp::RegExp& first, const regexp::RegExp& second);
 
 	static regexp::FormalRegExp alternate(const regexp::FormalRegExp& first, const regexp::FormalRegExp& second);
diff --git a/alib2algo/src/regexp/transform/RegExpConcatenate.h b/alib2algo/src/regexp/transform/RegExpConcatenate.h
index 01c4810ab8b52f624bcb050a4cff03858d3fec48..2f025b7058105404a179a753005c7cebf6deff72 100644
--- a/alib2algo/src/regexp/transform/RegExpConcatenate.h
+++ b/alib2algo/src/regexp/transform/RegExpConcatenate.h
@@ -22,6 +22,8 @@ namespace regexp
 class RegExpConcatenate : public regexp::VisitableRegExpBase::const_promoting_visitor_type
 {
 public:
+	RegExpConcatenate() {}
+
 	static regexp::RegExp concatenate(const regexp::RegExp& first, const regexp::RegExp& second);
 
 	static regexp::FormalRegExp concatenate(const regexp::FormalRegExp& first, const regexp::FormalRegExp& second);
diff --git a/alib2algo/src/regexp/transform/RegExpDerivation.h b/alib2algo/src/regexp/transform/RegExpDerivation.h
index d7402ceec1119af461e370ebc20e60d06200df49..9e578c25042522ee43d089d9a65e533e13912893 100644
--- a/alib2algo/src/regexp/transform/RegExpDerivation.h
+++ b/alib2algo/src/regexp/transform/RegExpDerivation.h
@@ -27,6 +27,8 @@ namespace regexp
 class RegExpDerivation : public regexp::VisitableRegExpBase::const_visitor_type, regexp::FormalRegExpElement::const_visitor_type, regexp::UnboundedRegExpElement::const_visitor_type
 {
 public:
+	RegExpDerivation() {}
+
 	/**
 	 * @param regexp RegExp to derivate
 	 * @param string String to derivate given RegExp over
diff --git a/alib2algo/src/regexp/transform/RegExpIntegral.h b/alib2algo/src/regexp/transform/RegExpIntegral.h
index 1f8d6ffc2a4b195e128a81c74ab52616e2b99136..e86206b37a612d4e7e15160631e2248748fc7911 100644
--- a/alib2algo/src/regexp/transform/RegExpIntegral.h
+++ b/alib2algo/src/regexp/transform/RegExpIntegral.h
@@ -24,6 +24,8 @@ namespace regexp
 class RegExpIntegral : public regexp::VisitableRegExpBase::const_visitor_type, regexp::FormalRegExpElement::const_visitor_type, regexp::UnboundedRegExpElement::const_visitor_type
 {
 public:
+	RegExpIntegral() {}
+
 	/**
 	 * @param regexp RegExp to integrate
 	 * @param string String to integrate given RegExp over
diff --git a/alib2algo/src/regexp/transform/RegExpIterate.h b/alib2algo/src/regexp/transform/RegExpIterate.h
index df65d580db4ed04352b505087241b20bab7fc8d2..b313cd0db26b3a3b2bc58abf0820ada974640597 100644
--- a/alib2algo/src/regexp/transform/RegExpIterate.h
+++ b/alib2algo/src/regexp/transform/RegExpIterate.h
@@ -22,6 +22,8 @@ namespace regexp
 class RegExpIterate : public regexp::VisitableRegExpBase::const_visitor_type
 {
 public:
+	RegExpIterate() {}
+
 	static regexp::RegExp iterate(const regexp::RegExp& regexp);
 
 	static regexp::FormalRegExp iterate(const regexp::FormalRegExp& regexp);
diff --git a/alib2algo/src/string/naive/ExactCompare.h b/alib2algo/src/string/naive/ExactCompare.h
index 3e6cdc880b89556bc98c406d9609ec17a1a68de2..ada478f2daf6b3358691d5ff969ee35c8aa1accd 100644
--- a/alib2algo/src/string/naive/ExactCompare.h
+++ b/alib2algo/src/string/naive/ExactCompare.h
@@ -16,6 +16,8 @@ namespace naive {
 
 class ExactCompare : public string::VisitableStringBase::const_promoting_visitor_type {
 public:
+	ExactCompare() {}
+
 	static int compare(const string::String& u, const string::String& v);
 
 	static int compare(const string::Epsilon& u, const string::Epsilon& v);
diff --git a/alib2algo/src/string/naive/ExactEqual.h b/alib2algo/src/string/naive/ExactEqual.h
index b131b5fdaf6624c748910ac689d1b9429be89d87..e0490504fd0ac9f330d59a5544eaba3daaafc168 100644
--- a/alib2algo/src/string/naive/ExactEqual.h
+++ b/alib2algo/src/string/naive/ExactEqual.h
@@ -16,6 +16,8 @@ namespace naive {
 
 class ExactEqual : public string::VisitableStringBase::const_promoting_visitor_type {
 public:
+	ExactEqual() {}
+
 	static bool equals(const string::String& u, const string::String& v);
 	
 	static bool equals(const string::Epsilon& u, const string::Epsilon& v);
diff --git a/alib2algo/src/string/simplify/NormalizeAlphabet.h b/alib2algo/src/string/simplify/NormalizeAlphabet.h
index 3452bf8e5783539765c0ab5013a8298030464ee2..ae869d9fa4f23b1060b33c56c8c9e38b0a1576cd 100644
--- a/alib2algo/src/string/simplify/NormalizeAlphabet.h
+++ b/alib2algo/src/string/simplify/NormalizeAlphabet.h
@@ -17,6 +17,8 @@ namespace simplify {
 
 class NormalizeAlphabet : public string::VisitableStringBase::const_visitor_type {
 public:
+	NormalizeAlphabet() {}
+
 	/**
 	 * @param dfa automaton to normalize
 	 */
diff --git a/alib2algo/src/string/simplify/NormalizeRotation.h b/alib2algo/src/string/simplify/NormalizeRotation.h
index d280a9feebab1e8a5a4cf0232546310ec80279fc..097d4bbbd58334d70b1ef0275766f612213cbdea 100644
--- a/alib2algo/src/string/simplify/NormalizeRotation.h
+++ b/alib2algo/src/string/simplify/NormalizeRotation.h
@@ -17,6 +17,8 @@ namespace simplify {
 
 class NormalizeRotation : public string::VisitableStringBase::const_visitor_type {
 public:
+	NormalizeRotation() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/stringology/exact/BorderArray.h b/alib2algo/src/stringology/exact/BorderArray.h
index c1283cbefa6f91d3c6cba5e60c02c0cc5ec65ad4..348a7599711493aed9150ad17e66720abb4845f8 100644
--- a/alib2algo/src/stringology/exact/BorderArray.h
+++ b/alib2algo/src/stringology/exact/BorderArray.h
@@ -17,6 +17,8 @@ namespace exact {
 
 class BorderArray : public string::VisitableStringBase::const_visitor_type {
 public:
+	BorderArray() {}
+
 	/**
 	 * Computes border array of string
 	 * @param string string to compute border array for
diff --git a/alib2algo/src/stringology/exact/BoyerMooreHorspool.h b/alib2algo/src/stringology/exact/BoyerMooreHorspool.h
index e42f44b3e10eae21dca2c898d1eaa1f64d83f595..b009922e1555bd820087ff65fb0f2606415e6246 100644
--- a/alib2algo/src/stringology/exact/BoyerMooreHorspool.h
+++ b/alib2algo/src/stringology/exact/BoyerMooreHorspool.h
@@ -20,6 +20,8 @@ namespace exact {
  */
 class BoyerMooreHorspool : public string::VisitableStringBase::const_same_visitor_type {
 public:
+	BoyerMooreHorspool() {}
+
 	/**
 	 * Search for pattern in linear string.
 	 * @return set set of occurences
diff --git a/alib2algo/src/stringology/exact/ExactFactorAutomaton.h b/alib2algo/src/stringology/exact/ExactFactorAutomaton.h
index b4957b220ecc85d4d2b66adda733e2c3f816ba54..d5549a32e8486610e8481e7085b71af1678fe0cb 100644
--- a/alib2algo/src/stringology/exact/ExactFactorAutomaton.h
+++ b/alib2algo/src/stringology/exact/ExactFactorAutomaton.h
@@ -19,6 +19,8 @@ namespace exact {
 
 class ExactFactorAutomaton : public string::VisitableStringBase::const_visitor_type {
 public:
+	ExactFactorAutomaton() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/stringology/exact/ExactMatch.h b/alib2algo/src/stringology/exact/ExactMatch.h
index 26e95dc0bf73b3f8e38efbf0762480b2fe675787..faf97daecccfbc9f7d07a92035ef47e5832d6c3b 100644
--- a/alib2algo/src/stringology/exact/ExactMatch.h
+++ b/alib2algo/src/stringology/exact/ExactMatch.h
@@ -16,6 +16,8 @@ namespace exact {
 
 class ExactMatch : public string::VisitableStringBase::const_promoting_visitor_type {
 public:
+	ExactMatch() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/stringology/exact/ExactMatchingAutomaton.h b/alib2algo/src/stringology/exact/ExactMatchingAutomaton.h
index 53087d50ce702f640ca1f577113f4b3b72ff15c5..d2fc0ef8c1a81c77484bac60a802960d370c2b40 100644
--- a/alib2algo/src/stringology/exact/ExactMatchingAutomaton.h
+++ b/alib2algo/src/stringology/exact/ExactMatchingAutomaton.h
@@ -19,6 +19,8 @@ namespace exact {
 
 class ExactMatchingAutomaton : public string::VisitableStringBase::const_visitor_type {
 public:
+	ExactMatchingAutomaton() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/stringology/exact/ExactMultiNondeterministicSubsequenceAutomaton.h b/alib2algo/src/stringology/exact/ExactMultiNondeterministicSubsequenceAutomaton.h
index eec9e5c0d47edfe22ec4ffd35ad1655b02b958b6..17b021b8daac486be65cfb31261682d6d030d4f0 100644
--- a/alib2algo/src/stringology/exact/ExactMultiNondeterministicSubsequenceAutomaton.h
+++ b/alib2algo/src/stringology/exact/ExactMultiNondeterministicSubsequenceAutomaton.h
@@ -19,6 +19,8 @@ namespace exact {
 
 class ExactMultiNondeterministicSubsequenceAutomaton {
 public:
+	ExactMultiNondeterministicSubsequenceAutomaton() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/stringology/exact/ExactNondeterministicSubsequenceAutomaton.h b/alib2algo/src/stringology/exact/ExactNondeterministicSubsequenceAutomaton.h
index d96b6ded3c2179fb7c65fec00d11ac684f726868..40fccb82eb7a50cdfe5b50d7ee9b379d980b36f1 100644
--- a/alib2algo/src/stringology/exact/ExactNondeterministicSubsequenceAutomaton.h
+++ b/alib2algo/src/stringology/exact/ExactNondeterministicSubsequenceAutomaton.h
@@ -19,6 +19,8 @@ namespace exact {
 
 class ExactNondeterministicSubsequenceAutomaton : public string::VisitableStringBase::const_visitor_type {
 public:
+	ExactNondeterministicSubsequenceAutomaton() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2algo/src/stringology/exact/ExactSubsequenceAutomaton.h b/alib2algo/src/stringology/exact/ExactSubsequenceAutomaton.h
index 0cc61c8b1909190cc12fc341d2b0bfc6564e3a11..0da0b1d86be452109d551536f32465b2f2971466 100644
--- a/alib2algo/src/stringology/exact/ExactSubsequenceAutomaton.h
+++ b/alib2algo/src/stringology/exact/ExactSubsequenceAutomaton.h
@@ -19,6 +19,8 @@ namespace exact {
 
 class ExactSubsequenceAutomaton : public string::VisitableStringBase::const_visitor_type {
 public:
+	ExactSubsequenceAutomaton() {}
+
 	/**
 	 * Performs conversion.
 	 * @return left regular grammar equivalent to source automaton.
diff --git a/alib2data/src/automaton/AutomatonBase.h b/alib2data/src/automaton/AutomatonBase.h
index 6ce99dfa0580fc64616c1575428ffb00bd138104..ebcfc1846ae4c18f0fce87fbf595c24ee172c6e8 100644
--- a/alib2data/src/automaton/AutomatonBase.h
+++ b/alib2data/src/automaton/AutomatonBase.h
@@ -33,7 +33,7 @@ public:
 };
 
 class VisitableConstFSMBase : public VisitableAutomatonBase::const_visitor_type {
-
+public:
 	using VisitableAutomatonBase::const_visitor_type::Visit;
 
 	void Visit(void*, const NFTA&) const {
@@ -90,7 +90,7 @@ class VisitableConstFSMBase : public VisitableAutomatonBase::const_visitor_type
 };
 
 class VisitableConstPDABase : public VisitableAutomatonBase::const_visitor_type {
-
+public:
 	using VisitableAutomatonBase::const_visitor_type::Visit;
 
 	void Visit(void*, const NFTA&) const {
@@ -132,7 +132,7 @@ class VisitableConstPDABase : public VisitableAutomatonBase::const_visitor_type
 };
 
 class VisitableConstNondeterministicAutomatonBase : public VisitableAutomatonBase::const_visitor_type {
-
+public:
 	using VisitableAutomatonBase::const_visitor_type::Visit;
 
 	void Visit(void*, const DFTA&) const {
@@ -169,7 +169,7 @@ class VisitableConstNondeterministicAutomatonBase : public VisitableAutomatonBas
 };
 
 class VisitableConstDeterministicAutomatonBase : public VisitableAutomatonBase::const_visitor_type {
-
+public:
 	using VisitableAutomatonBase::const_visitor_type::Visit;
 
 	void Visit(void*, const NFTA&) const {
diff --git a/alib2data/src/grammar/GrammarBase.h b/alib2data/src/grammar/GrammarBase.h
index 74018b7af972ffc292ba96f221d40b5783f5f811..9dc7b96f194db1e3aeb08530202255f897fa0c51 100644
--- a/alib2data/src/grammar/GrammarBase.h
+++ b/alib2data/src/grammar/GrammarBase.h
@@ -33,7 +33,7 @@ public:
 };
 
 class VisitableConstRGBase : public VisitableGrammarBase::const_visitor_type {
-
+public:
 	using VisitableGrammarBase::const_visitor_type::Visit;
 
 	void Visit(void*, const grammar::ContextPreservingUnrestrictedGrammar&) const