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

rename tgba_product as twa_product

Browse source 
Automatic mass renaming.

* iface/ltsmin/finite.test, src/ta/tgtaproduct.cc,
src/ta/tgtaproduct.hh, src/tgba/fwd.hh, src/tgba/tgbaproduct.cc,
src/tgba/tgbaproduct.hh, wrap/python/spot_impl.i: Rename tgba_product
as twa_product.
This commit is contained in:
Alexandre Duret-Lutz 2015-04-21 19:24:49 +02:00
parent e0bd0ad4c0
commit c856933099
7 changed files with 40 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

2
iface/ltsmin/finite.test
View file

@ -54,5 +54,5 @@ run 0 ../modelcheck -ddead -e $srcdir/finite.dve \
'!(G(dead -> ("P.a==2" | "P.b==3")))'
# This used to segfault because of a bug in
# tgba_product::transition_annotation.
# twa_product::transition_annotation.
run 0 ../modelcheck -gp $srcdir/finite.dve true

2
src/ta/tgtaproduct.cc
View file

@ -45,7 +45,7 @@ namespace spot
tgta_product::tgta_product(const const_kripke_ptr& left,
const const_tgta_ptr& right):
tgba_product(left, right)
twa_product(left, right)
{
}

2
src/ta/tgtaproduct.hh
View file

@ -29,7 +29,7 @@ namespace spot
{
/// \brief A lazy product. (States are computed on the fly.)
class SPOT_API tgta_product : public tgba_product
class SPOT_API tgta_product : public twa_product
{
public:
tgta_product(const const_kripke_ptr& left,

6
src/tgba/fwd.hh
View file

@ -31,7 +31,7 @@ namespace spot
typedef std::shared_ptr<const twa_graph> const_twa_graph_ptr;
typedef std::shared_ptr<twa_graph> twa_graph_ptr;
class tgba_product;
typedef std::shared_ptr<const tgba_product> const_tgba_product_ptr;
typedef std::shared_ptr<tgba_product> tgba_product_ptr;
class twa_product;
typedef std::shared_ptr<const twa_product> const_twa_product_ptr;
typedef std::shared_ptr<twa_product> twa_product_ptr;
}

40
src/tgba/tgbaproduct.cc
View file

@ -84,7 +84,7 @@ namespace spot
public:
tgba_succ_iterator_product_common(tgba_succ_iterator* left,
tgba_succ_iterator* right,
const tgba_product* prod,
const twa_product* prod,
fixed_size_pool* pool)
: left_(left), right_(right), prod_(prod), pool_(pool)
{
@ -140,9 +140,9 @@ namespace spot
protected:
tgba_succ_iterator* left_;
tgba_succ_iterator* right_;
const tgba_product* prod_;
const twa_product* prod_;
fixed_size_pool* pool_;
friend class spot::tgba_product;
friend class spot::twa_product;
};
@ -152,7 +152,7 @@ namespace spot
public:
tgba_succ_iterator_product(tgba_succ_iterator* left,
tgba_succ_iterator* right,
const tgba_product* prod,
const twa_product* prod,
fixed_size_pool* pool)
: tgba_succ_iterator_product_common(left, right, prod, pool)
{
@ -222,7 +222,7 @@ namespace spot
public:
tgba_succ_iterator_product_kripke(tgba_succ_iterator* left,
tgba_succ_iterator* right,
const tgba_product* prod,
const twa_product* prod,
fixed_size_pool* pool)
: tgba_succ_iterator_product_common(left, right, prod, pool)
{
@ -280,9 +280,9 @@ namespace spot
} // anonymous
////////////////////////////////////////////////////////////
// tgba_product
// twa_product
tgba_product::tgba_product(const const_tgba_ptr& left,
twa_product::twa_product(const const_tgba_ptr& left,
const const_tgba_ptr& right)
: twa(left->get_dict()), left_(left), right_(right),
pool_(sizeof(state_product))
@ -318,7 +318,7 @@ namespace spot
set_acceptance(left_num + right->acc().num_sets(), right_acc);
}
tgba_product::~tgba_product()
twa_product::~twa_product()
{
get_dict()->unregister_all_my_variables(this);
// Prevent these states from being destroyed by ~tgba(): they
@ -331,7 +331,7 @@ namespace spot
}
state*
tgba_product::get_init_state() const
twa_product::get_init_state() const
{
fixed_size_pool* p = const_cast<fixed_size_pool*>(&pool_);
return new(p->allocate()) state_product(left_->get_init_state(),
@ -339,7 +339,7 @@ namespace spot
}
tgba_succ_iterator*
tgba_product::succ_iter(const state* state) const
twa_product::succ_iter(const state* state) const
{
const state_product* s = down_cast<const state_product*>(state);
assert(s);
@ -363,7 +363,7 @@ namespace spot
}
bdd
tgba_product::compute_support_conditions(const state* in) const
twa_product::compute_support_conditions(const state* in) const
{
const state_product* s = down_cast<const state_product*>(in);
assert(s);
@ -372,18 +372,18 @@ namespace spot
return lsc & rsc;
}
const acc_cond& tgba_product::left_acc() const
const acc_cond& twa_product::left_acc() const
{
return left_->acc();
}
const acc_cond& tgba_product::right_acc() const
const acc_cond& twa_product::right_acc() const
{
return right_->acc();
}
std::string
tgba_product::format_state(const state* state) const
twa_product::format_state(const state* state) const
{
const state_product* s = down_cast<const state_product*>(state);
assert(s);
@ -393,7 +393,7 @@ namespace spot
}
state*
tgba_product::project_state(const state* s, const const_tgba_ptr& t) const
twa_product::project_state(const state* s, const const_tgba_ptr& t) const
{
const state_product* s2 = down_cast<const state_product*>(s);
assert(s2);
@ -406,7 +406,7 @@ namespace spot
}
std::string
tgba_product::transition_annotation(const tgba_succ_iterator* t) const
twa_product::transition_annotation(const tgba_succ_iterator* t) const
{
const tgba_succ_iterator_product_common* i =
down_cast<const tgba_succ_iterator_product_common*>(t);
@ -421,13 +421,13 @@ namespace spot
}
//////////////////////////////////////////////////////////////////////
// tgba_product_init
// twa_product_init
tgba_product_init::tgba_product_init(const const_tgba_ptr& left,
twa_product_init::twa_product_init(const const_tgba_ptr& left,
const const_tgba_ptr& right,
const state* left_init,
const state* right_init)
: tgba_product(left, right),
: twa_product(left, right),
left_init_(left_init), right_init_(right_init)
{
if (left_ != left)
@ -435,7 +435,7 @@ namespace spot
}
state*
tgba_product_init::get_init_state() const
twa_product_init::get_init_state() const
{
fixed_size_pool* p = const_cast<fixed_size_pool*>(&pool_);
return new(p->allocate()) state_product(left_init_->clone(),

24
src/tgba/tgbaproduct.hh
View file

@ -29,7 +29,7 @@ namespace spot
{
/// \ingroup tgba_on_the_fly_algorithms
/// \brief A state for spot::tgba_product.
/// \brief A state for spot::twa_product.
///
/// This state is in fact a pair of state: the state from the left
/// automaton and that of the right.
@ -77,16 +77,16 @@ namespace spot
/// \brief A lazy product. (States are computed on the fly.)
class SPOT_API tgba_product: public twa
class SPOT_API twa_product: public twa
{
public:
/// \brief Constructor.
/// \param left The left automata in the product.
/// \param right The right automata in the product.
/// Do not be fooled by these arguments: a product is commutative.
tgba_product(const const_tgba_ptr& left, const const_tgba_ptr& right);
twa_product(const const_tgba_ptr& left, const const_tgba_ptr& right);
virtual ~tgba_product();
virtual ~twa_product();
virtual state* get_init_state() const;
@ -114,15 +114,15 @@ namespace spot
private:
// Disallow copy.
tgba_product(const tgba_product&) SPOT_DELETED;
tgba_product& operator=(const tgba_product&) SPOT_DELETED;
twa_product(const twa_product&) SPOT_DELETED;
twa_product& operator=(const twa_product&) SPOT_DELETED;
};
/// \brief A lazy product with different initial states.
class SPOT_API tgba_product_init final: public tgba_product
class SPOT_API twa_product_init final: public twa_product
{
public:
tgba_product_init(const const_tgba_ptr& left, const const_tgba_ptr& right,
twa_product_init(const const_tgba_ptr& left, const const_tgba_ptr& right,
const state* left_init, const state* right_init);
virtual state* get_init_state() const;
protected:
@ -131,19 +131,19 @@ namespace spot
};
/// \brief on-the-fly TGBA product
inline tgba_product_ptr otf_product(const const_tgba_ptr& left,
inline twa_product_ptr otf_product(const const_tgba_ptr& left,
const const_tgba_ptr& right)
{
return std::make_shared<tgba_product>(left, right);
return std::make_shared<twa_product>(left, right);
}
/// \brief on-the-fly TGBA product with forced initial states
inline tgba_product_ptr otf_product_at(const const_tgba_ptr& left,
inline twa_product_ptr otf_product_at(const const_tgba_ptr& left,
const const_tgba_ptr& right,
const state* left_init,
const state* right_init)
{
return std::make_shared<tgba_product_init>(left, right,
return std::make_shared<twa_product_init>(left, right,
left_init, right_init);
}
}

4
wrap/python/spot_impl.i
View file

@ -50,8 +50,8 @@
%shared_ptr(spot::bdd_dict)
%shared_ptr(spot::twa)
%shared_ptr(spot::twa_graph)
%shared_ptr(spot::tgba_product)
%shared_ptr(spot::tgba_product_init)
%shared_ptr(spot::twa_product)
%shared_ptr(spot::twa_product_init)
%shared_ptr(spot::taa_tgba)
%shared_ptr(spot::taa_tgba_string)
%shared_ptr(spot::taa_tgba_formula)