alarsyo/spot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

c++11: replace Sgi::hash_* by Sgi::unordered_*.

Browse source 
* 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 2013-12-15 23:26:25 +01:00
parent c568b4d337
commit 34e91b7656
61 changed files with 284 additions and 271 deletions
Download patch file Download diff file Expand all files Collapse all files

4
bench/scc-stats/stats.cc
View file

@ -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;

4
bench/split-product/cutscc.cc
View file

@ -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;

25
iface/gspn/ssp.cc
View file

@ -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;

4
src/bin/ltlcross.cc
View file

@ -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

5
src/bin/ltlfilt.cc
View file

@ -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
{

5
src/bin/randltl.cc
View file

@ -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;

4
src/dstarparse/nsa2tgba.cc
View file

@ -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;

6
src/ltlast/formula.hh
View file

@ -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>

4
src/ltlast/nfa.hh
View file

@ -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_;

4
src/ltlvisit/contain.hh
View file

@ -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.

4
src/ltlvisit/dotty.cc
View file

@ -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)
{

9
src/ltlvisit/mark.hh
View file

@ -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_;

8
src/ltlvisit/relabel.cc
View file

@ -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;

6
src/ltlvisit/relabel.hh
View file

@ -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()
{

40
src/ltlvisit/simplify.cc
View file

@ -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)

4
src/ltlvisit/snf.hh
View file

@ -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.
///

6
src/misc/hash.hh
View file

@ -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

7
src/misc/mspool.hh
View file

@ -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

2
src/priv/acccompl.hh
View file

@ -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

2
src/priv/accconv.hh
View file

@ -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_;
};

6
src/saba/explicitstateconjunction.hh
View file

@ -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_;
};

35
src/saba/sabastate.hh
View file

@ -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>

5
src/sabaalgos/sabareachiter.hh
View file

@ -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.
};

6
src/sanity/style.test
View file

@ -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()'

6
src/ta/taexplicit.cc
View file

@ -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;

3
src/ta/taexplicit.hh
View file

@ -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
};

11
src/taalgos/emptinessta.cc
View file

@ -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;

7
src/taalgos/minimize.cc
View file

@ -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

4
src/taalgos/reachiter.hh
View file

@ -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.
};

35
src/tgba/state.hh
View file

@ -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;
}

16
src/tgba/taatgba.hh
View file

@ -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_;

4
src/tgba/tgbabddconcretefactory.hh
View file

@ -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
};

10
src/tgba/tgbaexplicit.hh
View file

@ -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)

6
src/tgba/tgbakvcomplement.cc
View file

@ -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

4
src/tgba/tgbasafracomplement.cc
View file

@ -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,

14
src/tgba/tgbatba.cc
View file

@ -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;

4
src/tgba/tgbatba.hh
View file

@ -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_;

4
src/tgbaalgos/cutscc.cc
View file

@ -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;

8
src/tgbaalgos/cycles.hh
View file

@ -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

14
src/tgbaalgos/degen.cc
View file

@ -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_;

6
src/tgbaalgos/dtbasat.cc
View file

@ -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;

6
src/tgbaalgos/dtgbasat.cc
View file

@ -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;

14
src/tgbaalgos/eltl2tgba_lacim.cc
View file

@ -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,

11
src/tgbaalgos/emptiness.cc
View file

@ -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())

4
src/tgbaalgos/gtec/explscc.hh
View file

@ -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;
};

4
src/tgbaalgos/gtec/nsheap.hh
View file

@ -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.
};

11
src/tgbaalgos/gv04.cc
View file

@ -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.

22
src/tgbaalgos/ltl2tgba_fm.cc
View file

@ -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)

9
src/tgbaalgos/magic.cc
View file

@ -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;
};

8
src/tgbaalgos/minimize.cc
View file

@ -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
{

14
src/tgbaalgos/ndfs_result.hxx
View file

@ -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

4
src/tgbaalgos/powerset.hh
View file

@ -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()
{

4
src/tgbaalgos/randomgraph.cc
View file

@ -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

10
src/tgbaalgos/reachiter.hh
View file

@ -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_;
};
}

9
src/tgbaalgos/replayrun.cc
View file

@ -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())

9
src/tgbaalgos/safety.cc
View file

@ -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.

4
src/tgbaalgos/scc.hh
View file

@ -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

17
src/tgbaalgos/se05.cc
View file

@ -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 };

12
src/tgbaalgos/simulation.cc
View file

@ -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;

9
src/tgbaalgos/tau03.cc
View file

@ -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;
};

13
src/tgbaalgos/tau03opt.cc
View file

@ -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
{