22 #include "misc/common.hh"
24 #include <type_traits>
30 #include <type_traits>
34 template <
typename State_Data,
typename Edge_Data,
bool Alternating = false>
39 template <
typename Of,
typename ...Args>
42 static const bool value =
false;
45 template <
typename Of,
typename Arg1,
typename ...Args>
48 static const bool value =
49 std::is_base_of<Of, typename std::decay<Arg1>::type>::value;
59 template <typename Data, bool boxed = !std::is_class<Data>::value>
65 template <
typename... Args,
66 typename =
typename std::enable_if<
68 boxed_label(Args&&... args)
69 noexcept(std::is_nothrow_constructible<Data, Args...>::value)
70 : label{std::forward<Args>(args)...}
76 explicit boxed_label()
77 noexcept(std::is_nothrow_constructible<Data>::value)
86 const Data& data()
const
91 bool operator<(
const boxed_label& other)
const
93 return label < other.label;
100 typedef std::tuple<> data_t;
106 const std::tuple<>& data()
const
113 template <
typename Data>
118 template <
typename... Args,
119 typename =
typename std::enable_if<
121 boxed_label(Args&&... args)
122 noexcept(std::is_nothrow_constructible<Data, Args...>::value)
123 : Data{std::forward<Args>(args)...}
129 explicit boxed_label()
130 noexcept(std::is_nothrow_constructible<Data>::value)
139 const Data& data()
const
152 template <
typename Edge,
typename State_Data>
159 template <
typename... Args,
160 typename =
typename std::enable_if<
162 distate_storage(Args&&... args)
163 noexcept(std::is_nothrow_constructible<State_Data, Args...>::value)
164 : State_Data{std::forward<Args>(args)...}
175 template <
typename StateIn,
176 typename StateOut,
typename Edge,
typename Edge_Data>
187 noexcept(std::is_nothrow_constructible<Edge_Data>::value)
192 template <
typename... Args>
194 StateIn src, Args&&... args)
195 noexcept(std::is_nothrow_constructible<Edge_Data, Args...>::value
196 && std::is_nothrow_constructible<StateOut, StateOut>::value
197 && std::is_nothrow_constructible<Edge, Edge>::value)
198 : Edge_Data{std::forward<Args>(args)...},
199 dst(dst), next_succ(next_succ), src(src)
214 return this->data() < other.data();
219 return src == other.src &&
221 this->data() == other.data();
233 template <
typename Graph>
235 std::iterator<std::forward_iterator_tag,
237 std::conditional<std::is_const<Graph>::value,
238 const typename Graph::edge_storage_t,
239 typename Graph::edge_storage_t>::type>
242 std::iterator<std::forward_iterator_tag,
244 std::conditional<std::is_const<Graph>::value,
245 const typename Graph::edge_storage_t,
246 typename Graph::edge_storage_t>::type>
249 typedef typename Graph::edge edge;
271 typename super::reference
274 return g_->edge_storage(t_);
277 typename super::pointer
280 return &g_->edge_storage(t_);
285 t_ = operator*().next_succ;
292 t_ = operator*().next_succ;
296 operator bool()
const
311 template <
typename Graph>
316 typedef typename Graph::state_storage_t state_storage_t;
317 typedef typename Graph::edge edge;
320 : super(g, t), src_(src), prev_(0)
327 this->t_ = this->operator*().next_succ;
341 edge next = this->operator*().next_succ;
346 this->g_->edge_storage(prev_).next_succ = next;
350 if (src_.succ == this->t_)
353 if (src_.succ_tail == this->t_)
355 src_.succ_tail = prev_;
360 this->operator*().next_succ = this->t_;
365 ++this->g_->killed_edge_;
369 state_storage_t& src_;
380 template <
typename Graph>
384 typedef typename Graph::edge edge;
414 template <
typename Graph>
416 std::iterator<std::forward_iterator_tag,
418 std::conditional<std::is_const<Graph>::value,
419 const typename Graph::edge_storage_t,
420 typename Graph::edge_storage_t>::type>
423 std::iterator<std::forward_iterator_tag,
425 std::conditional<std::is_const<Graph>::value,
426 const typename Graph::edge_storage_t,
427 typename Graph::edge_storage_t>::type>
430 typedef typename std::conditional<std::is_const<Graph>::value,
431 const typename Graph::edge_vector_t,
432 typename Graph::edge_vector_t>::type
440 unsigned s = tv_.size();
443 while (t_ < s && tv_[t_].next_succ == t_);
454 : t_(tv.size()), tv_(tv)
481 typename super::reference
487 typename super::pointer
495 template <
typename Graph>
498 typedef typename std::conditional<std::is_const<Graph>::value,
499 const typename Graph::edge_vector_t,
500 typename Graph::edge_vector_t>::type
527 template <
typename State_Data,
typename Edge_Data,
bool Alternating>
538 static constexpr
bool alternating()
544 typedef State_Data state_data_t;
545 typedef Edge_Data edge_data_t;
549 typedef unsigned state;
550 typedef unsigned edge;
554 typedef typename std::conditional<Alternating,
556 state>::type out_state;
558 typedef internal::distate_storage<edge,
559 internal::boxed_label<State_Data>>
561 typedef internal::edge_storage<state, out_state, edge,
562 internal::boxed_label<Edge_Data>>
564 typedef std::vector<state_storage_t> state_vector;
565 typedef std::vector<edge_storage_t> edge_vector_t;
567 state_vector states_;
568 edge_vector_t edges_;
570 unsigned killed_edge_;
578 digraph(
unsigned max_states = 10,
unsigned max_trans = 0)
581 states_.reserve(max_states);
583 max_trans = max_states * 2;
584 edges_.reserve(max_trans + 1);
589 edges_[0].next_succ = 0;
592 unsigned num_states()
const
594 return states_.size();
597 unsigned num_edges()
const
599 return edges_.size() - killed_edge_ - 1;
602 bool valid_trans(edge t)
const
606 return (t < edges_.size() &&
607 edges_[t].next_succ != t);
610 template <
typename... Args>
611 state new_state(Args&&... args)
613 state s = states_.size();
614 states_.emplace_back(std::forward<Args>(args)...);
618 template <
typename... Args>
619 state new_states(
unsigned n, Args&&... args)
621 state s = states_.size();
622 states_.reserve(s + n);
624 states_.emplace_back(std::forward<Args>(args)...);
629 state_storage(state s)
631 assert(s < states_.size());
635 const state_storage_t&
636 state_storage(state s)
const
638 assert(s < states_.size());
644 typename state_storage_t::data_t&
647 assert(s < states_.size());
648 return states_[s].data();
652 const typename state_storage_t::data_t&
653 state_data(state s)
const
655 assert(s < states_.size());
656 return states_[s].data();
662 assert(s < edges_.size());
666 const edge_storage_t&
667 edge_storage(edge s)
const
669 assert(s < edges_.size());
673 typename edge_storage_t::data_t&
676 assert(s < edges_.size());
677 return edges_[s].data();
680 const typename edge_storage_t::data_t&
681 edge_data(edge s)
const
683 assert(s < edges_.size());
684 return edges_[s].data();
687 template <
typename... Args>
689 new_edge(state src, out_state dst, Args&&... args)
691 assert(src < states_.size());
693 edge t = edges_.size();
694 edges_.emplace_back(dst, 0, src, std::forward<Args>(args)...);
696 edge st = states_[src].succ_tail;
697 assert(st < t || !st);
699 states_[src].succ = t;
701 edges_[st].next_succ = t;
702 states_[src].succ_tail = t;
706 state index_of_state(
const state_storage_t& ss)
const
708 assert(!states_.empty());
709 return &ss - &states_.front();
712 edge index_of_edge(
const edge_storage_t&
tt)
const
714 assert(!edges_.empty());
715 return &tt - &edges_.front();
718 internal::state_out<digraph>
721 return {
this, states_[src].succ};
724 internal::state_out<digraph>
725 out(state_storage_t& src)
727 return out(index_of_state(src));
730 internal::state_out<const digraph>
733 return {
this, states_[src].succ};
736 internal::state_out<const digraph>
737 out(state_storage_t& src)
const
739 return out(index_of_state(src));
742 internal::killer_edge_iterator<digraph>
743 out_iteraser(state_storage_t& src)
745 return {
this, src.succ, src};
748 internal::killer_edge_iterator<digraph>
749 out_iteraser(state src)
751 return out_iteraser(state_storage(src));
754 const state_vector& states()
const
759 state_vector& states()
764 internal::all_trans<const digraph> edges()
const
769 internal::all_trans<digraph> edges()
779 const edge_vector_t& edge_vector()
const
784 edge_vector_t& edge_vector()
789 bool is_dead_edge(
unsigned t)
const
791 return edges_[t].next_succ == t;
794 bool is_dead_edge(
const edge_storage_t& t)
const
796 return t.next_succ == index_of_edge(t);
801 void dump_storage(std::ostream& o)
const
803 unsigned tend = edges_.size();
804 for (
unsigned t = 1; t < tend; ++t)
806 o <<
't' << t <<
": (s"
807 << edges_[t].src <<
", s"
808 << edges_[t].dst <<
") t"
809 << edges_[t].next_succ <<
'\n';
811 unsigned send = states_.size();
812 for (
unsigned s = 0; s < send; ++s)
814 o <<
's' << s <<
": t"
815 << states_[s].succ <<
" t"
816 << states_[s].succ_tail <<
'\n';
824 void remove_dead_edges_()
826 if (killed_edge_ == 0)
828 auto i = std::remove_if(edges_.begin() + 1, edges_.end(),
829 [
this](
const edge_storage_t& t) {
830 return this->is_dead_edge(t);
832 edges_.erase(i, edges_.end());
839 template<
class Predicate = std::less<edge_storage_t>>
840 void sort_edges_(Predicate p = Predicate())
844 std::stable_sort(edges_.begin() + 1, edges_.end(), p);
851 state last_src = -1
U;
852 edge tend = edges_.size();
853 for (edge t = 1; t < tend; ++t)
855 state src = edges_[t].src;
858 states_[src].succ = t;
861 states_[last_src].succ_tail = t - 1;
862 edges_[t - 1].next_succ = 0;
864 while (++last_src != src)
866 states_[last_src].succ = 0;
867 states_[last_src].succ_tail = 0;
872 edges_[t - 1].next_succ = t;
877 states_[last_src].succ_tail = tend - 1;
878 edges_[tend - 1].next_succ = 0;
880 unsigned send = states_.size();
881 while (++last_src != send)
883 states_[last_src].succ = 0;
884 states_[last_src].succ_tail = 0;
894 void rename_states_(
const std::vector<unsigned>& newst)
896 assert(newst.size() == states_.size());
897 unsigned tend = edges_.size();
898 for (
unsigned t = 1; t < tend; t++)
900 edges_[t].dst = newst[edges_[t].dst];
901 edges_[t].src = newst[edges_[t].src];
905 void defrag_states(std::vector<unsigned>&& newst,
unsigned used_states)
907 assert(newst.size() == states_.size());
908 assert(used_states > 0);
914 unsigned send = states_.size();
915 for (state s = 0; s < send; ++s)
917 state dst = newst[s];
925 auto t = states_[s].succ;
927 std::swap(t, edges_[t].next_succ);
930 states_[dst] = std::move(states_[s]);
932 states_.resize(used_states);
937 unsigned tend = edges_.size();
938 std::vector<edge> newidx(tend);
940 for (edge t = 1; t < tend; ++t)
945 edges_[dest] = std::move(edges_[t]);
953 for (edge t = 1; t < dest; ++t)
955 auto& tr = edges_[t];
956 tr.next_succ = newidx[tr.next_succ];
957 tr.dst = newst[tr.dst];
958 tr.src = newst[tr.src];
959 assert(tr.dst != -1
U);
963 for (
auto& s: states_)
965 s.succ = newidx[s.succ];
966 s.succ_tail = newidx[s.succ_tail];
digraph(unsigned max_states=10, unsigned max_trans=0)
construct an empty graph
Definition: graph.hh:578