Abstract classes everywhere!

aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp

 #include "AbstractRGtoFAConverter.h"
-using namespace alphabet;
-using namespace automaton;
-using namespace grammar;
-
 namespace conversions
 {
-AbstractRGtoFAConverter::AbstractRGtoFAConverter( const RegularGrammar& grammar ) : m_grammar( grammar )
+AbstractRGtoFAConverter::AbstractRGtoFAConverter( void )
 {
 }
@@ -17,16 +13,4 @@ AbstractRGtoFAConverter::~AbstractRGtoFAConverter( void )
 }
-void AbstractRGtoFAConverter::createInputAlphabet( void )
-{
-    for( set<Symbol>::const_iterator i = m_grammar.getTerminalSymbols().begin(); i != m_grammar.getTerminalSymbols().end(); i++ )
-        m_automaton . addInputSymbol( *i );
-}
-
-void AbstractRGtoFAConverter::createStates( void )
-{
-    for( set<Symbol>::const_iterator i = m_grammar.getNonTerminalSymbols().begin(); i != m_grammar.getNonTerminalSymbols().end(); i++ )
-        m_automaton . addState( State( i-> getSymbol() ) );
-}
-
 } /* namespace conversions */

aconversions/src/rg2fa/AbstractRGtoFAConverter.h

@@ -2,8 +2,6 @@
 #define __ABSTRACTRGTOFACONVERTER_H__
 #include <automaton/FSM/FSM.h>
-#include <grammar/Regular/RegularGrammar.h>
-
 #include <AlibException.h>
 #include "../include/macros.h"
@@ -19,11 +17,8 @@ public:
     virtual ~AbstractRGtoFAConverter( void );
 protected:
-    AbstractRGtoFAConverter( const grammar::RegularGrammar& grammar );
-    void createStates( void );
-    void createInputAlphabet( void );
-    const grammar::RegularGrammar& m_grammar;
+    AbstractRGtoFAConverter( void );
     automaton::FSM m_automaton;
 };

aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp

+/*
+ * AbstractLRGtoFAConverter.cpp
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#include "AbstractLRGtoFAConverter.h"
+
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractLRGtoFAConverter::AbstractLRGtoFAConverter( const LeftRegularGrammar & lrg ) : m_grammar( lrg )
+{
+
+}
+
+AbstractLRGtoFAConverter::~AbstractLRGtoFAConverter( void )
+{
+
+}
+
+} /* namespace conversions */

aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h

+/*
+ * AbstractLRGtoFAConverter.h
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#ifndef ABSTRACTLRGTOFACONVERTER_H_
+#define ABSTRACTLRGTOFACONVERTER_H_
+
+#include <grammar/Regular/LeftRegularGrammar.h>
+
+#include "../AbstractRGtoFAConverter.h"
+
+namespace conversions
+{
+
+class AbstractLRGtoFAConverter: public AbstractRGtoFAConverter
+{
+public:
+    ~AbstractLRGtoFAConverter( void );
+
+protected:
+    AbstractLRGtoFAConverter( const grammar::LeftRegularGrammar & lrg );
+    const grammar::LeftRegularGrammar & m_grammar;
+
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTLRGTOFACONVERTER_H_ */

aconversions/src/rg2fa/LRGtoFAConverter.cpp → aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp

@@ -7,7 +7,7 @@ using namespace grammar;
 namespace conversions
 {
-LRGtoFAConverter::LRGtoFAConverter( const LeftRegularGrammar & grammar ) : AbstractRGtoFAConverter( grammar )
+LRGtoFAConverter::LRGtoFAConverter( const LeftRegularGrammar & grammar ) : AbstractLRGtoFAConverter( grammar )
 {
     //TODO: if is not LRG throw Exception
 }
@@ -19,8 +19,11 @@ LRGtoFAConverter::~LRGtoFAConverter( void )
 FSM LRGtoFAConverter::convert( void )
 {
-    createInputAlphabet( );
-    createStates( );
+    for( const auto & symbol : m_grammar.getTerminalSymbols( ) )
+        m_automaton.addInputSymbol( symbol );
+
+    for( const auto & symbol : m_grammar.getNonTerminalSymbols( ) )
+        m_automaton.addState( State( symbol.getSymbol( ) ) );
     const State & startState = m_automaton.createUniqueState( "q0", true );

aconversions/src/rg2fa/LRGtoFAConverter.h → aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h

 #ifndef __LRGTOFACONVERTER_H__
 #define __LRGTOFACONVERTER_H__
-#include <automaton/FSM/FSM.h>
-#include <grammar/Regular/LeftRegularGrammar.h>
-
-#include "AbstractRGtoFAConverter.h"
+#include "AbstractLRGtoFAConverter.h"
 namespace conversions
 {
-class LRGtoFAConverter : public AbstractRGtoFAConverter
+class LRGtoFAConverter : public AbstractLRGtoFAConverter
 {
 public:
     LRGtoFAConverter( const grammar::LeftRegularGrammar & grammar );

aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp

+/*
+ * AbstractRRGtoFAConverter.cpp
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#include "AbstractRRGtoFAConverter.h"
+
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractRRGtoFAConverter::AbstractRRGtoFAConverter( const RightRegularGrammar & rrg ) : m_grammar( rrg )
+{
+
+}
+
+AbstractRRGtoFAConverter::~AbstractRRGtoFAConverter()
+{
+
+}
+
+} /* namespace conversions */

aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h

+/*
+ * AbstractRRGtoFAConverter.h
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#ifndef ABSTRACTRRGTOFACONVERTER_H_
+#define ABSTRACTRRGTOFACONVERTER_H_
+
+#include <grammar/Regular/RightRegularGrammar.h>
+
+#include "../AbstractRGtoFAConverter.h"
+
+namespace conversions
+{
+
+class AbstractRRGtoFAConverter: public conversions::AbstractRGtoFAConverter
+{
+public:
+    virtual ~AbstractRRGtoFAConverter( void );
+
+protected:
+    AbstractRRGtoFAConverter( const grammar::RightRegularGrammar & rrg );
+    const grammar::RightRegularGrammar & m_grammar;
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTRRGTOFACONVERTER_H_ */

aconversions/src/rg2fa/RRGtoFAConverter.cpp → aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp

@@ -7,7 +7,7 @@ using namespace grammar;
 namespace conversions
 {
-RRGtoFAConverter::RRGtoFAConverter( const RightRegularGrammar & grammar ) : AbstractRGtoFAConverter( grammar )
+RRGtoFAConverter::RRGtoFAConverter( const RightRegularGrammar & grammar ) : AbstractRRGtoFAConverter( grammar )
 {
     //TODO: if is not RRG throw Exception
 }
@@ -20,8 +20,11 @@ RRGtoFAConverter::~RRGtoFAConverter( void )
 FSM RRGtoFAConverter::convert( void )
 {
-    createInputAlphabet( );
-    createStates( );
+    for( const auto & symbol : m_grammar.getTerminalSymbols( ) )
+        m_automaton.addInputSymbol( symbol );
+
+    for( const auto & symbol : m_grammar.getNonTerminalSymbols( ) )
+        m_automaton.addState( State( symbol.getSymbol( ) ) );
     const State & AState = m_automaton.createUniqueState( "A", true );

aconversions/src/rg2fa/RRGtoFAConverter.h → aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h

 #ifndef __RRGTOFACONVERTER_H__
 #define __RRGTOFACONVERTER_H__
-#include <grammar/Regular/RightRegularGrammar.h>
-#include <automaton/FSM/FSM.h>
-
-#include "AbstractRGtoFAConverter.h"
+#include "AbstractRRGtoFAConverter.h"
 namespace conversions
 {
-class RRGtoFAConverter : public AbstractRGtoFAConverter
+class RRGtoFAConverter : public AbstractRRGtoFAConverter
 {
 public:
     RRGtoFAConverter( const grammar::RightRegularGrammar & grammar );

aconversions/src/rg2re/AbstractRGtoREConverter.cpp

@@ -7,12 +7,10 @@
 #include "AbstractRGtoREConverter.h"
-using namespace grammar;
-
 namespace conversions
 {
-AbstractRGtoREConverter::AbstractRGtoREConverter( const RegularGrammar & grammar ) : m_grammar( grammar )
+AbstractRGtoREConverter::AbstractRGtoREConverter( void )
 {
 }

aconversions/src/rg2re/AbstractRGtoREConverter.h

@@ -8,7 +8,6 @@
 #ifndef ABSTRACTRGTORECONVERTER_H_
 #define ABSTRACTRGTORECONVERTER_H_
-#include <grammar/Regular/RegularGrammar.h>
 #include <regexp/RegExp.h>
 #include "../abstract/Conversion.h"
@@ -23,9 +22,8 @@ public:
     virtual ~AbstractRGtoREConverter( void );
 protected:
-    AbstractRGtoREConverter( const grammar::RegularGrammar& grammar );
-    const grammar::RegularGrammar& m_grammar;
+    AbstractRGtoREConverter( void );
     regexp::RegExp m_re;
 };

aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp

+/*
+ * AbstractLRGtoREConverter.cpp
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#include "AbstractLRGtoREConverter.h"
+
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractLRGtoREConverter::AbstractLRGtoREConverter( const LeftRegularGrammar & lrg ) : m_grammar( lrg )
+{
+
+}
+
+AbstractLRGtoREConverter::~AbstractLRGtoREConverter( void )
+{
+
+}
+
+} /* namespace conversions */

aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h

+/*
+ * AbstractLRGtoREConverter.h
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#ifndef ABSTRACTLRGTORECONVERTER_H_
+#define ABSTRACTLRGTORECONVERTER_H_
+
+#include <grammar/Regular/LeftRegularGrammar.h>
+
+#include "../AbstractRGtoREConverter.h"
+
+namespace conversions
+{
+
+class AbstractLRGtoREConverter: public AbstractRGtoREConverter
+{
+public:
+    virtual ~AbstractLRGtoREConverter( void );
+
+protected:
+    AbstractLRGtoREConverter( const grammar::LeftRegularGrammar & lrg );
+    const grammar::LeftRegularGrammar & m_grammar;
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTLRGTORECONVERTER_H_ */

aconversions/src/rg2re/LRGAlgebraic.cpp → aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp

@@ -14,7 +14,7 @@ using namespace regexp;
 namespace conversions
 {
-LRGAlgebraic::LRGAlgebraic( const LeftRegularGrammar & rg ) : AbstractRGtoREConverter( rg )
+LRGAlgebraic::LRGAlgebraic( const LeftRegularGrammar & rg ) : AbstractLRGtoREConverter( rg )
 {
 }

aconversions/src/rg2re/LRGAlgebraic.h → aconversions/src/rg2re/lrg2re/LRGAlgebraic.h

@@ -8,16 +8,13 @@
 #ifndef LRGALGEBRAIC_H_
 #define LRGALGEBRAIC_H_
-#include <grammar/Regular/LeftRegularGrammar.h>
-#include <regexp/RegExp.h>
-
-#include "../shared/equations/LeftRegularEquationSolver.h"
-#include "AbstractRGtoREConverter.h"
+#include "../../shared/equations/LeftRegularEquationSolver.h"
+#include "AbstractLRGtoREConverter.h"
 namespace conversions
 {
-class LRGAlgebraic: public AbstractRGtoREConverter
+class LRGAlgebraic: public AbstractLRGtoREConverter
 {
 public:
     LRGAlgebraic( const grammar::LeftRegularGrammar & rg );

aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp

+/*
+ * AbstractRRGtoREConverter.cpp
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#include "AbstractRRGtoREConverter.h"
+
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractRRGtoREConverter::AbstractRRGtoREConverter( const RightRegularGrammar & rrg ) : m_grammar( rrg )
+{
+
+}
+
+AbstractRRGtoREConverter::~AbstractRRGtoREConverter( void )
+{
+
+}
+
+} /* namespace conversions */

aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h

+/*
+ * AbstractRRGtoREConverter.h
+ *
+ *  Created on: 16. 3. 2014
+ *      Author: tomas
+ */
+
+#ifndef ABSTRACTRRGTORECONVERTER_H_
+#define ABSTRACTRRGTORECONVERTER_H_
+
+#include <grammar/Regular/RightRegularGrammar.h>
+
+#include "../AbstractRGtoREConverter.h"
+
+namespace conversions
+{
+
+class AbstractRRGtoREConverter: public AbstractRGtoREConverter
+{
+public:
+    virtual ~AbstractRRGtoREConverter( void );
+
+protected:
+    AbstractRRGtoREConverter( const grammar::RightRegularGrammar & rrg );
+
+    const grammar::RightRegularGrammar & m_grammar;
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTRRGTORECONVERTER_H_ */

aconversions/src/rg2re/RRGAlgebraic.cpp → aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp

@@ -14,7 +14,7 @@ using namespace regexp;
 namespace conversions
 {
-RRGAlgebraic::RRGAlgebraic( const RightRegularGrammar & rg ) : AbstractRGtoREConverter( rg )
+RRGAlgebraic::RRGAlgebraic( const RightRegularGrammar & rg ) : AbstractRRGtoREConverter( rg )
 {
 }

aconversions/src/rg2re/RRGAlgebraic.h → aconversions/src/rg2re/rrg2re/RRGAlgebraic.h

@@ -8,16 +8,13 @@
 #ifndef RRGALGEBRAIC_H_
 #define RRGALGEBRAIC_H_
-#include <grammar/Regular/RightRegularGrammar.h>
-#include <regexp/RegExp.h>
-
-#include "../shared/equations/RightRegularEquationSolver.h"
-#include "AbstractRGtoREConverter.h"
+#include "../../shared/equations/RightRegularEquationSolver.h"
+#include "AbstractRRGtoREConverter.h"
 namespace conversions
 {
-class RRGAlgebraic: public AbstractRGtoREConverter
+class RRGAlgebraic: public AbstractRRGtoREConverter
 {
 public:
     RRGAlgebraic( const grammar::RightRegularGrammar & rg );