22 #include "misc/common.hh"
24 #include <type_traits>
33 template <
typename State_Data,
typename Edge_Data,
bool Alternating = false>
38 template <
typename Of,
typename ...Args>
41 static const bool value =
false;
44 template <
typename Of,
typename Arg1,
typename ...Args>
47 static const bool value =
48 std::is_base_of<Of, typename std::decay<Arg1>::type>::value;
58 template <typename Data, bool boxed = !std::is_class<Data>::value>
64 template <
typename... Args,
65 typename =
typename std::enable_if<
67 boxed_label(Args&&... args):
68 label{std::forward<Args>(args)...}
74 explicit boxed_label()
83 const Data& data()
const
88 bool operator<(
const boxed_label& other)
const
90 return label < other.label;
97 typedef std::tuple<> data_t;
103 const std::tuple<>& data()
const
110 template <
typename Data>
115 template <
typename... Args,
116 typename =
typename std::enable_if<
118 boxed_label(Args&&... args):
119 Data{std::forward<Args>(args)...}
125 explicit boxed_label()
134 const Data& data()
const
147 template <
typename Edge,
typename State_Data>
154 template <
typename... Args,
155 typename =
typename std::enable_if<
157 distate_storage(Args&&... args):
158 State_Data{std::forward<Args>(args)...}
169 template <
typename StateIn,
170 typename StateOut,
typename Edge,
typename Edge_Data>
185 template <
typename... Args>
187 StateIn src, Args&&... args)
188 : Edge_Data{std::forward<Args>(args)...},
189 dst(dst), next_succ(next_succ), src(src)
193 bool operator<(
const edge_storage& other)
const
204 return this->data() < other.data();
207 bool operator==(
const edge_storage& other)
const
209 return src == other.src &&
211 this->data() == other.data();
223 template <
typename Graph>
225 std::iterator<std::forward_iterator_tag,
227 std::conditional<std::is_const<Graph>::value,
228 const typename Graph::edge_storage_t,
229 typename Graph::edge_storage_t>::type>
232 std::iterator<std::forward_iterator_tag,
234 std::conditional<std::is_const<Graph>::value,
235 const typename Graph::edge_storage_t,
236 typename Graph::edge_storage_t>::type>
239 typedef typename Graph::edge edge;
260 typename super::reference
263 return g_->edge_storage(t_);
266 typename super::pointer
269 return &g_->edge_storage(t_);
274 t_ = operator*().next_succ;
281 t_ = operator*().next_succ;
285 operator bool()
const
300 template <
typename Graph>
305 typedef typename Graph::state_storage_t state_storage_t;
306 typedef typename Graph::edge edge;
309 super(g, t), src_(src), prev_(0)
316 this->t_ = this->operator*().next_succ;
330 edge next = this->operator*().next_succ;
335 this->g_->edge_storage(prev_).next_succ = next;
339 if (src_.succ == this->t_)
342 if (src_.succ_tail == this->t_)
344 src_.succ_tail = prev_;
349 this->operator*().next_succ = this->t_;
354 ++this->g_->killed_edge_;
358 state_storage_t& src_;
369 template <
typename Graph>
373 typedef typename Graph::edge edge;
403 template <
typename Graph>
405 std::iterator<std::forward_iterator_tag,
407 std::conditional<std::is_const<Graph>::value,
408 const typename Graph::edge_storage_t,
409 typename Graph::edge_storage_t>::type>
412 std::iterator<std::forward_iterator_tag,
414 std::conditional<std::is_const<Graph>::value,
415 const typename Graph::edge_storage_t,
416 typename Graph::edge_storage_t>::type>
419 typedef typename std::conditional<std::is_const<Graph>::value,
420 const typename Graph::edge_vector_t,
421 typename Graph::edge_vector_t>::type
429 unsigned s = tv_.size();
432 while (t_ < s && tv_[t_].next_succ == t_);
443 : t_(tv.size()), tv_(tv)
470 typename super::reference
476 typename super::pointer
484 template <
typename Graph>
487 typedef typename std::conditional<std::is_const<Graph>::value,
488 const typename Graph::edge_vector_t,
489 typename Graph::edge_vector_t>::type
516 template <
typename State_Data,
typename Edge_Data,
bool Alternating>
527 static constexpr
bool alternating()
533 typedef State_Data state_data_t;
534 typedef Edge_Data edge_data_t;
538 typedef unsigned state;
539 typedef unsigned edge;
543 typedef typename std::conditional<Alternating,
545 state>::type out_state;
547 typedef internal::distate_storage<edge,
548 internal::boxed_label<State_Data>>
550 typedef internal::edge_storage<state, out_state, edge,
551 internal::boxed_label<Edge_Data>>
553 typedef std::vector<state_storage_t> state_vector;
554 typedef std::vector<edge_storage_t> edge_vector_t;
556 state_vector states_;
557 edge_vector_t edges_;
559 unsigned killed_edge_;
567 digraph(
unsigned max_states = 10,
unsigned max_trans = 0)
570 states_.reserve(max_states);
572 max_trans = max_states * 2;
573 edges_.reserve(max_trans + 1);
578 edges_[0].next_succ = 0;
581 unsigned num_states()
const
583 return states_.size();
586 unsigned num_edges()
const
588 return edges_.size() - killed_edge_ - 1;
591 bool valid_trans(edge t)
const
595 return (t < edges_.size() &&
596 edges_[t].next_succ != t);
599 template <
typename... Args>
600 state new_state(Args&&... args)
602 state s = states_.size();
603 states_.emplace_back(std::forward<Args>(args)...);
607 template <
typename... Args>
608 state new_states(
unsigned n, Args&&... args)
610 state s = states_.size();
611 states_.reserve(s + n);
613 states_.emplace_back(std::forward<Args>(args)...);
618 state_storage(state s)
620 assert(s < states_.size());
624 const state_storage_t&
625 state_storage(state s)
const
627 assert(s < states_.size());
633 typename state_storage_t::data_t&
636 assert(s < states_.size());
637 return states_[s].data();
641 const typename state_storage_t::data_t&
642 state_data(state s)
const
644 assert(s < states_.size());
645 return states_[s].data();
651 assert(s < edges_.size());
655 const edge_storage_t&
656 edge_storage(edge s)
const
658 assert(s < edges_.size());
662 typename edge_storage_t::data_t&
665 assert(s < edges_.size());
666 return edges_[s].data();
669 const typename edge_storage_t::data_t&
670 edge_data(edge s)
const
672 assert(s < edges_.size());
673 return edges_[s].data();
676 template <
typename... Args>
678 new_edge(state src, out_state dst, Args&&... args)
680 assert(src < states_.size());
682 edge t = edges_.size();
683 edges_.emplace_back(dst, 0, src, std::forward<Args>(args)...);
685 edge st = states_[src].succ_tail;
686 assert(st < t || !st);
688 states_[src].succ = t;
690 edges_[st].next_succ = t;
691 states_[src].succ_tail = t;
695 state index_of_state(
const state_storage_t& ss)
const
697 assert(!states_.empty());
698 return &ss - &states_.front();
701 edge index_of_edge(
const edge_storage_t&
tt)
const
703 assert(!edges_.empty());
704 return &tt - &edges_.front();
707 internal::state_out<digraph>
710 return {
this, states_[src].succ};
713 internal::state_out<digraph>
714 out(state_storage_t& src)
716 return out(index_of_state(src));
719 internal::state_out<const digraph>
722 return {
this, states_[src].succ};
725 internal::state_out<const digraph>
726 out(state_storage_t& src)
const
728 return out(index_of_state(src));
731 internal::killer_edge_iterator<digraph>
732 out_iteraser(state_storage_t& src)
734 return {
this, src.succ, src};
737 internal::killer_edge_iterator<digraph>
738 out_iteraser(state src)
740 return out_iteraser(state_storage(src));
743 const state_vector& states()
const
748 state_vector& states()
753 internal::all_trans<const digraph> edges()
const
758 internal::all_trans<digraph> edges()
768 const edge_vector_t& edge_vector()
const
773 edge_vector_t& edge_vector()
778 bool is_dead_edge(
unsigned t)
const
780 return edges_[t].next_succ == t;
783 bool is_dead_edge(
const edge_storage_t& t)
const
785 return t.next_succ == index_of_edge(t);
790 void dump_storage(std::ostream& o)
const
792 unsigned tend = edges_.size();
793 for (
unsigned t = 1; t < tend; ++t)
795 o <<
't' << t <<
": (s"
796 << edges_[t].src <<
", s"
797 << edges_[t].dst <<
") t"
798 << edges_[t].next_succ <<
'\n';
800 unsigned send = states_.size();
801 for (
unsigned s = 0; s < send; ++s)
803 o <<
's' << s <<
": t"
804 << states_[s].succ <<
" t"
805 << states_[s].succ_tail <<
'\n';
813 void remove_dead_edges_()
815 if (killed_edge_ == 0)
817 auto i = std::remove_if(edges_.begin() + 1, edges_.end(),
818 [
this](
const edge_storage_t& t) {
819 return this->is_dead_edge(t);
821 edges_.erase(i, edges_.end());
828 template<
class Predicate = std::less<edge_storage_t>>
829 void sort_edges_(Predicate p = Predicate())
833 std::stable_sort(edges_.begin() + 1, edges_.end(), p);
840 state last_src = -1
U;
841 edge tend = edges_.size();
842 for (edge t = 1; t < tend; ++t)
844 state src = edges_[t].src;
847 states_[src].succ = t;
850 states_[last_src].succ_tail = t - 1;
851 edges_[t - 1].next_succ = 0;
853 while (++last_src != src)
855 states_[last_src].succ = 0;
856 states_[last_src].succ_tail = 0;
861 edges_[t - 1].next_succ = t;
866 states_[last_src].succ_tail = tend - 1;
867 edges_[tend - 1].next_succ = 0;
869 unsigned send = states_.size();
870 while (++last_src != send)
872 states_[last_src].succ = 0;
873 states_[last_src].succ_tail = 0;
883 void rename_states_(
const std::vector<unsigned>& newst)
885 assert(newst.size() == states_.size());
886 unsigned tend = edges_.size();
887 for (
unsigned t = 1; t < tend; t++)
889 edges_[t].dst = newst[edges_[t].dst];
890 edges_[t].src = newst[edges_[t].src];
894 void defrag_states(std::vector<unsigned>&& newst,
unsigned used_states)
896 assert(newst.size() == states_.size());
897 assert(used_states > 0);
903 unsigned send = states_.size();
904 for (state s = 0; s < send; ++s)
906 state dst = newst[s];
914 auto t = states_[s].succ;
916 std::swap(t, edges_[t].next_succ);
919 states_[dst] = std::move(states_[s]);
921 states_.resize(used_states);
926 unsigned tend = edges_.size();
927 std::vector<edge> newidx(tend);
929 for (edge t = 1; t < tend; ++t)
934 edges_[dest] = std::move(edges_[t]);
942 for (edge t = 1; t < dest; ++t)
944 auto& tr = edges_[t];
945 tr.next_succ = newidx[tr.next_succ];
946 tr.dst = newst[tr.dst];
947 tr.src = newst[tr.src];
948 assert(tr.dst != -1
U);
952 for (
auto& s: states_)
954 s.succ = newidx[s.succ];
955 s.succ_tail = newidx[s.succ_tail];
digraph(unsigned max_states=10, unsigned max_trans=0)
construct an empty graph
Definition: graph.hh:567