23 #ifndef SPOT_TGBA_TGBAEXPLICIT_HH
24 # define SPOT_TGBA_TGBAEXPLICIT_HH
31 #include "tgba/formula2bdd.hh"
32 #include "misc/hash.hh"
33 #include "misc/bddop.hh"
35 #include "ltlvisit/tostring.hh"
60 template<
typename Label,
typename label_hash>
81 typedef Label label_t;
82 typedef label_hash label_hash_t;
87 bdd acceptance_conditions;
91 typedef std::list<transition> transitions_t;
92 transitions_t successors;
94 const Label& label()
const
101 return successors.empty();
121 reinterpret_cast<const char*
>(
this) - static_cast<const char*>(0);
150 static const int default_val;
169 static const std::string default_val;
193 template<
typename State>
201 all_acceptance_conditions_(all_acc)
207 it_ = start_->successors.begin();
217 return it_ == start_->successors.end();
223 const State* res = down_cast<
const State*>(it_->dest);
225 return const_cast<State*
>(res);
231 return it_->condition;
237 return it_->acceptance_conditions;
240 typename State::transitions_t::const_iterator
248 typename State::transitions_t::const_iterator it_;
249 bdd all_acceptance_conditions_;
254 template<
typename State,
typename Type>
258 typedef typename State::label_t label_t;
259 typedef typename State::label_hash_t label_hash_t;
260 typedef typename State::transitions_t transitions_t;
261 typedef typename State::transition transition;
264 typedef Sgi::hash_map<label_t, State, label_hash_t> ls_map;
265 typedef Sgi::hash_map<label_t, State*, label_hash_t> alias_map;
266 typedef Sgi::hash_map<const State*, label_t, ptr_hash<State> > sl_map;
275 all_acceptance_conditions_(bddfalse),
276 all_acceptance_conditions_computed_(
false),
277 neg_acceptance_conditions_(bddtrue)
281 State* add_default_init()
283 return add_state(State::default_val);
286 size_t num_states()
const
292 create_transition(State* source,
const State* dest)
297 t.condition = bddtrue;
298 t.acceptance_conditions = bddfalse;
300 typename transitions_t::iterator i =
301 source->successors.insert(source->successors.end(), t);
307 create_transition(
const label_t& source,
const label_t& dest)
312 State* s = add_state(source);
313 return create_transition(s, add_state(dest));
319 return const_cast<transition*
>(&(*(si->get_iterator())));
328 return get_transition(tmp);
331 void add_condition(transition* t,
const ltl::formula* f)
333 t->condition &= formula_to_bdd(f, dict_,
this);
340 dict_->register_propositions(f,
this);
344 bool has_acceptance_condition(
const ltl::formula* f)
const
346 return dict_->is_registered_acceptance_variable(f,
this);
350 bool has_state(
const label_t& name)
352 return ls_.find(name) != ls_.end();
361 typename ls_map::const_iterator i = ls_.find(name);
367 const label_t& get_label(
const State* s)
const
369 typename sl_map::const_iterator i = sl_.find(s);
370 assert(i != sl_.end());
374 const label_t& get_label(
const spot::state* s)
const
376 const State* se = down_cast<
const State*>(s);
378 return get_label(se);
382 complement_all_acceptance_conditions()
384 bdd all = this->all_acceptance_conditions();
385 typename ls_map::iterator i;
386 for (i = ls_.begin(); i != ls_.end(); ++i)
388 typename transitions_t::iterator i2;
389 for (i2 = i->second.successors.begin();
390 i2 != i->second.successors.end(); ++i2)
391 i2->acceptance_conditions = all - i2->acceptance_conditions;
398 typedef typename transitions_t::iterator trans_t;
399 typedef std::map<int, trans_t> acc_map;
401 ptr_hash<spot::state> > dest_map;
403 typename ls_map::iterator i;
404 for (i = ls_.begin(); i != ls_.end(); ++i)
406 const spot::state* last_dest = 0;
408 typename dest_map::iterator dmi = dm.end();
409 typename transitions_t::iterator t1 = i->second.successors.begin();
414 while (t1 != i->second.successors.end())
416 const spot::state* dest = t1->dest;
417 if (dest != last_dest)
422 dmi = dm.insert(std::make_pair(dest, acc_map())).first;
424 int acc = t1->acceptance_conditions.id();
425 typename acc_map::iterator it = dmi->second.find(acc);
426 if (it == dmi->second.end())
428 dmi->second[acc] = t1;
433 it->second->condition |= t1->condition;
434 t1 = i->second.successors.erase(t1);
444 typename ls_map::iterator i = ls_.find(name);
447 typename alias_map::iterator j = alias_.find(name);
448 if (j != alias_.end())
452 &(ls_.insert(std::make_pair(name, State(name))).first->second);
464 set_init_state(
const label_t&
state)
466 State* s = add_state(state);
472 virtual ~explicit_graph()
474 typename ls_map::iterator i = ls_.begin();
476 while (i != ls_.end())
478 label_t s = i->first;
481 destroy_key<label_t> dest;
485 this->dict_->unregister_all_my_variables(
this);
488 this->last_support_conditions_input_ = 0;
489 this->last_support_variables_input_ = 0;
492 virtual State* get_init_state()
const
495 const_cast<explicit_graph<State, Type>*
>(
this)->add_default_init();
500 virtual tgba_explicit_succ_iterator<State>*
501 succ_iter(
const spot::state* state,
502 const spot::state* global_state = 0,
503 const tgba* global_automaton = 0)
const
505 const State* s = down_cast<
const State*>(state);
509 (void) global_automaton;
512 new tgba_explicit_succ_iterator<State>(s,
514 ->all_acceptance_conditions());
518 typedef std::string (*to_string_func_t)(
const label_t& t);
520 void set_to_string_func(to_string_func_t f)
525 to_string_func_t get_to_string_func()
const
527 return to_string_func_;
530 virtual std::string format_state(
const spot::state* state)
const
532 const State* se = down_cast<
const State*>(state);
534 typename sl_map::const_iterator i = sl_.find(se);
535 assert(i != sl_.end());
536 assert(to_string_func_);
537 return to_string_func_(i->second);
544 alias_[alias] = add_state(real);
554 assert(neg_acceptance_conditions_ == bddtrue);
555 assert(all_acceptance_conditions_computed_ ==
false);
557 this->dict_->register_acceptance_variables(f,
this);
558 neg_acceptance_conditions_ = f;
565 assert(neg_acceptance_conditions_ == bddtrue);
566 assert(all_acceptance_conditions_computed_ ==
false);
568 this->dict_->register_acceptance_variables(bdd_support(acc),
this);
569 neg_acceptance_conditions_ = compute_neg_acceptance_conditions(acc);
570 all_acceptance_conditions_computed_ =
true;
571 all_acceptance_conditions_ = acc;
574 void add_acceptance_condition(transition* t,
const ltl::formula* f)
576 bdd c = get_acceptance_condition(f);
577 t->acceptance_conditions |= c;
584 bdd sup = bdd_support(f);
585 this->dict_->register_acceptance_variables(sup,
this);
586 while (sup != bddtrue)
588 neg_acceptance_conditions_ &= bdd_nithvar(bdd_var(sup));
591 t->acceptance_conditions |= f;
594 virtual bdd all_acceptance_conditions()
const
596 if (!all_acceptance_conditions_computed_)
598 all_acceptance_conditions_ =
599 compute_all_acceptance_conditions(neg_acceptance_conditions_);
600 all_acceptance_conditions_computed_ =
true;
602 return all_acceptance_conditions_;
605 virtual bdd_dict* get_dict()
const
610 virtual bdd neg_acceptance_conditions()
const
612 return neg_acceptance_conditions_;
616 declare_acceptance_condition(
const ltl::formula* f)
618 int v = this->dict_->register_acceptance_variable(f,
this);
620 bdd neg = bdd_nithvar(v);
621 neg_acceptance_conditions_ &= neg;
630 typename ls_map::iterator i;
631 for (i = this->ls_.begin(); i != this->ls_.end(); ++i)
633 typename transitions_t::iterator i2;
634 for (i2 = i->second.successors.begin();
635 i2 != i->second.successors.end(); ++i2)
636 i2->acceptance_conditions &= neg;
639 all_acceptance_conditions_computed_ =
false;
642 bdd get_acceptance_condition(
const ltl::formula* f)
644 bdd_dict::fv_map::iterator i = this->dict_->acc_map.find(f);
645 assert(this->has_acceptance_condition(f));
647 bdd v = bdd_ithvar(i->second);
648 v &= bdd_exist(neg_acceptance_conditions_, v);
654 virtual bdd compute_support_conditions(
const spot::state* in)
const
656 const State* s = down_cast<
const State*>(in);
658 const transitions_t& st = s->successors;
662 typename transitions_t::const_iterator i;
663 for (i = st.begin(); i != st.end(); ++i)
669 virtual bdd compute_support_variables(
const spot::state* in)
const
671 const State* s = down_cast<
const State*>(in);
673 const transitions_t& st = s->successors;
677 typename transitions_t::const_iterator i;
678 for (i = st.begin(); i != st.end(); ++i)
679 res &= bdd_support(i->condition);
691 mutable bdd all_acceptance_conditions_;
692 mutable bool all_acceptance_conditions_computed_;
693 bdd neg_acceptance_conditions_;
694 to_string_func_t to_string_func_;
697 template <
typename State>
716 template <
typename State>
731 const State* st = down_cast<
const State*>(s);
734 if (st->successors.empty())
736 return (st->successors.front().acceptance_conditions
737 == this->all_acceptance_conditions());
757 template<
class graph,
typename Type>
766 static std::string
to_string(
const typename Type::label_t& l)
768 std::stringstream ss;
774 template<
class graph>
783 static std::string
to_string(
const std::string& l)
789 template<
class graph>
833 #endif // SPOT_TGBA_TGBAEXPLICIT_HH