identities.hh

Go to the documentation of this file.

#pragma once

#include <iostream>
#include <string>

#include <vcsn/core/join.hh>
#include <vcsn/misc/export.hh>

namespace vcsn LIBVCSN_API
{
  namespace rat
  {
    class identities
    {
    public:
      using self_t = identities;

      enum ids_t
        {
          none,

          trivial,

          associative,

          linear,

          distributive,

          agressive,

          deflt = linear,
        };

      identities(ids_t id = deflt)
        : ids_{id}
      {}

      identities(const std::string& i);

      identities(const char* cp);

      ids_t ids() const
      {
        return ids_;
      }

      bool is_agressive() const
      {
        return agressive <= ids_;
      }

      bool is_associative() const
      {
        return associative <= ids_;
      }

      bool is_distributive() const
      {
        return ids_ == distributive;
      }

      bool is_linear() const
      {
        return linear <= ids_;
      }

      bool is_trivial() const
      {
        return trivial <= ids_;
      }

      operator bool() const
      {
        return ids_ != none;
      }

      bool operator<(self_t that) const
      {
        return ids_ < that.ids_;
      }

      bool operator==(self_t that) const
      {
        return ids_ == that.ids_;
      }

      bool operator!=(self_t that) const
      {
        return !operator==(that);
      }

    private:
      ids_t ids_;
    };

    std::string to_string(identities i);

    std::istream& operator>>(std::istream& is, identities& i);

    std::ostream& operator<<(std::ostream& os, identities i);

    identities meet(identities i1, identities i2);
  } // namespace rat

  namespace detail
  {
    template <>
    struct join_impl<rat::identities, rat::identities>
    {
      using type = rat::identities;
      static type join(rat::identities i1, rat::identities i2)
      {
        return std::max(i1, i2);
      }
    };
  }
} // namespace vcsn