is-valid.hh

Go to the documentation of this file.

#ifndef VCSN_ALGOS_IS_VALID_HH
# define VCSN_ALGOS_IS_VALID_HH

# include <stdexcept>
# include <type_traits>
# include <utility>

# include <vcsn/algos/copy.hh>
# include <vcsn/algos/is-eps-acyclic.hh>
# include <vcsn/algos/is-proper.hh>
# include <vcsn/algos/proper.hh>
# include <vcsn/algos/strip.hh>
# include <vcsn/core/kind.hh>
# include <vcsn/misc/star_status.hh>
# include <vcsn/misc/direction.hh>

namespace vcsn
{

  /*----------------.
  | is_valid(aut).  |
  `----------------*/

  namespace detail
  {

    template <typename Aut>
    typename Aut::element_type::automaton_nocv_t
    absval(const Aut& aut)
    {
      auto res = copy(aut);
      // Apply absolute value to the weight of each transition.
      const auto& ws = *aut->weightset();
      for (auto t: res->transitions())
        res->set_weight(t, ws.abs(res->weight_of(t)));
      return res;
    }

    template <typename Aut>
    bool is_properable(Aut&& aut)
    {
      return in_situ_remover(aut);
    }


    template <typename Aut, bool has_one = context_t_of<Aut>::has_one()>
    class is_valider
    {
    public:
      using automaton_t = typename std::remove_cv<Aut>::type;
      using weightset_t = weightset_t_of<automaton_t>;

      static bool is_valid(const automaton_t& aut)
      {
        return is_valid_<weightset_t::star_status()>(aut);
      }

    private:
      template <star_status_t Status>
      static
      typename std::enable_if<Status == star_status_t::TOPS,
                              bool>::type
      is_valid_(const automaton_t& aut)
      {
        return (is_proper(aut)
                || is_eps_acyclic(aut)
                || is_properable(copy(aut)));
      }

      template <star_status_t Status>
      static
      typename std::enable_if<Status == star_status_t::ABSVAL,
                              bool>::type
      is_valid_(const automaton_t& aut)
      {
        return (is_proper(aut)
                || is_eps_acyclic(aut)
                || is_properable(absval(aut)));
      }

      template <star_status_t Status>
      static
      typename std::enable_if<Status == star_status_t::STARRABLE,
                              bool>::type
      is_valid_(const automaton_t&)
      {
        return true;
      }

      template <star_status_t Status>
      static
      typename std::enable_if<Status == star_status_t::NON_STARRABLE,
                              bool>::type
      is_valid_(const automaton_t& aut)
      {
        return is_proper(aut) || is_eps_acyclic(aut);
      }
    };

    template <typename Aut>
    class is_valider<Aut, false>
    {
      using automaton_t = typename std::remove_cv<Aut>::type;
    public:
      static constexpr bool is_valid(const automaton_t&)
      {
        return true;
      }
    };

  }


  template <typename Aut>
  inline
  bool is_valid(const Aut& aut)
  {
    return detail::is_valider<Aut>::is_valid(aut);
  }

  namespace dyn
  {
    namespace detail
    {
      template <typename Aut>
      bool is_valid(const automaton& aut)
      {
        const auto& a = aut->as<Aut>();
        return is_valid(strip(a));
      }

     REGISTER_DECLARE(is_valid,
                      (const automaton& aut) -> bool);
    }
  }
} // namespace vcsn

#endif // !VCSN_ALGOS_IS_VALID_HH