transition_map.hh

Go to the documentation of this file.

// This file is part of Awali.
// Copyright 2016-2022 Sylvain Lombardy, Victor Marsault, Jacques Sakarovitch
//
// Awali is a 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 AWALI_CORE_TRANSITION_MAP_HH
# define AWALI_CORE_TRANSITION_MAP_HH
 
# include <map>
# include <type_traits>
 
namespace awali { namespace sttc {
 
  namespace internal
  {
 
    template <typename Aut,
              typename WeightSet = weightset_t_of<Aut>,
              bool Deterministic = false,
              bool AllOut = false>
    struct transition_map
    {
      using weightset_t = WeightSet;
      using weight_t = typename weightset_t::value_t;
      struct transition
      {
        weight_t wgt;
        state_t dst;
      };
 
      using transitions_t
        = typename std::conditional<Deterministic,
                                    transition,
                                    std::vector<transition>>::type;
      using map_t = std::map<label_t_of<Aut>, transitions_t>;
      using maps_t = std::map<state_t, map_t>;
      maps_t maps_;
 
      transition_map(const Aut& aut, const weightset_t& ws)
        : aut_(aut)
        , ws_(ws)
      {}
 
      transition_map(const Aut& aut)
        : transition_map(aut, *aut->weightset())
      {}
 
      template <bool Deterministic_>
      void
      insert_(map_t& map,
              label_t_of<Aut> l, transition t,
              typename std::enable_if<Deterministic_>::type* = nullptr)
      {
        map.emplace(l, t);
      }
 
      template <bool Deterministic_>
      void
      insert_(map_t& map,
              label_t_of<Aut> l, transition t,
              typename std::enable_if<!Deterministic_>::type* = nullptr)
      {
        map[l].emplace_back(t);
      }
 
      map_t&
      build_map_(typename maps_t::iterator lb, state_t s)
      {
        auto& res = maps_.emplace_hint(lb, s, map_t{})->second;
        for (auto t: aut_->all_out(s))
          if (AllOut || !aut_->labelset()->is_special(aut_->label_of(t)))
            {
              auto w = ws_.conv(*aut_->weightset(), aut_->weight_of(t));
              insert_<Deterministic>(res,
                                     aut_->label_of(t),
                                     transition{w, aut_->dst_of(t)});
            }
        return res;
      }
 
      map_t& operator[](state_t s)
      {
        auto lb = maps_.lower_bound(s);
        if (lb == maps_.end() || maps_.key_comp()(s, lb->first))
          return build_map_(lb, s);
        else
          return lb->second;
      }
 
      const Aut& aut_;
      const weightset_t& ws_;
    };
  }
 
}}//end of ns awali::stc
 
#endif // !AWALI_CORE_TRANSITION_MAP_HH