copy.hh

Go to the documentation of this file.

#pragma once

#include <unordered_map>

#include <vcsn/algos/fwd.hh> // focus_automaton.
#include <vcsn/core/automaton-decorator.hh>
#include <vcsn/core/fwd.hh>
#include <vcsn/core/mutable-automaton.hh>
#include <vcsn/core/rat/copy.hh>
#include <vcsn/dyn/automaton.hh>
#include <vcsn/dyn/context.hh>
#include <vcsn/dyn/expression.hh>
#include <vcsn/misc/attributes.hh>
#include <vcsn/misc/set.hh>
#include <vcsn/misc/unordered_set.hh>

namespace vcsn
{

  /*------------------.
  | copy(automaton).  |
  `------------------*/

  namespace detail
  {
    template <typename AutIn, typename AutOut = AutIn>
    struct copier
    {
      using in_automaton_t = AutIn;
      using out_automaton_t = AutOut;

      using in_state_t = state_t_of<in_automaton_t>;
      using out_state_t = state_t_of<out_automaton_t>;
      using state_map_t = std::unordered_map<in_state_t, out_state_t>;

      copier(const in_automaton_t& in, out_automaton_t& out)
        : in_(in)
        , out_(out)
        , out_state_{{in_->pre(),  out_->pre()},
                     {in_->post(), out_->post()}}
      {}

      template <typename KeepState, typename KeepTrans>
      void operator()(KeepState keep_state, KeepTrans keep_trans,
                      bool safe = true)
      {
        // Copy the states.  We cannot iterate on the transitions
        // only, as we would lose the states without transitions.  And
        // this way, we keep the states in the same order.
        for (auto s: in_->states())
          if (keep_state(s))
            out_state_[s] = out_->new_state();

        for (auto t : in_->all_transitions())
          if (keep_trans(t))
            {
              auto src = out_state_.find(in_->src_of(t));
              auto dst = out_state_.find(in_->dst_of(t));
              if (src != out_state_.end() && dst != out_state_.end())
                {
                  if (safe)
                    out_->new_transition_copy(src->second, dst->second,
                                              in_, t);
                  else
                    out_->add_transition_copy(src->second, dst->second,
                                              in_, t);
                }
            }
      }

      void operator()(bool safe = true)
      {
        operator()([](state_t_of<in_automaton_t>) { return true; },
                   [](transition_t_of<in_automaton_t>) { return true; },
                   safe);
      }

      const state_map_t& state_map() const
      {
        return out_state_;
      }

      state_map_t& state_map()
      {
        return out_state_;
      }

    private:
      in_automaton_t in_;
      out_automaton_t out_;
      state_map_t out_state_;
    };
  }

  template <typename AutIn, typename AutOut>
  detail::copier<AutIn, AutOut>
  make_copier(const AutIn& in, AutOut& out)
  {
    return {in, out};
  }

  template <typename AutIn, typename AutOut,
            typename KeepState, typename KeepTrans>
  inline void
  copy_into(const AutIn& in, AutOut& out,
            KeepState keep_state, KeepTrans keep_trans)
  {
    auto copy = make_copier(in, out);
    return copy(keep_state, keep_trans);
  }

  template <typename AutIn, typename AutOut, typename KeepState>
  inline
  void
  copy_into(const AutIn& in, AutOut& out, KeepState keep_state)
  {
    return copy_into(in, out, keep_state,
                     [](transition_t_of<AutIn>) { return true; });
  }

  template <typename AutIn, typename AutOut>
  inline
  void
  copy_into(const AutIn& in, AutOut& out)
  {
    return copy_into(in, out,
                     [](state_t_of<AutIn>) { return true; },
                     [](transition_t_of<AutIn>) { return true; });
  }

  template <typename AutIn, typename AutOut>
  inline
  void
  copy_into(const AutIn& in, AutOut& out, bool safe)
  {
    auto copy = make_copier(in, out);
    return copy([](state_t_of<AutIn>) { return true; },
                [](transition_t_of<AutIn>) { return true; },
                safe);
  }

  namespace detail
  {
    template <typename Aut>
    struct real_context_impl;

    template <typename Aut>
    auto
    real_context(const Aut& aut)
      -> decltype(real_context_impl<Aut>::context(aut));

    template <typename Aut>
    struct real_context_impl
    {
      static auto context(const Aut& aut)
        -> decltype(aut->context())
      {
        return aut->context();
      }
    };

    template <std::size_t Tape, typename Aut>
    struct real_context_impl<focus_automaton<Tape, Aut>>
    {
      static auto context(const focus_automaton<Tape, Aut>& aut)
        -> decltype(aut->full_context())
      {
        return aut->full_context();
      }
    };

    //
    // FIXME: try to recurse on all automaton decorator types without
    // listing them.
    template <typename Aut>
    struct real_context_impl<automaton_decorator<Aut>>
    {
      static auto context(const automaton_decorator<Aut>& aut)
        -> decltype(real_context(aut->strip()))
      {
        return real_context(aut->strip());
      }
    };

    template <typename Aut>
    auto
    real_context(const Aut& aut)
      -> decltype(real_context_impl<Aut>::context(aut))
    {
      return real_context_impl<Aut>::context(aut);
    }
  }

  template <typename AutIn,
            typename AutOut = fresh_automaton_t_of<AutIn>>
  inline AutOut
  make_fresh_automaton(const AutIn& model)
  {
    // FIXME: here, we need a means to convert the given input context
    // (e.g. letter -> B) into the destination one (e.g., letter ->
    // Q).  The automaton constructor wants the exact context type.
    return make_shared_ptr<AutOut>(detail::real_context(model));
  }

  template <typename AutIn,
            typename AutOut = fresh_automaton_t_of<AutIn>,
            typename KeepState, typename KeepTrans>
  inline
  AutOut
  copy(const AutIn& input, KeepState keep_state, KeepTrans keep_trans)
  {
    auto res = make_fresh_automaton<AutIn, AutOut>(input);
    ::vcsn::copy_into(input, res, keep_state, keep_trans);
    return res;
  }

  template <typename AutIn,
            typename AutOut = fresh_automaton_t_of<AutIn>,
            typename KeepState>
  inline
  AutOut
  copy(const AutIn& input, KeepState keep_state)
  {
    return ::vcsn::copy<AutIn, AutOut>(
             input,
             keep_state,
             [](transition_t_of<AutIn>) { return true; }
    );
  }

  template <typename AutIn,
            typename AutOut = fresh_automaton_t_of<AutIn>>
  inline
  AutOut
  copy(const AutIn& input)
  {
    return ::vcsn::copy<AutIn, AutOut>(
             input,
             [](state_t_of<AutIn>) { return true; },
             [](transition_t_of<AutIn>) { return true; }
    );
  }

  template <typename AutIn,
            typename AutOut = fresh_automaton_t_of<AutIn>>
  inline
  AutOut
  copy(const AutIn& input, const std::set<state_t_of<AutIn>>& keep)
  {
    return ::vcsn::copy<AutIn, AutOut>
      (input,
       [&keep](state_t_of<AutIn> s) { return has(keep, s); });
  }

  template <typename AutIn,
            typename AutOut = fresh_automaton_t_of<AutIn>>
  inline
  AutOut
  copy(const AutIn& input, const std::unordered_set<state_t_of<AutIn>>& keep)
  {
    return ::vcsn::copy<AutIn, AutOut>
      (input,
       [&keep](state_t_of<AutIn> s) { return has(keep, s); });
  }

  namespace dyn
  {
    namespace detail
    {
      template <typename Aut, typename Ctx>
      inline
      automaton
      copy_convert(const automaton& aut, const context& ctx)
      {
        const auto& a = aut->as<Aut>();
        const auto& c = ctx->as<Ctx>();
        auto res = make_mutable_automaton(c);
        ::vcsn::copy_into(a, res);
        return make_automaton(res);
      }

      template <typename Aut>
      inline
      automaton
      copy(const automaton& aut)
      {
        const auto& a = aut->as<Aut>();
        return make_automaton(::vcsn::copy(a));
      }
    }
  }

  /*--------------------.
  | copy(expression).   |
  `--------------------*/

  namespace dyn
  {
    namespace detail
    {
      template <typename ExpSet, typename Context, typename Identities>
      inline
      expression
      copy_expression(const expression& exp,
                      const context& ctx, rat::identities ids)
      {
        const auto& r = exp->as<ExpSet>();
        const auto& c = ctx->as<Context>();
        const auto& rs = make_expressionset(c, ids);

        return make_expression(rs,
                               ::vcsn::rat::copy(r.expressionset(), rs,
                                                 r.expression()));
      }
    }
  }



} // namespace vcsn