expression.h

Go to the documentation of this file.

#ifndef REG_EXP_H
#define REG_EXP_H

#include <vector>

#include <unordered_map>

#include <string>

#include <memory>

namespace reg {
class dfa;

class expression {
public:

  typedef std::shared_ptr<expression const> exptr;
  static exptr const& spawnEmptySet();
  static exptr const& spawnEmptyString();
  static exptr const& spawnSymbol(char32_t symbol);
  static exptr const& spawnSymbol(std::string const& utf8Symbol);
  static exptr spawnKleene(exptr const& b, bool optimized = true, bool aggressive = false);
  static exptr spawnConcatenation(exptr const& l, exptr const& r, bool optimized = true, bool aggressive = false);
  static exptr spawnAlternation(exptr const& l, exptr const& r, bool optimized = true, bool aggressive = false);
  struct literals {
    char32_t const L, 
                   R, 
                   S, 
                   P, 
                   EPSILON, 
                   EMPTY; 

    literals(char32_t plus = U'+', char32_t empty = U'∅', char32_t epsilon = U'ε',
        char32_t star = U'*', char32_t rPar = U')', char32_t lPar = U'(')
        : L(lPar), R(rPar), S(star), P(plus), EPSILON(epsilon), EMPTY(empty){}
  };
  static exptr spawnFromString(std::u32string const& re, literals lits = literals(),
      bool optimized = false, bool aggressive = false);
  static exptr spawnFromString(std::string const& utf8Re, literals lits = literals(),
      bool optimized = false, bool aggressive = false);
  enum struct operation { empty, symbol, kleene, concatenation, alternation };
  size_t size() const;
  operation getOperation() const;
  bool operator==(expression const& r) const;
  bool operator!=(expression const& r) const;
  char32_t extractSymbol() const;
  std::string extractUtf8Symbol() const;
  std::u32string to_u32string() const;
  std::string to_string() const;
  std::vector<exptr>::const_iterator begin() const;
  std::vector<exptr>::const_iterator end() const;
private:
  expression();
  expression(char32_t symbol);
  expression(exptr const& l, exptr const& r, operation op);
  expression(exptr const& b);
  expression(expression& e) = delete;
  expression(expression&& e) = delete;
  expression& operator=(expression& e) = delete;
  expression& operator=(expression& e) const = delete;
  expression& operator=(expression&& e) = delete;
  expression& operator=(expression&& e) const = delete;
  static exptr empty;
  static std::unordered_map<char32_t, exptr> symbols;
  std::vector<exptr> const subExpressions;
  operation const op;
  std::unique_ptr<dfa const> mutable acceptingDfa;
  struct parser;
};
}
#endif