rwse.h

//
// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2016 James D. Mitchell
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef LIBSEMIGROUPS_SRC_RWSE_H_
#define LIBSEMIGROUPS_SRC_RWSE_H_

#include <algorithm>
#include <stack>
#include <string>
#include <utility>
#include <vector>

#include "elements.h"
#include "rws.h"

namespace libsemigroups {

  class RWSE : public Element {
   private:
    RWSE(RWS* rws, rws_word_t* w, bool reduce)
        : Element(Element::elm_t::RWSE), _rws(rws), _rws_word(w) {
      if (reduce) {
        _rws->rewrite(_rws_word);
      }
    }

   public:
    RWSE(RWS* rws, rws_word_t* w) : RWSE(rws, w, true) {
      LIBSEMIGROUPS_ASSERT(w != nullptr);
    }

    RWSE(RWS& rws, rws_word_t const& w) : RWSE(&rws, new rws_word_t(w)) {}

    RWSE(RWS& rws, letter_t const& a)
        : RWSE(&rws, RWS::letter_to_rws_word(a)) {}

    RWSE(RWS& rws, word_t const& w) : RWSE(&rws, RWS::word_to_rws_word(w)) {}

    bool operator==(Element const& that) const override {
      LIBSEMIGROUPS_ASSERT(_rws_word != nullptr);
      LIBSEMIGROUPS_ASSERT(static_cast<RWSE const&>(that)._rws_word != nullptr);
      return *(static_cast<RWSE const&>(that)._rws_word) == *(this->_rws_word);
    }

    // TODO should use the reduction ordering of RWS.
    bool operator<(const Element& that) const override;

    Element* really_copy(size_t increase_deg_by) const override;

    void copy(Element const* x) override;
    void swap(Element* x) override;

    void really_delete() override {
      delete _rws_word;
      _rws_word = nullptr;
    }

    size_t complexity() const override {
      return Semigroup::LIMIT_MAX;
    }

    size_t degree() const override {
      return 0;
    }

    Element* identity() const override {
      return new RWSE(_rws, new rws_word_t());
    }

    void cache_hash_value() const override {
      LIBSEMIGROUPS_ASSERT(_rws_word != nullptr);
      this->_hash_value = std::hash<rws_word_t>()(*_rws_word);
    }

    void redefine(Element const* x, Element const* y) override;

    rws_word_t const* get_rws_word() const {
      return _rws_word;
    }

   private:
    // TODO const!
    RWS*        _rws;
    rws_word_t* _rws_word;
  };
}  // namespace libsemigroups

#endif  // LIBSEMIGROUPS_SRC_RWSE_H_