c++11: replace Sgi::hash_* by Sgi::unordered_*.
* bench/scc-stats/stats.cc, bench/split-product/cutscc.cc, iface/gspn/ssp.cc, src/bin/ltlcross.cc, src/bin/ltlfilt.cc, src/bin/randltl.cc, src/dstarparse/nsa2tgba.cc, src/ltlast/formula.hh, src/ltlast/nfa.hh, src/ltlvisit/contain.hh, src/ltlvisit/dotty.cc, src/ltlvisit/mark.hh, src/ltlvisit/relabel.cc, src/ltlvisit/relabel.hh, src/ltlvisit/simplify.cc, src/ltlvisit/snf.hh, src/misc/hash.hh, src/misc/mspool.hh, src/priv/acccompl.hh, src/priv/accconv.hh, src/saba/explicitstateconjunction.hh, src/saba/sabastate.hh, src/sabaalgos/sabareachiter.hh, src/sanity/style.test, src/ta/taexplicit.cc, src/ta/taexplicit.hh, src/taalgos/emptinessta.cc, src/taalgos/minimize.cc, src/taalgos/reachiter.hh, src/tgba/state.hh, src/tgba/taatgba.hh, src/tgba/tgbabddconcretefactory.hh, src/tgba/tgbaexplicit.hh, src/tgba/tgbakvcomplement.cc, src/tgba/tgbasafracomplement.cc, src/tgba/tgbatba.cc, src/tgba/tgbatba.hh, src/tgbaalgos/cutscc.cc, src/tgbaalgos/cycles.hh, src/tgbaalgos/degen.cc, src/tgbaalgos/dtbasat.cc, src/tgbaalgos/dtgbasat.cc, src/tgbaalgos/eltl2tgba_lacim.cc, src/tgbaalgos/emptiness.cc, src/tgbaalgos/gtec/explscc.hh, src/tgbaalgos/gtec/nsheap.hh, src/tgbaalgos/gv04.cc, src/tgbaalgos/ltl2tgba_fm.cc, src/tgbaalgos/magic.cc, src/tgbaalgos/minimize.cc, src/tgbaalgos/ndfs_result.hxx, src/tgbaalgos/powerset.hh, src/tgbaalgos/randomgraph.cc, src/tgbaalgos/reachiter.hh, src/tgbaalgos/replayrun.cc, src/tgbaalgos/safety.cc, src/tgbaalgos/scc.hh, src/tgbaalgos/se05.cc, src/tgbaalgos/simulation.cc, src/tgbaalgos/tau03.cc, src/tgbaalgos/tau03opt.cc: Adjust code. * src/sanity/style.test: Remove check.
This commit is contained in:
Alexandre Duret-Lutz
parent
c568b4d337
commit
34e91b7656
61 changed files with 284 additions and 271 deletions
|
|
@ -1,5 +1,5 @@
|
|||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2009, 2010, 2012 Laboratoire de Recherche et
|
||||
// Copyright (C) 2009, 2010, 2012, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -28,7 +28,7 @@ namespace spot
|
|||
{
|
||||
unsigned tgba_size(const tgba* a)
|
||||
{
|
||||
typedef Sgi::hash_set<const state*,
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
hash_type seen;
|
||||
std::queue<state*> tovisit;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2009, 2010, 2012 Laboratoire de Recherche et
|
||||
// Copyright (C) 2009, 2010, 2012, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -38,7 +38,7 @@ namespace spot
|
|||
{
|
||||
unsigned tgba_size(const tgba* a)
|
||||
{
|
||||
typedef Sgi::hash_set<const state*,
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
hash_type seen;
|
||||
std::queue<state*> tovisit;
|
||||
|
|
|
|||
|
|
@ -1,8 +1,9 @@
|
|||
// Copyright (C) 2008, 2011 Laboratoire de Recherche et Developpement
|
||||
// de l'Epita (LRDE).
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2008, 2011, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
// Copyright (C) 2003, 2004, 2005, 2006, 2007 Laboratoire
|
||||
// d'Informatique de Paris 6 (LIP6), département Systèmes Répartis
|
||||
// Coopératifs (SRC), Université Pierre et Marie Curie.
|
||||
// d'Informatique de Paris 6 (LIP6), département Systèmes Répartis
|
||||
// Coopératifs (SRC), Université Pierre et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
//
|
||||
|
|
@ -610,8 +611,8 @@ namespace spot
|
|||
}
|
||||
|
||||
protected:
|
||||
typedef Sgi::hash_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> set_type;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> set_type;
|
||||
set_type states;
|
||||
};
|
||||
|
||||
|
|
@ -895,15 +896,15 @@ namespace spot
|
|||
virtual numbered_state_heap_const_iterator* iterator() const;
|
||||
|
||||
protected:
|
||||
typedef Sgi::hash_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
hash_type h; ///< Map of visited states.
|
||||
|
||||
typedef std::list<const state*> state_list;
|
||||
typedef Sgi::hash_map<const state*, state_list,
|
||||
state_ptr_hash, state_ptr_equal> f_map;
|
||||
typedef Sgi::hash_map<const void*, f_map,
|
||||
ptr_hash<void> > contained_map;
|
||||
typedef std::unordered_map<const state*, state_list,
|
||||
state_ptr_hash, state_ptr_equal> f_map;
|
||||
typedef std::unordered_map<const void*, f_map,
|
||||
ptr_hash<void> > contained_map;
|
||||
contained_map contained;
|
||||
|
||||
friend class numbered_state_heap_ssp_const_iterator;
|
||||
|
|
|
|||
|
|
@ -1190,8 +1190,8 @@ namespace
|
|||
}
|
||||
|
||||
typedef
|
||||
Sgi::hash_set<const spot::ltl::formula*,
|
||||
const spot::ptr_hash<const spot::ltl::formula> > fset_t;
|
||||
std::unordered_set<const spot::ltl::formula*,
|
||||
const spot::ptr_hash<const spot::ltl::formula> > fset_t;
|
||||
|
||||
|
||||
class processor: public job_processor
|
||||
|
|
|
|||
|
|
@ -385,8 +385,9 @@ parse_opt(int key, char* arg, struct argp_state*)
|
|||
return 0;
|
||||
}
|
||||
|
||||
typedef Sgi::hash_set<const spot::ltl::formula*,
|
||||
const spot::ptr_hash<const spot::ltl::formula> > fset_t;
|
||||
typedef
|
||||
std::unordered_set<const spot::ltl::formula*,
|
||||
const spot::ptr_hash<const spot::ltl::formula>> fset_t;
|
||||
|
||||
namespace
|
||||
{
|
||||
|
|
|
|||
|
|
@ -344,8 +344,9 @@ main(int argc, char** argv)
|
|||
error(2, 0, "No atomic proposition supplied? Run '%s --help' for usage.",
|
||||
program_name);
|
||||
|
||||
typedef Sgi::hash_set<const spot::ltl::formula*,
|
||||
const spot::ptr_hash<const spot::ltl::formula> > fset_t;
|
||||
typedef
|
||||
std::unordered_set<const spot::ltl::formula*,
|
||||
const spot::ptr_hash<const spot::ltl::formula>> fset_t;
|
||||
|
||||
fset_t unique_set;
|
||||
|
||||
|
|
|
|||
|
|
@ -90,8 +90,8 @@ namespace spot
|
|||
};
|
||||
|
||||
// Associate the build state to its number.
|
||||
typedef Sgi::hash_map<build_state, int,
|
||||
build_state_hash, build_state_equal> bs2num_map;
|
||||
typedef std::unordered_map<build_state, int,
|
||||
build_state_hash, build_state_equal> bs2num_map;
|
||||
|
||||
// Queue of state to be processed.
|
||||
typedef std::deque<build_state> queue_t;
|
||||
|
|
|
|||
|
|
@ -497,14 +497,14 @@ namespace spot
|
|||
/// \brief Hash Function for <code>const formula*</code>.
|
||||
///
|
||||
/// This is meant to be used as a hash functor for
|
||||
/// Sgi's \c hash_map whose key are of type <code>const formula*</code>.
|
||||
/// \c unordered_map whose key are of type <code>const formula*</code>.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c const::formula*.
|
||||
/// \code
|
||||
/// // Remember how many times each formula has been seen.
|
||||
/// Sgi::hash_map<const spot::ltl::formula*, int,
|
||||
/// const spot::ltl::formula_ptr_hash> seen;
|
||||
/// std::unordered_map<const spot::ltl::formula*, int,
|
||||
/// const spot::ltl::formula_ptr_hash> seen;
|
||||
/// \endcode
|
||||
struct formula_ptr_hash:
|
||||
public std::unary_function<const formula*, size_t>
|
||||
|
|
|
|||
|
|
@ -102,8 +102,8 @@ namespace spot
|
|||
private:
|
||||
state* add_state(int name);
|
||||
|
||||
typedef Sgi::hash_map<int, state*, Sgi::hash<int> > is_map;
|
||||
typedef Sgi::hash_map<const state*, int, ptr_hash<state> > si_map;
|
||||
typedef std::unordered_map<int, state*, std::hash<int>> is_map;
|
||||
typedef std::unordered_map<const state*, int, ptr_hash<state>> si_map;
|
||||
|
||||
is_map is_;
|
||||
si_map si_;
|
||||
|
|
|
|||
|
|
@ -41,8 +41,8 @@ namespace spot
|
|||
typedef std::map<const record_*, bool> incomp_map;
|
||||
incomp_map incompatible;
|
||||
};
|
||||
typedef Sgi::hash_map<const formula*,
|
||||
record_, formula_ptr_hash> trans_map;
|
||||
typedef std::unordered_map<const formula*,
|
||||
record_, formula_ptr_hash> trans_map;
|
||||
public:
|
||||
/// This class uses spot::ltl_to_tgba_fm to translate LTL
|
||||
/// formulae. See that function for the meaning of these options.
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2009, 2010, 2011, 2012 Laboratoire de Recherche et
|
||||
// Copyright (C) 2009, 2010, 2011, 2012, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
// Copyright (C) 2003, 2004 Laboratoire d'Informatique de Paris 6
|
||||
// (LIP6), département Systèmes Répartis Coopératifs (SRC), Université
|
||||
|
|
@ -36,7 +36,7 @@ namespace spot
|
|||
class dotty_visitor: public visitor
|
||||
{
|
||||
public:
|
||||
typedef Sgi::hash_map<const formula*, int, ptr_hash<formula> > map;
|
||||
typedef std::unordered_map<const formula*, int, ptr_hash<formula>> map;
|
||||
dotty_visitor(std::ostream& os, map& m)
|
||||
: os_(os), father_(-1), node_(m), sinks_(new std::ostringstream)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
// Copyright (C) 2010, 2011, 2012 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2010, 2011, 2012, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
//
|
||||
|
|
@ -42,8 +43,8 @@ namespace spot
|
|||
~mark_tools();
|
||||
|
||||
private:
|
||||
typedef Sgi::hash_map<const formula*, const formula*,
|
||||
ptr_hash<formula> > f2f_map;
|
||||
typedef std::unordered_map<const formula*, const formula*,
|
||||
ptr_hash<formula>> f2f_map;
|
||||
f2f_map simpmark_;
|
||||
f2f_map markops_;
|
||||
visitor* simpvisitor_;
|
||||
|
|
|
|||
|
|
@ -91,8 +91,8 @@ namespace spot
|
|||
class relabeler: public clone_visitor
|
||||
{
|
||||
public:
|
||||
typedef Sgi::hash_map<const formula*, const formula*,
|
||||
ptr_hash<formula> > map;
|
||||
typedef std::unordered_map<const formula*, const formula*,
|
||||
ptr_hash<formula> > map;
|
||||
map newname;
|
||||
ap_generator* gen;
|
||||
relabeling_map* oldnames;
|
||||
|
|
@ -363,8 +363,8 @@ namespace spot
|
|||
unsigned num; // serial number, in pre-order
|
||||
unsigned low; // lowest number accessible via unstacked descendants
|
||||
};
|
||||
typedef Sgi::hash_map<const formula*, data_entry,
|
||||
const formula_ptr_hash> fmap_t;
|
||||
typedef std::unordered_map<const formula*, data_entry,
|
||||
const formula_ptr_hash> fmap_t;
|
||||
struct stack_entry
|
||||
{
|
||||
const formula* grand_parent;
|
||||
|
|
|
|||
|
|
@ -30,9 +30,9 @@ namespace spot
|
|||
enum relabeling_style { Abc, Pnn };
|
||||
|
||||
|
||||
struct relabeling_map: public Sgi::hash_map<const formula*,
|
||||
const formula*,
|
||||
ptr_hash<formula> >
|
||||
struct relabeling_map: public std::unordered_map<const formula*,
|
||||
const formula*,
|
||||
ptr_hash<formula>>
|
||||
{
|
||||
~relabeling_map()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -44,10 +44,10 @@ namespace spot
|
|||
// The name of this class is public, but not its contents.
|
||||
class ltl_simplifier_cache
|
||||
{
|
||||
typedef Sgi::hash_map<const formula*, const formula*,
|
||||
ptr_hash<formula> > f2f_map;
|
||||
typedef Sgi::hash_map<const formula*, bdd,
|
||||
ptr_hash<formula> > f2b_map;
|
||||
typedef std::unordered_map<const formula*, const formula*,
|
||||
ptr_hash<formula>> f2f_map;
|
||||
typedef std::unordered_map<const formula*, bdd,
|
||||
ptr_hash<formula>> f2b_map;
|
||||
typedef std::pair<const formula*, const formula*> pairf;
|
||||
typedef std::map<pairf, bool> syntimpl_cache_t;
|
||||
public:
|
||||
|
|
@ -2857,11 +2857,11 @@ namespace spot
|
|||
// a & (b | X(b M a)) = b M a
|
||||
if (!mo->is_X_free())
|
||||
{
|
||||
typedef Sgi::hash_set<const formula*,
|
||||
ptr_hash<formula> > fset_t;
|
||||
typedef Sgi::hash_map<const formula*,
|
||||
std::set<unsigned>,
|
||||
ptr_hash<formula> > fmap_t;
|
||||
typedef std::unordered_set<const formula*,
|
||||
ptr_hash<formula>> fset_t;
|
||||
typedef std::unordered_map<const formula*,
|
||||
std::set<unsigned>,
|
||||
ptr_hash<formula>> fmap_t;
|
||||
fset_t xgset; // XG(...)
|
||||
fset_t xset; // X(...)
|
||||
fmap_t wuset; // (X...)W(...) or (X...)U(...)
|
||||
|
|
@ -3131,9 +3131,9 @@ namespace spot
|
|||
// F(a) & (a M b) = a M b
|
||||
// F(b) & (a W b) = a U b
|
||||
// F(b) & (a U b) = a U b
|
||||
typedef Sgi::hash_map<const formula*,
|
||||
multop::vec::iterator,
|
||||
ptr_hash<formula> > fmap_t;
|
||||
typedef std::unordered_map<const formula*,
|
||||
multop::vec::iterator,
|
||||
ptr_hash<formula>> fmap_t;
|
||||
fmap_t uwmap; // associates "b" to "a U b" or "a W b"
|
||||
fmap_t rmmap; // associates "a" to "a R b" or "a M b"
|
||||
// (a U b) & (c U b) = (a & c) U b
|
||||
|
|
@ -3606,11 +3606,11 @@ namespace spot
|
|||
// a | (b & X(b U a)) = b U a
|
||||
if (!mo->is_X_free())
|
||||
{
|
||||
typedef Sgi::hash_set<const formula*,
|
||||
ptr_hash<formula> > fset_t;
|
||||
typedef Sgi::hash_map<const formula*,
|
||||
std::set<unsigned>,
|
||||
ptr_hash<formula> > fmap_t;
|
||||
typedef std::unordered_set<const formula*,
|
||||
ptr_hash<formula>> fset_t;
|
||||
typedef std::unordered_map<const formula*,
|
||||
std::set<unsigned>,
|
||||
ptr_hash<formula>> fmap_t;
|
||||
fset_t xfset; // XF(...)
|
||||
fset_t xset; // X(...)
|
||||
fmap_t rmset; // (X...)R(...) or (X...)M(...) or
|
||||
|
|
@ -3922,9 +3922,9 @@ namespace spot
|
|||
// G(a) | (a W b) = a W b
|
||||
// G(b) | (a R b) = a R b.
|
||||
// G(b) | (a M b) = a R b.
|
||||
typedef Sgi::hash_map<const formula*,
|
||||
multop::vec::iterator,
|
||||
ptr_hash<formula> > fmap_t;
|
||||
typedef std::unordered_map<const formula*,
|
||||
multop::vec::iterator,
|
||||
ptr_hash<formula>> fmap_t;
|
||||
fmap_t uwmap; // associates "a" to "a U b" or "a W b"
|
||||
fmap_t rmmap; // associates "b" to "a R b" or "a M b"
|
||||
// (a U b) | (a U c) = a U (b | c)
|
||||
|
|
|
|||
|
|
@ -28,8 +28,8 @@ namespace spot
|
|||
namespace ltl
|
||||
{
|
||||
|
||||
typedef Sgi::hash_map<const formula*, const formula*,
|
||||
ptr_hash<formula> > snf_cache;
|
||||
typedef std::unordered_map<const formula*, const formula*,
|
||||
ptr_hash<formula>> snf_cache;
|
||||
|
||||
/// Helper to rewrite a sere in Star Normal Form.
|
||||
///
|
||||
|
|
|
|||
|
|
@ -30,10 +30,6 @@
|
|||
|
||||
# include <unordered_map>
|
||||
# include <unordered_set>
|
||||
namespace Sgi = std;
|
||||
# define hash_map unordered_map
|
||||
# define hash_multimap unordered_multimap
|
||||
# define hash_set unordered_set
|
||||
|
||||
namespace spot
|
||||
{
|
||||
|
|
@ -60,7 +56,7 @@ namespace spot
|
|||
|
||||
/// \ingroup hash_funcs
|
||||
/// \brief A hash function for strings.
|
||||
typedef Sgi::hash<std::string> string_hash;
|
||||
typedef std::hash<std::string> string_hash;
|
||||
|
||||
/// \ingroup hash_funcs
|
||||
/// \brief A hash function that returns identity
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
// Copyright (C) 2011 Laboratoire de Recherche et Developpement de
|
||||
// l'Epita (LRDE)
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2011, 2013 Laboratoire de Recherche et Developpement
|
||||
// de l'Epita (LRDE)
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
//
|
||||
|
|
@ -117,7 +118,7 @@ namespace spot
|
|||
|
||||
private:
|
||||
struct block_ { block_* next; };
|
||||
Sgi::hash_map<size_t, block_*> freelist_;
|
||||
std::unordered_map<size_t, block_*> freelist_;
|
||||
char* free_start_;
|
||||
char* free_end_;
|
||||
// chunk = several agglomerated blocks
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ namespace spot
|
|||
protected:
|
||||
const bdd all_;
|
||||
const bdd neg_;
|
||||
typedef Sgi::hash_map<bdd, bdd, bdd_hash> bdd_cache_t;
|
||||
typedef std::unordered_map<bdd, bdd, bdd_hash> bdd_cache_t;
|
||||
bdd_cache_t cache_;
|
||||
};
|
||||
} // End namespace Spot
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ namespace spot
|
|||
|
||||
protected:
|
||||
bdd allneg_;
|
||||
typedef Sgi::hash_map<bdd, bdd, bdd_hash> bdd_cache_t;
|
||||
typedef std::unordered_map<bdd, bdd, bdd_hash> bdd_cache_t;
|
||||
bdd_cache_t pos_prod_cache_;
|
||||
bdd_cache_t full_prod_cache_;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -66,9 +66,9 @@ namespace spot
|
|||
/// The class becomes owner of \a state.
|
||||
void add(saba_state* state);
|
||||
private:
|
||||
typedef Sgi::hash_set<shared_saba_state,
|
||||
spot::saba_state_shared_ptr_hash,
|
||||
spot::saba_state_shared_ptr_equal> saba_state_set_t;
|
||||
typedef std::unordered_set<shared_saba_state,
|
||||
saba_state_shared_ptr_hash,
|
||||
saba_state_shared_ptr_equal> saba_state_set_t;
|
||||
saba_state_set_t set_;
|
||||
saba_state_set_t::iterator it_;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -52,9 +52,10 @@ namespace spot
|
|||
///
|
||||
/// Note that the hash value is guaranteed to be unique for all
|
||||
/// equal states (in compare()'s sense) for only has long has one
|
||||
/// of these states exists. So it's OK to use a spot::saba_state as a
|
||||
/// key in a \c hash_map because the mere use of the state as a
|
||||
/// key in the hash will ensure the state continues to exist.
|
||||
/// of these states exists. So it's OK to use a spot::saba_state
|
||||
/// as a key in an \c unordered_map because the mere use of the
|
||||
/// state as a key in the hash will ensure the state continues to
|
||||
/// exist.
|
||||
///
|
||||
/// However if you create the state, get its hash key, delete the
|
||||
/// state, recreate the same state, and get its hash key, you may
|
||||
|
|
@ -63,7 +64,7 @@ namespace spot
|
|||
/// occur only when the state is BDD-encoded, because BDD numbers
|
||||
/// (used to build the hash value) can be reused for other
|
||||
/// formulas. That probably doesn't matter, since the hash value
|
||||
/// is meant to be used in a \c hash_map, but it had to be noted.
|
||||
/// is meant to be used in an \c unordered_map, but it had to be noted.
|
||||
virtual size_t hash() const = 0;
|
||||
|
||||
/// Duplicate a state.
|
||||
|
|
@ -107,13 +108,13 @@ namespace spot
|
|||
/// \brief An Equivalence Relation for \c saba_state*.
|
||||
///
|
||||
/// This is meant to be used as a comparison functor for
|
||||
/// Sgi \c hash_map whose key are of type \c saba_state*.
|
||||
/// \c unordered_map whose keys are of type \c saba_state*.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c saba_state*.
|
||||
/// \code
|
||||
/// // Remember how many times each state has been visited.
|
||||
/// Sgi::hash_map<spot::saba_state*, int, spot::saba_state_ptr_hash,
|
||||
/// std::unordered_map<spot::saba_state*, int, spot::saba_state_ptr_hash,
|
||||
/// spot::saba_state_ptr_equal> seen;
|
||||
/// \endcode
|
||||
struct saba_state_ptr_equal:
|
||||
|
|
@ -132,13 +133,13 @@ namespace spot
|
|||
/// \brief Hash Function for \c saba_state*.
|
||||
///
|
||||
/// This is meant to be used as a hash functor for
|
||||
/// Sgi's \c hash_map whose key are of type \c saba_state*.
|
||||
/// an \c unordered_map whose keys are of type \c saba_state*.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c saba_state*.
|
||||
/// \code
|
||||
/// // Remember how many times each state has been visited.
|
||||
/// Sgi::hash_map<spot::saba_state*, int, spot::saba_state_ptr_hash,
|
||||
/// std::unordered_map<spot::saba_state*, int, spot::saba_state_ptr_hash,
|
||||
/// spot::saba_state_ptr_equal> seen;
|
||||
/// \endcode
|
||||
struct saba_state_ptr_hash:
|
||||
|
|
@ -162,7 +163,7 @@ namespace spot
|
|||
/// (shared_ptr<const saba_state*>).
|
||||
///
|
||||
/// This is meant to be used as a comparison functor for
|
||||
/// STL \c map whose key are of type \c shared_saba_state.
|
||||
/// STL \c map whose keys are of type \c shared_saba_state.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c shared_saba_state.
|
||||
|
|
@ -189,15 +190,15 @@ namespace spot
|
|||
/// (shared_ptr<const saba_state*>).
|
||||
///
|
||||
/// This is meant to be used as a comparison functor for
|
||||
/// Sgi \c hash_map whose key are of type \c shared_saba_state.
|
||||
/// an \c unordred_map whose keys are of type \c shared_saba_state.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c shared_saba_state
|
||||
/// \code
|
||||
/// // Remember how many times each state has been visited.
|
||||
/// Sgi::hash_map<shared_saba_state, int,
|
||||
/// spot::saba_state_shared_ptr_hash,
|
||||
/// spot::saba_state_shared_ptr_equal> seen;
|
||||
/// std::unordered_map<shared_saba_state, int,
|
||||
/// saba_state_shared_ptr_hash,
|
||||
/// saba_state_shared_ptr_equal> seen;
|
||||
/// \endcode
|
||||
struct saba_state_shared_ptr_equal:
|
||||
public std::binary_function<shared_saba_state,
|
||||
|
|
@ -218,16 +219,16 @@ namespace spot
|
|||
/// (shared_ptr<const saba_state*>).
|
||||
///
|
||||
/// This is meant to be used as a hash functor for
|
||||
/// Sgi's \c hash_map whose key are of type
|
||||
/// \c unordered_map whose key are of type
|
||||
/// \c shared_saba_state.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c shared_saba_state.
|
||||
/// \code
|
||||
/// // Remember how many times each state has been visited.
|
||||
/// Sgi::hash_map<shared_saba_state, int,
|
||||
/// spot::saba_state_shared_ptr_hash,
|
||||
/// spot::saba_state_shared_ptr_equal> seen;
|
||||
/// std::unordered_map<shared_saba_state, int,
|
||||
/// saba_state_shared_ptr_hash,
|
||||
/// saba_state_shared_ptr_equal> seen;
|
||||
/// \endcode
|
||||
struct saba_state_shared_ptr_hash:
|
||||
public std::unary_function<shared_saba_state, size_t>
|
||||
|
|
|
|||
|
|
@ -108,8 +108,9 @@ namespace spot
|
|||
protected:
|
||||
const saba* automata_; ///< The spot::saba to explore.
|
||||
|
||||
typedef Sgi::hash_map<const saba_state*, int,
|
||||
saba_state_ptr_hash, saba_state_ptr_equal> seen_map;
|
||||
typedef
|
||||
std::unordered_map<const saba_state*, int,
|
||||
saba_state_ptr_hash, saba_state_ptr_equal> seen_map;
|
||||
seen_map seen; ///< States already seen.
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -238,12 +238,6 @@ for dir in "${INCDIR-..}" "${INCDIR-..}"/../iface; do
|
|||
grep '[^a-zA-Z0-9_](\*[a-zA-Z0-9_]*)\.' $tmp &&
|
||||
diag 'Use "x->y", not "(*x).y"'
|
||||
|
||||
grep 'std::hash' $tmp &&
|
||||
diag 'use Sgi:: for hash and hash_map'
|
||||
|
||||
grep 'Sgi::[^h]' $tmp &&
|
||||
diag 'Sgi:: is for hash and hash_map only'
|
||||
|
||||
egrep 'bdd_(false|true)[ ]*\(' $tmp &&
|
||||
diag 'Use bddfalse and bddtrue instead of bdd_false() and bdd_true()'
|
||||
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ namespace spot
|
|||
state_ta_explicit::get_transitions(bdd condition) const
|
||||
{
|
||||
|
||||
Sgi::hash_map<int, transitions*, Sgi::hash<int> >::const_iterator i =
|
||||
std::unordered_map<int, transitions*, std::hash<int> >::const_iterator i =
|
||||
transitions_by_condition.find(condition.id());
|
||||
|
||||
if (i == transitions_by_condition.end())
|
||||
|
|
@ -334,8 +334,8 @@ namespace spot
|
|||
}
|
||||
delete trans;
|
||||
|
||||
Sgi::hash_map<int, transitions*, Sgi::hash<int> >::iterator i =
|
||||
transitions_by_condition.begin();
|
||||
std::unordered_map<int, transitions*, std::hash<int> >::iterator i =
|
||||
transitions_by_condition.begin();
|
||||
while (i != transitions_by_condition.end())
|
||||
{
|
||||
delete i->second;
|
||||
|
|
|
|||
|
|
@ -236,7 +236,8 @@ namespace spot
|
|||
bool is_accepting_state_;
|
||||
bool is_livelock_accepting_state_;
|
||||
transitions* transitions_;
|
||||
Sgi::hash_map<int, transitions*, Sgi::hash<int> > transitions_by_condition;
|
||||
std::unordered_map<int, transitions*, std::hash<int>>
|
||||
transitions_by_condition;
|
||||
#endif // !SWIG
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2010, 2011, 2012 Laboratoire de Recherche et
|
||||
// Copyright (C) 2010, 2011, 2012, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -72,14 +72,15 @@ namespace spot
|
|||
// it is also used as a key in H.
|
||||
std::stack<pair_state_iter> todo;
|
||||
|
||||
Sgi::hash_map<const state*, std::string, state_ptr_hash, state_ptr_equal>
|
||||
colour;
|
||||
std::unordered_map<const state*, std::string,
|
||||
state_ptr_hash, state_ptr_equal> colour;
|
||||
|
||||
trace
|
||||
<< "PASS 1" << std::endl;
|
||||
|
||||
Sgi::hash_map<const state*, std::set<const state*, state_ptr_less_than>,
|
||||
state_ptr_hash, state_ptr_equal> liveset;
|
||||
std::unordered_map<const state*,
|
||||
std::set<const state*, state_ptr_less_than>,
|
||||
state_ptr_hash, state_ptr_equal> liveset;
|
||||
|
||||
std::stack<spot::state*> livelock_roots;
|
||||
|
||||
|
|
|
|||
|
|
@ -40,9 +40,10 @@
|
|||
|
||||
namespace spot
|
||||
{
|
||||
typedef Sgi::hash_set<const state*, state_ptr_hash, state_ptr_equal> hash_set;
|
||||
typedef Sgi::hash_map<const state*, unsigned, state_ptr_hash, state_ptr_equal>
|
||||
hash_map;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hash_set;
|
||||
typedef std::unordered_map<const state*, unsigned,
|
||||
state_ptr_hash, state_ptr_equal> hash_map;
|
||||
typedef std::list<hash_set*> partition_t;
|
||||
|
||||
namespace
|
||||
|
|
|
|||
|
|
@ -89,8 +89,8 @@ namespace spot
|
|||
|
||||
const ta* t_automata_; ///< The spot::ta to explore.
|
||||
|
||||
typedef Sgi::hash_map<const state*, int, state_ptr_hash, state_ptr_equal>
|
||||
seen_map;
|
||||
typedef std::unordered_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> seen_map;
|
||||
seen_map seen; ///< States already seen.
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -127,13 +127,13 @@ namespace spot
|
|||
/// \brief An Equivalence Relation for \c state*.
|
||||
///
|
||||
/// This is meant to be used as a comparison functor for
|
||||
/// Sgi \c hash_map whose key are of type \c state*.
|
||||
/// an \c unordered_map whose key are of type \c state*.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c state*.
|
||||
/// \code
|
||||
/// // Remember how many times each state has been visited.
|
||||
/// Sgi::hash_map<spot::state*, int, spot::state_ptr_hash,
|
||||
/// std::unordered_map<spot::state*, int, spot::state_ptr_hash,
|
||||
/// spot::state_ptr_equal> seen;
|
||||
/// \endcode
|
||||
struct state_ptr_equal:
|
||||
|
|
@ -152,13 +152,13 @@ namespace spot
|
|||
/// \brief Hash Function for \c state*.
|
||||
///
|
||||
/// This is meant to be used as a hash functor for
|
||||
/// Sgi's \c hash_map whose key are of type \c state*.
|
||||
/// an \c unordered_map whose key are of type \c state*.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c state*.
|
||||
/// \code
|
||||
/// // Remember how many times each state has been visited.
|
||||
/// Sgi::hash_map<spot::state*, int, spot::state_ptr_hash,
|
||||
/// std::unordered_map<spot::state*, int, spot::state_ptr_hash,
|
||||
/// spot::state_ptr_equal> seen;
|
||||
/// \endcode
|
||||
struct state_ptr_hash:
|
||||
|
|
@ -172,9 +172,8 @@ namespace spot
|
|||
}
|
||||
};
|
||||
|
||||
typedef Sgi::hash_set<const state*,
|
||||
spot::state_ptr_hash,
|
||||
spot::state_ptr_equal> state_set;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> state_set;
|
||||
|
||||
|
||||
// Functions related to shared_ptr.
|
||||
|
|
@ -215,15 +214,15 @@ namespace spot
|
|||
/// (shared_ptr<const state*>).
|
||||
///
|
||||
/// This is meant to be used as a comparison functor for
|
||||
/// Sgi \c hash_map whose key are of type \c shared_state.
|
||||
/// un \c unordered_map whose key are of type \c shared_state.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c shared_state
|
||||
/// \code
|
||||
/// // Remember how many times each state has been visited.
|
||||
/// Sgi::hash_map<shared_state, int,
|
||||
/// spot::state_shared_ptr_hash,
|
||||
/// spot::state_shared_ptr_equal> seen;
|
||||
/// std::unordered_map<shared_state, int,
|
||||
/// state_shared_ptr_hash,
|
||||
/// state_shared_ptr_equal> seen;
|
||||
/// \endcode
|
||||
struct state_shared_ptr_equal:
|
||||
public std::binary_function<shared_state,
|
||||
|
|
@ -243,16 +242,16 @@ namespace spot
|
|||
/// \brief Hash Function for \c shared_state (shared_ptr<const state*>).
|
||||
///
|
||||
/// This is meant to be used as a hash functor for
|
||||
/// Sgi's \c hash_map whose key are of type
|
||||
/// an \c unordered_map whose key are of type
|
||||
/// \c shared_state.
|
||||
///
|
||||
/// For instance here is how one could declare
|
||||
/// a map of \c shared_state.
|
||||
/// \code
|
||||
/// // Remember how many times each state has been visited.
|
||||
/// Sgi::hash_map<shared_state, int,
|
||||
/// spot::state_shared_ptr_hash,
|
||||
/// spot::state_shared_ptr_equal> seen;
|
||||
/// std::unordered_map<shared_state, int,
|
||||
/// state_shared_ptr_hash,
|
||||
/// state_shared_ptr_equal> seen;
|
||||
/// \endcode
|
||||
struct state_shared_ptr_hash:
|
||||
public std::unary_function<shared_state, size_t>
|
||||
|
|
@ -265,9 +264,9 @@ namespace spot
|
|||
}
|
||||
};
|
||||
|
||||
typedef Sgi::hash_set<shared_state,
|
||||
state_shared_ptr_hash,
|
||||
state_shared_ptr_equal> shared_state_set;
|
||||
typedef std::unordered_set<shared_state,
|
||||
state_shared_ptr_hash,
|
||||
state_shared_ptr_equal> shared_state_set;
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -127,9 +127,9 @@ namespace spot
|
|||
typedef taa_tgba::state::const_iterator iterator;
|
||||
typedef std::pair<iterator, iterator> iterator_pair;
|
||||
typedef std::vector<iterator_pair> bounds_t;
|
||||
typedef Sgi::hash_map<
|
||||
const spot::set_state*, std::vector<taa_tgba::transition*>,
|
||||
state_ptr_hash, state_ptr_equal> seen_map;
|
||||
typedef std::unordered_map<const spot::set_state*,
|
||||
std::vector<taa_tgba::transition*>,
|
||||
state_ptr_hash, state_ptr_equal> seen_map;
|
||||
|
||||
struct distance_sort :
|
||||
public std::binary_function<const iterator_pair&,
|
||||
|
|
@ -252,12 +252,10 @@ namespace spot
|
|||
protected:
|
||||
typedef label label_t;
|
||||
|
||||
typedef Sgi::hash_map<
|
||||
const label, taa_tgba::state*, label_hash
|
||||
> ns_map;
|
||||
typedef Sgi::hash_map<
|
||||
const taa_tgba::state*, label, ptr_hash<taa_tgba::state>
|
||||
> sn_map;
|
||||
typedef std::unordered_map<const label, taa_tgba::state*,
|
||||
label_hash> ns_map;
|
||||
typedef std::unordered_map<const taa_tgba::state*, label,
|
||||
ptr_hash<taa_tgba::state>> sn_map;
|
||||
|
||||
ns_map name_state_map_;
|
||||
sn_map state_name_map_;
|
||||
|
|
|
|||
|
|
@ -93,8 +93,8 @@ namespace spot
|
|||
private:
|
||||
tgba_bdd_core_data data_; ///< Core data for the new automata.
|
||||
|
||||
typedef Sgi::hash_map<const ltl::formula*, bdd,
|
||||
ltl::formula_ptr_hash> acc_map_;
|
||||
typedef std::unordered_map<const ltl::formula*, bdd,
|
||||
ltl::formula_ptr_hash> acc_map_;
|
||||
acc_map_ acc_; ///< BDD associated to each acceptance condition
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -261,9 +261,9 @@ namespace spot
|
|||
typedef typename State::transition transition;
|
||||
typedef State state;
|
||||
protected:
|
||||
typedef Sgi::hash_map<label_t, State, label_hash_t> ls_map;
|
||||
typedef Sgi::hash_map<label_t, State*, label_hash_t> alias_map;
|
||||
typedef Sgi::hash_map<const State*, label_t, ptr_hash<State> > sl_map;
|
||||
typedef std::unordered_map<label_t, State, label_hash_t> ls_map;
|
||||
typedef std::unordered_map<label_t, State*, label_hash_t> alias_map;
|
||||
typedef std::unordered_map<const State*, label_t, ptr_hash<State> > sl_map;
|
||||
|
||||
public:
|
||||
|
||||
|
|
@ -397,8 +397,8 @@ namespace spot
|
|||
{
|
||||
typedef typename transitions_t::iterator trans_t;
|
||||
typedef std::map<int, trans_t> acc_map;
|
||||
typedef Sgi::hash_map<const spot::state*, acc_map,
|
||||
ptr_hash<spot::state> > dest_map;
|
||||
typedef std::unordered_map<const spot::state*, acc_map,
|
||||
ptr_hash<spot::state> > dest_map;
|
||||
|
||||
typename ls_map::iterator i;
|
||||
for (i = ls_.begin(); i != ls_.end(); ++i)
|
||||
|
|
|
|||
|
|
@ -88,9 +88,9 @@ namespace spot
|
|||
};
|
||||
|
||||
// typedefs.
|
||||
typedef Sgi::hash_map<shared_state, rank_t,
|
||||
state_shared_ptr_hash,
|
||||
state_shared_ptr_equal> state_rank_map;
|
||||
typedef std::unordered_map<shared_state, rank_t,
|
||||
state_shared_ptr_hash,
|
||||
state_shared_ptr_equal> state_rank_map;
|
||||
|
||||
////////////////////////////////////////
|
||||
// state_kv_complement
|
||||
|
|
|
|||
|
|
@ -763,8 +763,8 @@ namespace spot
|
|||
//////////////////////////////
|
||||
namespace test
|
||||
{
|
||||
typedef Sgi::hash_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> stnum_t;
|
||||
typedef std::unordered_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> stnum_t;
|
||||
|
||||
void print_safra_tree(const safra_tree* this_node,
|
||||
stnum_t& node_names,
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ namespace spot
|
|||
}
|
||||
|
||||
// Note: There is a default copy constructor, needed by
|
||||
// Sgi::hash_set. It does not clone the state "s", because the
|
||||
// std::unordered_set. It does not clone the state "s", because the
|
||||
// destructor will not destroy it either. Actually, the states
|
||||
// are all destroyed in the tgba_tba_proxy destructor.
|
||||
|
||||
|
|
@ -127,9 +127,9 @@ namespace spot
|
|||
}
|
||||
};
|
||||
|
||||
typedef Sgi::hash_set<state_tba_proxy,
|
||||
state_tba_proxy_hash,
|
||||
state_tba_proxy_equal> uniq_map_t;
|
||||
typedef std::unordered_set<state_tba_proxy,
|
||||
state_tba_proxy_hash,
|
||||
state_tba_proxy_equal> uniq_map_t;
|
||||
|
||||
typedef std::pair<const state_tba_proxy*, bool> state_ptr_bool_t;
|
||||
|
||||
|
|
@ -382,9 +382,9 @@ namespace spot
|
|||
protected:
|
||||
const bdd the_acceptance_cond_;
|
||||
|
||||
typedef Sgi::hash_map<state_ptr_bool_t, bdd,
|
||||
state_ptr_bool_hash,
|
||||
state_ptr_bool_equal> transmap_t;
|
||||
typedef std::unordered_map<state_ptr_bool_t, bdd,
|
||||
state_ptr_bool_hash,
|
||||
state_ptr_bool_equal> transmap_t;
|
||||
transmap_t transmap_;
|
||||
typedef transmap_t::const_iterator mapit_t;
|
||||
typedef std::list<mapit_t> translist_t;
|
||||
|
|
|
|||
|
|
@ -111,8 +111,8 @@ namespace spot
|
|||
|
||||
private:
|
||||
bdd the_acceptance_cond_;
|
||||
typedef Sgi::hash_map<const state*, bdd,
|
||||
state_ptr_hash, state_ptr_equal> accmap_t;
|
||||
typedef std::unordered_map<const state*, bdd,
|
||||
state_ptr_hash, state_ptr_equal> accmap_t;
|
||||
mutable accmap_t accmap_;
|
||||
mutable accmap_t accmapu_;
|
||||
|
||||
|
|
|
|||
|
|
@ -35,8 +35,8 @@ namespace spot
|
|||
tgba_explicit_string* sub_a = new tgba_explicit_string(a->get_dict());
|
||||
state* cur = a->get_init_state();
|
||||
std::queue<state*> tovisit;
|
||||
typedef Sgi::hash_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
// Setup
|
||||
hash_type seen;
|
||||
unsigned scc_number;
|
||||
|
|
|
|||
|
|
@ -79,8 +79,8 @@ namespace spot
|
|||
class SPOT_API enumerate_cycles
|
||||
{
|
||||
protected:
|
||||
typedef Sgi::hash_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> set_type;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> set_type;
|
||||
|
||||
// Extra information required for the algorithm for each state.
|
||||
struct state_info
|
||||
|
|
@ -105,8 +105,8 @@ namespace spot
|
|||
};
|
||||
|
||||
// Store the state_info for all visited states.
|
||||
typedef Sgi::hash_map<const state*, state_info,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_map<const state*, state_info,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
hash_type tags_;
|
||||
|
||||
// A tagged_state s is a state* (s->first) associated to its
|
||||
|
|
|
|||
|
|
@ -60,8 +60,8 @@ namespace spot
|
|||
};
|
||||
|
||||
// Associate the degeneralized state to its number.
|
||||
typedef Sgi::hash_map<degen_state, int,
|
||||
degen_state_hash, degen_state_equal> ds2num_map;
|
||||
typedef std::unordered_map<degen_state, int,
|
||||
degen_state_hash, degen_state_equal> ds2num_map;
|
||||
|
||||
// Queue of state to be processed.
|
||||
typedef std::deque<degen_state> queue_t;
|
||||
|
|
@ -69,7 +69,7 @@ namespace spot
|
|||
// Memory management for the input states.
|
||||
class unicity_table
|
||||
{
|
||||
typedef Sgi::hash_set<const state*,
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> uniq_set;
|
||||
uniq_set m;
|
||||
public:
|
||||
|
|
@ -112,8 +112,8 @@ namespace spot
|
|||
{
|
||||
const tgba* a_;
|
||||
typedef std::pair<bdd, bdd> cache_entry;
|
||||
typedef Sgi::hash_map<const state*, cache_entry,
|
||||
state_ptr_hash, state_ptr_equal> cache_t;
|
||||
typedef std::unordered_map<const state*, cache_entry,
|
||||
state_ptr_hash, state_ptr_equal> cache_t;
|
||||
cache_t cache_;
|
||||
const scc_map* sm_;
|
||||
|
||||
|
|
@ -170,8 +170,8 @@ namespace spot
|
|||
class has_acc_loop
|
||||
{
|
||||
const tgba* a_;
|
||||
typedef Sgi::hash_map<const state*, bool,
|
||||
state_ptr_hash, state_ptr_equal> cache_t;
|
||||
typedef std::unordered_map<const state*, bool,
|
||||
state_ptr_hash, state_ptr_equal> cache_t;
|
||||
cache_t cache_;
|
||||
unicity_table& uniq_;
|
||||
|
||||
|
|
|
|||
|
|
@ -212,9 +212,9 @@ namespace spot
|
|||
std::map<path, int> pathid_ref;
|
||||
std::map<path, int> pathid_cand;
|
||||
int nvars;
|
||||
typedef Sgi::hash_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> state_map;
|
||||
typedef Sgi::hash_map<int, const state*> int_map;
|
||||
typedef std::unordered_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> state_map;
|
||||
typedef std::unordered_map<int, const state*> int_map;
|
||||
state_map state_to_int;
|
||||
int_map int_to_state;
|
||||
int cand_size;
|
||||
|
|
|
|||
|
|
@ -260,9 +260,9 @@ namespace spot
|
|||
|
||||
std::map<path, int> pathid;
|
||||
int nvars;
|
||||
typedef Sgi::hash_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> state_map;
|
||||
typedef Sgi::hash_map<int, const state*> int_map;
|
||||
typedef std::unordered_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> state_map;
|
||||
typedef std::unordered_map<int, const state*> int_map;
|
||||
state_map state_to_int;
|
||||
int_map int_to_state;
|
||||
int cand_size;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
// Copyright (C) 2008, 2009, 2010, 2012 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2008, 2009, 2010, 2012, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
//
|
||||
|
|
@ -221,15 +222,16 @@ namespace spot
|
|||
bool root_;
|
||||
|
||||
/// BDD associated to each automatop A representing finish(A).
|
||||
typedef Sgi::hash_map<const ltl::formula*, bdd,
|
||||
ltl::formula_ptr_hash> finish_map_;
|
||||
typedef std::unordered_map<const ltl::formula*, bdd,
|
||||
ltl::formula_ptr_hash> finish_map_;
|
||||
|
||||
finish_map_ finish_;
|
||||
|
||||
// Table containing the two now variables associated with each state.
|
||||
// TODO: a little documentation about that.
|
||||
typedef Sgi::hash_map<
|
||||
const nfa::state*, std::pair<int, int>, ptr_hash<nfa::state> > nmap;
|
||||
typedef std::unordered_map<const nfa::state*,
|
||||
std::pair<int, int>,
|
||||
ptr_hash<nfa::state>> nmap;
|
||||
|
||||
std::pair<int, int>&
|
||||
recurse_state(const nfa::ptr& nfa, const nfa::state* s,
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
// Copyright (C) 2009, 2011, 2012 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2009, 2011, 2012, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
// Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -305,8 +306,8 @@ namespace spot
|
|||
const tgba_run::steps* l;
|
||||
bdd seen_acc = bddfalse;
|
||||
|
||||
typedef Sgi::hash_map<const state*, state_explicit_string*,
|
||||
state_ptr_hash, state_ptr_equal> state_map;
|
||||
typedef std::unordered_map<const state*, state_explicit_string*,
|
||||
state_ptr_hash, state_ptr_equal> state_map;
|
||||
state_map seen;
|
||||
|
||||
if (run->prefix.empty())
|
||||
|
|
|
|||
|
|
@ -56,8 +56,8 @@ namespace spot
|
|||
virtual const state* has_state(const state* s) const;
|
||||
virtual void insert(const state* s);
|
||||
protected:
|
||||
typedef Sgi::hash_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> set_type;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> set_type;
|
||||
set_type states;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -121,8 +121,8 @@ namespace spot
|
|||
|
||||
virtual numbered_state_heap_const_iterator* iterator() const;
|
||||
|
||||
typedef Sgi::hash_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
protected:
|
||||
hash_type h; ///< Map of visited states.
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
// Copyright (C) 2008, 2010, 2011 Laboratoire de recherche et
|
||||
// développement de l'Epita (LRDE).
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2008, 2010, 2011, 2013 Laboratoire de recherche et
|
||||
// développement de l'Epita (LRDE).
|
||||
// Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6
|
||||
// (LIP6), département Systèmes Répartis Coopératifs (SRC), Université
|
||||
// (LIP6), département Systèmes Répartis Coopératifs (SRC), Université
|
||||
// Pierre et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -58,8 +59,8 @@ namespace spot
|
|||
bdd accepting;
|
||||
|
||||
// Map of visited states.
|
||||
typedef Sgi::hash_map<const state*, size_t,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_map<const state*, size_t,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
hash_type h;
|
||||
|
||||
// Stack of visited states on the path.
|
||||
|
|
|
|||
|
|
@ -120,8 +120,8 @@ namespace spot
|
|||
private:
|
||||
translate_dict& dict_;
|
||||
std::vector<tgba_explicit_formula*> automata_;
|
||||
typedef Sgi::hash_map<const formula*, tgba_explicit_formula*,
|
||||
formula_ptr_hash> f2a_t;
|
||||
typedef std::unordered_map<const formula*, tgba_explicit_formula*,
|
||||
formula_ptr_hash> f2a_t;
|
||||
f2a_t f2a_;
|
||||
};
|
||||
|
||||
|
|
@ -218,8 +218,9 @@ namespace spot
|
|||
bool has_marked:1;
|
||||
};
|
||||
|
||||
typedef Sgi::hash_map<flagged_formula, translated, flagged_formula_hash>
|
||||
flagged_formula_to_bdd_map;
|
||||
typedef
|
||||
std::unordered_map<flagged_formula, translated,
|
||||
flagged_formula_hash> flagged_formula_to_bdd_map;
|
||||
private:
|
||||
flagged_formula_to_bdd_map ltl_bdd_;
|
||||
|
||||
|
|
@ -1893,7 +1894,8 @@ namespace spot
|
|||
}
|
||||
|
||||
private:
|
||||
typedef Sgi::hash_map<const formula*, bool, formula_ptr_hash> pfl_map;
|
||||
typedef std::unordered_map<const formula*, bool,
|
||||
formula_ptr_hash> pfl_map;
|
||||
pfl_map pfl_;
|
||||
};
|
||||
|
||||
|
|
@ -2039,13 +2041,14 @@ namespace spot
|
|||
// We do this because many formulae (such as `aR(bRc)' and
|
||||
// `aR(bRc).(bRc)') are equivalent, and are trivially identified
|
||||
// by looking at the set of successors.
|
||||
typedef Sgi::hash_map<bdd, const formula*, bdd_hash> bdd_to_formula_map;
|
||||
typedef std::unordered_map<bdd, const formula*,
|
||||
bdd_hash> bdd_to_formula_map;
|
||||
bdd_to_formula_map b2f_;
|
||||
// Map each formula to its associated bdd. This speed things up when
|
||||
// the same formula is translated several times, which especially
|
||||
// occurs when canonize() is called repeatedly inside exprop.
|
||||
typedef Sgi::hash_map<const formula*, translate_dict::translated,
|
||||
ptr_hash<formula> > formula_to_bdd_map;
|
||||
typedef std::unordered_map<const formula*, translate_dict::translated,
|
||||
ptr_hash<formula> > formula_to_bdd_map;
|
||||
formula_to_bdd_map f2b_;
|
||||
|
||||
possible_fair_loop_checker pflc_;
|
||||
|
|
@ -2057,7 +2060,8 @@ namespace spot
|
|||
}
|
||||
|
||||
typedef std::map<bdd, bdd, bdd_less_than> prom_map;
|
||||
typedef Sgi::hash_map<const formula*, prom_map, formula_ptr_hash> dest_map;
|
||||
typedef std::unordered_map<const formula*, prom_map,
|
||||
formula_ptr_hash> dest_map;
|
||||
|
||||
static void
|
||||
fill_dests(translate_dict& d, dest_map& dests, bdd label, const formula* dest)
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
// Copyright (C) 2011 Laboratoire de recherche et développement de
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2011, 2013 Laboratoire de recherche et développement de
|
||||
// l'Epita (LRDE).
|
||||
// Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -504,8 +505,8 @@ namespace spot
|
|||
|
||||
private:
|
||||
|
||||
typedef Sgi::hash_map<const state*, color,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_map<const state*, color,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
hash_type h;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -52,10 +52,10 @@
|
|||
|
||||
namespace spot
|
||||
{
|
||||
typedef Sgi::hash_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hash_set;
|
||||
typedef Sgi::hash_map<const state*, unsigned,
|
||||
state_ptr_hash, state_ptr_equal> hash_map;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hash_set;
|
||||
typedef std::unordered_map<const state*, unsigned,
|
||||
state_ptr_hash, state_ptr_equal> hash_map;
|
||||
|
||||
namespace
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
// Copyright (C) 2011 Laboratoire de recherche et développement de
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2011, 2013 Laboratoire de recherche et développement de
|
||||
// l'Epita (LRDE).
|
||||
// Copyright (C) 2004, 2005, 2006 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -226,8 +227,8 @@ namespace spot
|
|||
};
|
||||
typedef std::list<transition> accepting_transitions_list;
|
||||
|
||||
typedef Sgi::hash_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> state_set;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> state_set;
|
||||
|
||||
void clean(stack_type& st1, state_set& seen, state_set& dead)
|
||||
{
|
||||
|
|
@ -457,8 +458,9 @@ namespace spot
|
|||
}
|
||||
}
|
||||
|
||||
typedef Sgi::hash_multimap<const state*, transition,
|
||||
state_ptr_hash, state_ptr_equal> m_source_trans;
|
||||
typedef std::unordered_multimap<const state*, transition,
|
||||
state_ptr_hash,
|
||||
state_ptr_equal> m_source_trans;
|
||||
|
||||
template<bool cycle>
|
||||
class min_path: public bfs_steps
|
||||
|
|
|
|||
|
|
@ -34,8 +34,8 @@ namespace spot
|
|||
{
|
||||
typedef std::set<const state*, state_ptr_less_than> power_state;
|
||||
typedef std::map<int, power_state> power_map_data;
|
||||
typedef Sgi::hash_set<const state*, state_ptr_hash,
|
||||
state_ptr_equal> state_set;
|
||||
typedef std::unordered_set<const state*, state_ptr_hash,
|
||||
state_ptr_equal> state_set;
|
||||
|
||||
~power_map()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2008, 2009, 2010, 2012 Laboratoire de Recherche et
|
||||
// Copyright (C) 2008, 2009, 2010, 2012, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE).
|
||||
// Copyright (C) 2004, 2005, 2007 Laboratoire d'Informatique de
|
||||
// Paris 6 (LIP6), département Systèmes Répartis Coopératifs (SRC),
|
||||
|
|
@ -126,7 +126,7 @@ namespace spot
|
|||
*i &= bdd_exist(allneg, *i);
|
||||
|
||||
|
||||
// Using Sgi::hash_set instead of std::set for these sets is 3
|
||||
// Using std::unordered_set instead of std::set for these sets is 3
|
||||
// times slower (tested on a 50000 nodes example). Use an int
|
||||
// (the index into states[]), not the tgba_explicit::state*
|
||||
// directly, because the later would yield different graphs
|
||||
|
|
|
|||
|
|
@ -91,8 +91,8 @@ namespace spot
|
|||
protected:
|
||||
const tgba* aut_; ///< The spot::tgba to explore.
|
||||
|
||||
typedef Sgi::hash_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> seen_map;
|
||||
typedef std::unordered_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> seen_map;
|
||||
seen_map seen; ///< States already seen.
|
||||
};
|
||||
|
||||
|
|
@ -161,8 +161,8 @@ namespace spot
|
|||
protected:
|
||||
const tgba* aut_; ///< The spot::tgba to explore.
|
||||
|
||||
typedef Sgi::hash_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> seen_map;
|
||||
typedef std::unordered_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> seen_map;
|
||||
seen_map seen; ///< States already seen.
|
||||
struct stack_item
|
||||
{
|
||||
|
|
@ -197,7 +197,7 @@ namespace spot
|
|||
virtual void push(const state* s, int sn);
|
||||
virtual void pop();
|
||||
|
||||
Sgi::hash_set<int> stack_;
|
||||
std::unordered_set<int> stack_;
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
// Copyright (C) 2011 Laboratoire de Recherche et Développement
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2011, 2013 Laboratoire de Recherche et Développement
|
||||
// de l'Epita (LRDE).
|
||||
// Copyright (C) 2004 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -52,8 +53,8 @@ namespace spot
|
|||
bdd all_acc = bddfalse;
|
||||
bdd expected_all_acc = a->all_acceptance_conditions();
|
||||
bool all_acc_seen = false;
|
||||
typedef Sgi::hash_map<const state*, std::set<int>,
|
||||
state_ptr_hash, state_ptr_equal> state_map;
|
||||
typedef std::unordered_map<const state*, std::set<int>,
|
||||
state_ptr_hash, state_ptr_equal> state_map;
|
||||
state_map seen;
|
||||
|
||||
if (run->prefix.empty())
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
// Copyright (C) 2010, 2011 Laboratoire de Recherche et Développement de
|
||||
// l'Epita (LRDE)
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2010, 2011, 2013 Laboratoire de Recherche et
|
||||
// Développement de l'Epita (LRDE)
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
//
|
||||
|
|
@ -71,8 +72,8 @@ namespace spot
|
|||
|
||||
bool is_safety_mwdba(const tgba* aut)
|
||||
{
|
||||
typedef Sgi::hash_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> seen_map;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> seen_map;
|
||||
seen_map seen; // States already seen.
|
||||
std::deque<const state*> todo; // A queue of states yet to explore.
|
||||
|
||||
|
|
|
|||
|
|
@ -223,8 +223,8 @@ namespace spot
|
|||
// between each of these SCC.
|
||||
std::stack<bdd> arc_cond_; // A stack of conditions
|
||||
// between each of these SCC.
|
||||
typedef Sgi::hash_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_map<const state*, int,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
hash_type h_; // Map of visited states. Values >= 0
|
||||
// designate maximal SCC. Values < 0
|
||||
// number states that are part of
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
// Copyright (C) 2011 Laboratoire de Recherche et Developpement de
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2011, 2013 Laboratoire de Recherche et Developpement de
|
||||
// l'Epita (LRDE).
|
||||
// Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -436,10 +437,10 @@ namespace spot
|
|||
|
||||
class explicit_se05_search_heap
|
||||
{
|
||||
typedef Sgi::hash_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hcyan_type;
|
||||
typedef Sgi::hash_map<const state*, color,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hcyan_type;
|
||||
typedef std::unordered_map<const state*, color,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
public:
|
||||
enum { Safe = 1 };
|
||||
|
||||
|
|
@ -572,8 +573,8 @@ namespace spot
|
|||
class bsh_se05_search_heap
|
||||
{
|
||||
private:
|
||||
typedef Sgi::hash_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hcyan_type;
|
||||
typedef std::unordered_set<const state*,
|
||||
state_ptr_hash, state_ptr_equal> hcyan_type;
|
||||
public:
|
||||
enum { Safe = 0 };
|
||||
|
||||
|
|
|
|||
|
|
@ -101,13 +101,13 @@ namespace spot
|
|||
// Some useful typedef:
|
||||
|
||||
// Used to get the signature of the state.
|
||||
typedef Sgi::hash_map<const state*, bdd,
|
||||
state_ptr_hash,
|
||||
state_ptr_equal> map_state_bdd;
|
||||
typedef std::unordered_map<const state*, bdd,
|
||||
state_ptr_hash,
|
||||
state_ptr_equal> map_state_bdd;
|
||||
|
||||
typedef Sgi::hash_map<const state*, unsigned,
|
||||
state_ptr_hash,
|
||||
state_ptr_equal> map_state_unsigned;
|
||||
typedef std::unordered_map<const state*, unsigned,
|
||||
state_ptr_hash,
|
||||
state_ptr_equal> map_state_unsigned;
|
||||
|
||||
typedef std::map<const state*, const state*,
|
||||
state_ptr_less_than> map_state_state;
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
// Copyright (C) 2011 Laboratoire de Recherche et Developpement de
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2011, 2013 Laboratoire de Recherche et Developpement de
|
||||
// l'Epita (LRDE).
|
||||
// Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -368,8 +369,8 @@ namespace spot
|
|||
}
|
||||
private:
|
||||
|
||||
typedef Sgi::hash_map<const state*, std::pair<color, bdd>,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_map<const state*, std::pair<color, bdd>,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
hash_type h;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
// Copyright (C) 2011 Laboratoire de Recherche et Developpement de
|
||||
// -*- coding: utf-8 -*-
|
||||
// Copyright (C) 2011, 2013 Laboratoire de Recherche et Developpement de
|
||||
// l'Epita (LRDE).
|
||||
// Copyright (C) 2004, 2005 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
// et Marie Curie.
|
||||
//
|
||||
// This file is part of Spot, a model checking library.
|
||||
|
|
@ -409,10 +410,10 @@ namespace spot
|
|||
|
||||
class explicit_tau03_opt_search_heap
|
||||
{
|
||||
typedef Sgi::hash_map<const state*, std::pair<weight, bdd>,
|
||||
state_ptr_hash, state_ptr_equal> hcyan_type;
|
||||
typedef Sgi::hash_map<const state*, std::pair<color, bdd>,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
typedef std::unordered_map<const state*, std::pair<weight, bdd>,
|
||||
state_ptr_hash, state_ptr_equal> hcyan_type;
|
||||
typedef std::unordered_map<const state*, std::pair<color, bdd>,
|
||||
state_ptr_hash, state_ptr_equal> hash_type;
|
||||
public:
|
||||
class color_ref
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue