diff --git a/aconversions/src/re2fa/Brzozowski.cpp b/aconversions/src/re2fa/Brzozowski.cpp
index 42beed5d6e6743e27b1a36fa46a7cdd1c5dcd7c3..3c2048ace647e15a55b64f66c320316b61ee48f7 100644
--- a/aconversions/src/re2fa/Brzozowski.cpp
+++ b/aconversions/src/re2fa/Brzozowski.cpp
@@ -6,7 +6,6 @@
*/
#include "Brzozowski.h"
-#include <iostream>
using namespace alib;
using namespace automaton;
@@ -31,7 +30,7 @@ FSM Brzozowski::convert( void )
// 1.
RegExp V = opt.optimize( m_re );
- set<RegExpSymbol> alphabet = RegExpAlphabet::getSymbols( m_re );
+ set<alphabet::Symbol> alphabet = m_re.getAlphabet( );
set<RegExp> Q = { V };
deque<set<RegExp>> Qi;
@@ -129,7 +128,7 @@ const State & Brzozowski::StateBuilder::getState( const RegExp & re ) const
{
auto state = m_states.find( re );
if( state != m_states.end() ) return state->second;
-
+
throw AlibException( "Brzozowski::StateBuilder - Regular expression not found!" );
}
diff --git a/aconversions/src/re2fa/Brzozowski.h b/aconversions/src/re2fa/Brzozowski.h
index 2263d402e0c979cfbdc39c65e3557a8d8436ea21..d455ff530834d194509eca2dd3a461b0c044642c 100644
--- a/aconversions/src/re2fa/Brzozowski.h
+++ b/aconversions/src/re2fa/Brzozowski.h
@@ -19,7 +19,6 @@
#include "RegExpDerivation.h"
-#include "RegExpAlphabet.h"
#include "RegExpOptimize.h"
namespace conversions
diff --git a/aconversions/src/re2fa/Glushkov.cpp b/aconversions/src/re2fa/Glushkov.cpp
index 98fa8e88eafa4aed3cbabba49ef1a26b6a5f4c00..8d123383459bee955c720e74c5fef057989d1526 100644
--- a/aconversions/src/re2fa/Glushkov.cpp
+++ b/aconversions/src/re2fa/Glushkov.cpp
@@ -31,7 +31,7 @@ FSM Glushkov::convert( void )
// step 1
initNumberSymbols( );
- for( const auto & symbol : RegExpAlphabet::getSymbols( m_re ) )
+ for( const auto & symbol : m_re.getAlphabet( ) )
m_fsm.addInputSymbol( symbol.getSymbol( ) );
// steps 2, 3, 4
@@ -73,7 +73,7 @@ void Glushkov::initNumberSymbols( void )
{
int id = 1;
- for( const auto & symb : RegExpAlphabet::getSymbolsListInOrder( m_re ) )
+ for( const auto & symb : GlushkovTraversal::getSymbolsListInOrder( m_re ) )
m_numberedSymbols.insert( pair<const RegExpSymbol*, NumberedSymbol>( symb, NumberedSymbol( symb, id ++ ) ) );
}
diff --git a/aconversions/src/re2fa/Glushkov.h b/aconversions/src/re2fa/Glushkov.h
index 6fdc3d9f0aed6111626015910cc66b6f2531427e..d5002c13d4151d6cba9a35449c0d18cce16eae76 100644
--- a/aconversions/src/re2fa/Glushkov.h
+++ b/aconversions/src/re2fa/Glushkov.h
@@ -18,8 +18,6 @@
#include "AbstractREtoFAConverter.h"
#include "../shared/GlushkovTraversal.h"
-#include "RegExpAlphabet.h"
-
namespace conversions
{
diff --git a/aconversions/src/re2fa/Thompson.cpp b/aconversions/src/re2fa/Thompson.cpp
index f5f72e31327a4fec6a5acf2fc8409c1baf7be7d0..e0e17d6cc158beaa4adcecbbf226e2c56af1d331 100644
--- a/aconversions/src/re2fa/Thompson.cpp
+++ b/aconversions/src/re2fa/Thompson.cpp
@@ -26,7 +26,7 @@ Thompson::~Thompson( void )
FSM Thompson::convert( void )
{
- for( const auto & symbol : RegExpAlphabet::getSymbols( m_re ) )
+ for( const auto & symbol : m_re.getAlphabet( ) )
m_fsm.addInputSymbol( symbol.getSymbol( ) );
SubexpressionTails st = processRegExpNode( m_re.getRegExp( ) );
diff --git a/aconversions/src/re2fa/Thompson.h b/aconversions/src/re2fa/Thompson.h
index 76d5a5d15dd2e046e5473f91f6f62f1ab6a763de..3ba43932c739957018dbd7873319988d3ef9e3ae 100644
--- a/aconversions/src/re2fa/Thompson.h
+++ b/aconversions/src/re2fa/Thompson.h
@@ -17,8 +17,6 @@
#include "AbstractREtoFAConverter.h"
-#include "RegExpAlphabet.h"
-
namespace conversions
{
diff --git a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp
index afd359c6269f3745c2cdc29573882736ce2692aa..a0798d9c29f71e58f993d2a10089b8b6d7f8b67e 100644
--- a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp
+++ b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp
@@ -6,7 +6,6 @@
*/
#include "BrzozowskiDerivationRRG.h"
-#include <iostream>
using namespace alib;
using namespace alphabet;
@@ -33,7 +32,7 @@ RightRegularGrammar BrzozowskiDerivationRRG::convert( void )
// 1.
RegExp V = opt.optimize( m_re );
- set<RegExpSymbol> alphabet = RegExpAlphabet::getSymbols( m_re );
+ set<Symbol> alphabet = m_re.getAlphabet( );
set<RegExp> N = { V };
deque<set<RegExp>> Ni;
diff --git a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h
index a656f8c79f63089b93cb83314307e9ff42f8c821..47b1546dccf67f8af173d41848b4b0dc527063b4 100644
--- a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h
+++ b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h
@@ -18,7 +18,6 @@
#include "AbstractREtoRRGConverter.h"
-#include "RegExpAlphabet.h"
#include "RegExpOptimize.h"
#include "RegExpDerivation.h"
diff --git a/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp b/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp
index 4416d1fcb63c7107721d7938be4dc5c76583550f..845294fd4ec7a6884888b745d39aae45b33a7ee2 100644
--- a/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp
+++ b/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp
@@ -29,7 +29,7 @@ GlushkovRRG::~GlushkovRRG( void )
RightRegularGrammar GlushkovRRG::convert( void )
{
// step 1
- for( const auto & symbol : RegExpAlphabet::getSymbols( m_re ) )
+ for( const auto & symbol : m_re.getAlphabet( ) )
m_grammar.addTerminalSymbol( symbol.getSymbol( ) );
initNumberSymbols( );
@@ -102,7 +102,7 @@ void GlushkovRRG::initNumberSymbols( void )
{
int id = 1;
- for( const auto & symb : RegExpAlphabet::getSymbolsListInOrder( m_re ) )
+ for( const auto & symb : GlushkovTraversal::getSymbolsListInOrder( m_re ) )
m_numberedSymbols.insert( pair<const RegExpSymbol*, NumberedSymbol>( symb, NumberedSymbol( symb, m_grammar, id ++ ) ) );
}
diff --git a/aconversions/src/re2rg/re2rrg/GlushkovRRG.h b/aconversions/src/re2rg/re2rrg/GlushkovRRG.h
index 78d48eb00c8d56fb8712abac3183ed119bafb31d..1588df99f38517e42553de85f9ca0056e3557fa9 100644
--- a/aconversions/src/re2rg/re2rrg/GlushkovRRG.h
+++ b/aconversions/src/re2rg/re2rrg/GlushkovRRG.h
@@ -16,8 +16,6 @@
#include "../../shared/GlushkovTraversal.h"
#include "AbstractREtoRRGConverter.h"
-#include "RegExpAlphabet.h"
-
namespace conversions
{
diff --git a/aconversions/src/shared/GlushkovTraversal.cpp b/aconversions/src/shared/GlushkovTraversal.cpp
index d9971752cada83c5685145485295664aadf4d65d..897e106e43990415aacf34c3c69a62ec4f122c20 100644
--- a/aconversions/src/shared/GlushkovTraversal.cpp
+++ b/aconversions/src/shared/GlushkovTraversal.cpp
@@ -293,4 +293,59 @@ set<GlushkovTraversal::Neighbours> GlushkovTraversal::getNeighbours( const RegEx
return set<Neighbours>( );
}
+// ----------------------------------------------------------------------------
+
+list<const RegExpSymbol*> GlushkovTraversal::getSymbolsListInOrder( const RegExp & re )
+{
+ list<const RegExpSymbol*> alphabet;
+
+ getSymbolsListInOrder( re.getRegExp( ), alphabet );
+
+ return alphabet;
+}
+
+void GlushkovTraversal::getSymbolsListInOrder( const RegExpElement * node, list<const RegExpSymbol*> & alphabet )
+{
+ const Alternation* alternation = dynamic_cast<const Alternation*>( node );
+ const Concatenation* concatenation = dynamic_cast<const Concatenation*>( node );
+ const Iteration* iteration = dynamic_cast<const Iteration*>( node );
+ const RegExpSymbol* symbol = dynamic_cast<const RegExpSymbol*>( node );
+ const RegExpEmpty * empty = dynamic_cast<const RegExpEmpty*>( node );
+ const RegExpEpsilon* eps = dynamic_cast<const RegExpEpsilon*>( node );
+
+ if( symbol )
+ {
+ alphabet.push_back( symbol );
+ return;
+ }
+
+ else if( alternation )
+ {
+ for( const auto & element : alternation->getElements( ) )
+ getSymbolsListInOrder( element, alphabet );
+ return;
+ }
+
+ else if( concatenation )
+ {
+ for( const auto & element : concatenation->getElements( ) )
+ getSymbolsListInOrder( element, alphabet );
+ return;
+ }
+
+ else if( iteration )
+ {
+ getSymbolsListInOrder( iteration->getElement( ), alphabet );
+ return;
+ }
+
+ else if( empty )
+ return;
+
+ else if( eps )
+ return;
+
+ throw AlibException( "GlushkovTraversal::getSymbolsListInOrder() - unknown RegExpElement node" );
+}
+
} /* namespace conversions */
diff --git a/aconversions/src/shared/GlushkovTraversal.h b/aconversions/src/shared/GlushkovTraversal.h
index 09c7928214517283f1708a9e49fc98eb311edecc..018bbb159badc4c8c4c39a31659838b376353ccd 100644
--- a/aconversions/src/shared/GlushkovTraversal.h
+++ b/aconversions/src/shared/GlushkovTraversal.h
@@ -9,6 +9,7 @@
#define GLUSHKOVTRAVERSAL_H_
#include <set>
+#include <list>
#include <regexp/RegExp.h>
#include <regexp/RegExpElement.h>
@@ -56,6 +57,14 @@ public:
*/
static std::set<Neighbours> getNeighbours( const regexp::RegExp & re );
+ /**
+ * Returns pointers to RegExpSymbols in order as they occur in regexp.
+ *
+ * @param re RegExp to probe
+ * @return symbols of regexp tree in order of they occurence in regexp.
+ */
+ static std::list<const regexp::RegExpSymbol*> getSymbolsListInOrder( const regexp::RegExp & re );
+
private:
static std::set<const regexp::RegExpSymbol*> getLeftmostSymbolsInTree( const regexp::RegExpElement * node );
static std::set<const regexp::RegExpSymbol*> getLeftmostSymbolsInTree( const regexp::Alternation * node );
@@ -80,6 +89,11 @@ private:
static std::set<Neighbours> getNeighbours( const regexp::RegExpSymbol * node );
static std::set<Neighbours> getNeighbours( const regexp::RegExpEmpty * node );
static std::set<Neighbours> getNeighbours( const regexp::RegExpEpsilon * node );
+
+ /**
+ * @see GlushkovTraversal::getSymbolsListInOrder()
+ */
+ static void getSymbolsListInOrder( const regexp::RegExpElement * node, std::list<const regexp::RegExpSymbol*> & alphabet );
};
} /* namespace conversions */
diff --git a/alib/src/regexp/Alternation.cpp b/alib/src/regexp/Alternation.cpp
index aac9219f55ed47a13bc213dfcab3fb030db76925..7a92bf6f651b3e2026cf2af601ae3732ecf10b51 100644
--- a/alib/src/regexp/Alternation.cpp
+++ b/alib/src/regexp/Alternation.cpp
@@ -99,6 +99,11 @@ bool Alternation::operator==(const Alternation& other) const {
return true;
}
+void Alternation::getAlphabet( std::set<alphabet::Symbol> & alphabet ) const {
+ for(const auto& child : this->elements)
+ child->getAlphabet(alphabet);
+}
+
bool Alternation::containsEmptyString() const {
for(const auto& e : getElements())
if(e->containsEmptyString())
diff --git a/alib/src/regexp/Alternation.h b/alib/src/regexp/Alternation.h
index d5f5c94622140975754787c63b6e832004845260..320c7fa6da1ab9d9a54e92aa9353db0d93115f5d 100644
--- a/alib/src/regexp/Alternation.h
+++ b/alib/src/regexp/Alternation.h
@@ -51,6 +51,11 @@ public:
virtual bool operator<(const Alternation&) const;
virtual bool operator==(const Alternation&) const;
+ /**
+ * @copydoc RegExpElement::getAlphabet()
+ */
+ virtual void getAlphabet( std::set<alphabet::Symbol> & alphabet ) const;
+
/**
* @copydoc RegExpElement::containsEmptyString() const
*/
diff --git a/alib/src/regexp/Concatenation.cpp b/alib/src/regexp/Concatenation.cpp
index 087f14074e913757b1e5df8eb53da2c03c3532b8..b678958ac903898e5d8e5dabdab98066f8ed7cb5 100644
--- a/alib/src/regexp/Concatenation.cpp
+++ b/alib/src/regexp/Concatenation.cpp
@@ -95,6 +95,11 @@ bool Concatenation::operator==(const Concatenation& other) const {
return true;
}
+void Concatenation::getAlphabet( std::set<alphabet::Symbol> & alphabet ) const {
+ for(const auto& child : this->elements)
+ child->getAlphabet(alphabet);
+}
+
bool Concatenation::containsEmptyString() const {
for(const auto& e : getElements())
if( ! e->containsEmptyString())
diff --git a/alib/src/regexp/Concatenation.h b/alib/src/regexp/Concatenation.h
index 955c6b765b7667fb1fd624b1236e866367450a79..f195f3e3cba21540413a4517c256f57d46e5d8ae 100644
--- a/alib/src/regexp/Concatenation.h
+++ b/alib/src/regexp/Concatenation.h
@@ -50,6 +50,11 @@ public:
virtual bool operator<(const Concatenation&) const;
virtual bool operator==(const Concatenation&) const;
+ /**
+ * @copydoc RegExpElement::getAlphabet()
+ */
+ virtual void getAlphabet( std::set<alphabet::Symbol> & alphabet ) const;
+
/**
* @copydoc RegExpElement::containsEmptyString() const
*/
diff --git a/alib/src/regexp/Iteration.cpp b/alib/src/regexp/Iteration.cpp
index 3495f4a6bc7ce31427106dad88f49e1bce2cd91e..888985fa098e84a3fd3232911854a5a01d26f23b 100644
--- a/alib/src/regexp/Iteration.cpp
+++ b/alib/src/regexp/Iteration.cpp
@@ -93,6 +93,10 @@ bool Iteration::operator==(const Iteration& other) const {
return *(this->element) == *(other.element);
}
+void Iteration::getAlphabet( std::set<alphabet::Symbol> & alphabet ) const {
+ element->getAlphabet( alphabet );
+}
+
bool Iteration::containsEmptyString() const {
return true;
}
diff --git a/alib/src/regexp/Iteration.h b/alib/src/regexp/Iteration.h
index f5e1f2c5c60e8c89481dfb0ce06be90f8feb4548..9b3e8c50727e6320de921393565917172033e720 100644
--- a/alib/src/regexp/Iteration.h
+++ b/alib/src/regexp/Iteration.h
@@ -58,6 +58,11 @@ public:
virtual bool operator<(const Iteration&) const;
virtual bool operator==(const Iteration&) const;
+ /**
+ * @copydoc RegExpElement::getAlphabet()
+ */
+ virtual void getAlphabet( std::set<alphabet::Symbol> & alphabet ) const;
+
/**
* @copydoc RegExpElement::containsEmptyString() const
*/
diff --git a/alib/src/regexp/RegExp.cpp b/alib/src/regexp/RegExp.cpp
index 246a5ee7ebe1b436ba90201d255cdc9bf26def24..5f7571ae1fa06a9f6119408856f541ebdf46d86c 100644
--- a/alib/src/regexp/RegExp.cpp
+++ b/alib/src/regexp/RegExp.cpp
@@ -70,6 +70,15 @@ void RegExp::setRegExp(RegExpElement* regExp) {
this->regExp = regExp;
}
+set<alphabet::Symbol> RegExp::getAlphabet(void) const{
+ set<alphabet::Symbol> alphabet;
+
+ if(regExp)
+ regExp->getAlphabet( alphabet );
+
+ return alphabet;
+}
+
bool RegExp::isEmpty() const {
return regExp == NULL || regExp->isEmpty();
}
diff --git a/alib/src/regexp/RegExp.h b/alib/src/regexp/RegExp.h
index 9f6e62484221f68dd9c5f9be6787aff70df18596..528cfb5024f57cf12efd24881224c62766641d6a 100644
--- a/alib/src/regexp/RegExp.h
+++ b/alib/src/regexp/RegExp.h
@@ -14,6 +14,8 @@
#include "RegExpElement.h"
#include "RegExpEmpty.h"
+#include "../alphabet/Symbol.h"
+
namespace regexp {
using namespace std;
@@ -55,6 +57,12 @@ public:
*/
void setRegExp(RegExpElement* regExp);
+ /**
+ * Gets alphabet symbols used in RegExp.
+ * @return set of alphabet symbols used in regexp.
+ */
+ std::set<alphabet::Symbol> getAlphabet(void) const;
+
/**
* @return true if regexp represents empty language
*/
diff --git a/alib/src/regexp/RegExpElement.cpp b/alib/src/regexp/RegExpElement.cpp
index fc07c4c1f017c38e277ec1b9717f54ba53d569a3..7dddc07ea2a911d2c2cf3076dce0eed3f31ab35a 100644
--- a/alib/src/regexp/RegExpElement.cpp
+++ b/alib/src/regexp/RegExpElement.cpp
@@ -75,4 +75,8 @@ bool RegExpElement::operator==(const RegExpEmpty& other) const {
return false;
}
+void RegExpElement::getAlphabet( std::set<alphabet::Symbol> & alphabet ) const {
+ // default: do nothing.
+}
+
} /* namespace regexp */
diff --git a/alib/src/regexp/RegExpElement.h b/alib/src/regexp/RegExpElement.h
index 186fe7c3b06d9d98e5bcde492c6f96e5f5bdff39..2337635f61546c4bd0f17336dd74e105a62aeee6 100644
--- a/alib/src/regexp/RegExpElement.h
+++ b/alib/src/regexp/RegExpElement.h
@@ -8,6 +8,9 @@
#ifndef REGEXPELEMENT_H_
#define REGEXPELEMENT_H_
+#include <set>
+#include "../alphabet/Symbol.h"
+
namespace regexp {
using namespace std;
@@ -65,6 +68,13 @@ public:
* @return true if this subtree describes empty language
*/
virtual bool isEmpty() const = 0;
+
+ /**
+ * Traverses the regexp tree to get alphabet symbols used.
+ *
+ * @param alphabet All alphabet symbols encountered are added into this set
+ */
+ virtual void getAlphabet( std::set<alphabet::Symbol> & alphabet ) const;
};
} /* namespace regexp */
diff --git a/alib/src/regexp/RegExpSymbol.cpp b/alib/src/regexp/RegExpSymbol.cpp
index f71609fc715cc47d51ebbd7cab0a53f148e8fa1a..140eee9f5210f0e097601e6a24c1fae478a85ff6 100644
--- a/alib/src/regexp/RegExpSymbol.cpp
+++ b/alib/src/regexp/RegExpSymbol.cpp
@@ -62,6 +62,10 @@ bool RegExpSymbol::isEmpty() const {
return false;
}
+void RegExpSymbol::getAlphabet( std::set<alphabet::Symbol> & alphabet ) const {
+ alphabet.insert( Symbol( this->getSymbol( ) ) );
+}
+
const string& RegExpSymbol::getSymbol() const {
return this->symbol;
}
diff --git a/alib/src/regexp/RegExpSymbol.h b/alib/src/regexp/RegExpSymbol.h
index ce0a6b60552c688c488819d4fb11a388efbd2d71..167cc5f1da52029f256ce8b4e668410024713e73 100644
--- a/alib/src/regexp/RegExpSymbol.h
+++ b/alib/src/regexp/RegExpSymbol.h
@@ -41,14 +41,21 @@ public:
virtual bool operator<(const RegExpSymbol&) const;
virtual bool operator==(const RegExpSymbol&) const;
+ /**
+ * @copydoc RegExpElement::getAlphabet()
+ */
+ virtual void getAlphabet( std::set<alphabet::Symbol> & alphabet ) const;
+
+ /**
+ * @return Returns string representation of symbol.
+ */
+ const string& getSymbol() const;
/**
* @copydoc RegExpElement::containsEmptyString() const
*/
virtual bool containsEmptyString() const;
- const string& getSymbol() const;
-
/**
* @copydoc RegExpElement::isEmpty() const
*/
diff --git a/libaregexptree/src/RegExpAlphabet.cpp b/libaregexptree/src/RegExpAlphabet.cpp
deleted file mode 100644
index d39a7183fa6682d5c21a19f82b1acff33c21b5ce..0000000000000000000000000000000000000000
--- a/libaregexptree/src/RegExpAlphabet.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "RegExpAlphabet.h"
-
-using namespace alib;
-using namespace alphabet;
-using namespace regexp;
-using namespace std;
-
-set<RegExpSymbol> RegExpAlphabet::getSymbols( const RegExp & re )
-{
- set<RegExpSymbol> alphabet;
-
- for( const auto & symbol : getSymbolsListInOrder( re ) )
- alphabet.insert( RegExpSymbol( symbol->getSymbol( ) ) );
-
- return alphabet;
-}
-
-list<const RegExpSymbol*> RegExpAlphabet::getSymbolsListInOrder( const RegExp & re )
-{
- list<const RegExpSymbol*> alphabet;
- searchSymbols( re.getRegExp( ), alphabet );
- return alphabet;
-}
-
-
-void RegExpAlphabet::searchSymbols( const RegExpElement * node, list<const RegExpSymbol*> & alphabet )
-{
- const Alternation* alternation = dynamic_cast<const Alternation*>( node );
- const Concatenation* concatenation = dynamic_cast<const Concatenation*>( node );
- const Iteration* iteration = dynamic_cast<const Iteration*>( node );
- const RegExpSymbol* symbol = dynamic_cast<const RegExpSymbol*>( node );
- const RegExpEmpty * empty = dynamic_cast<const RegExpEmpty*>( node );
- const RegExpEpsilon* eps = dynamic_cast<const RegExpEpsilon*>( node );
-
- if( symbol )
- {
- alphabet.push_back( symbol );
- return;
- }
-
- else if( alternation )
- {
- for( const auto & element : alternation->getElements( ) )
- searchSymbols( element, alphabet );
- return;
- }
-
- else if( concatenation )
- {
- for( const auto & element : concatenation->getElements( ) )
- searchSymbols( element, alphabet );
- return;
- }
-
- else if( iteration )
- {
- searchSymbols( iteration->getElement( ), alphabet );
- return;
- }
-
- else if( empty )
- return;
-
- else if( eps )
- return;
-
-
- throw AlibException( "RegExpAlphabet::traverseSymbols() - unknown RegExpElement node" );
-}
diff --git a/libaregexptree/src/RegExpAlphabet.h b/libaregexptree/src/RegExpAlphabet.h
deleted file mode 100644
index dcbd0e032c6f7ff76ffc1de860e5d801902f3264..0000000000000000000000000000000000000000
--- a/libaregexptree/src/RegExpAlphabet.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef REGEXPALPHABET_H_
-#define REGEXPALPHABET_H_
-
-#include <regexp/RegExp.h>
-#include <regexp/RegExpElements.h>
-
-#include <AlibException.h>
-
-#include <list>
-#include <set>
-
-/**
- * "Getters" for regular expression alphabet.
- */
-class RegExpAlphabet
-{
-public:
- /**
- * Returns pointers to RegExpSymbols in order as they occur in regexp tree. Used in Glushkov algorithm.
- * @param re RegExp
- * @return symbols of regexp tree in order of they occurence in regexp.
- */
- static std::list<const regexp::RegExpSymbol*> getSymbolsListInOrder( const regexp::RegExp & re );
-
- /**
- * @param re RegExp
- * @return set of symbols appearing in regexp
- */
- static std::set<regexp::RegExpSymbol> getSymbols( const regexp::RegExp & re );
-
-private:
- /**
- * Traverse through regexp tree and store all encountered RegExpSymbols.
- *
- * @param alphabet list to insert symbols
- */
- static void searchSymbols( const regexp::RegExpElement * element, std::list<const regexp::RegExpSymbol*> & alphabet );
-};
-
-#endif /* REGEXPALPHABET_H_ */