RepoMirrors/libabigail
1
0
Fork 0
mirror of git://sourceware.org/git/libabigail.git synced 2024-12-14 14:04:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Consistently use std::unique_ptr for private implementations (pimpl)

Browse Source 
In the absence of non-refcounting smart pointers before C++11,
std::shared_ptr was commonly used instead. Having bumped the standard to
C++11, allows us to use std::unique_ptr consistently avoiding any costs
involved with shared_ptr ref counting. Hence do that and add default
virtual destructors where required.

	* include/abg-comparison.h (diff_maps): use unique_ptr for priv_
	(diff_context): Likewise.
	(diff_traversable_base): Likewise.
	(type_diff_base): Likewise.
	(decl_diff_base): Likewise.
	(distinct_diff): Likewise.
	(var_diff): Likewise.
	(pointer_diff): Likewise.
	(reference_diff): Likewise.
	(array_diff): Likewise.
	(qualified_type_diff): Likewise.
	(enum_diff): Likewise.
	(class_or_union_diff): Likewise.
	(class_diff): Likewise.
	(base_diff): Likewise.
	(scope_diff): Likewise.
	(fn_parm_diff): Likewise.
	(function_type_diff): Likewise.
	(function_decl_diff): Likewise.
	(typedef_diff): Likewise.
	(translation_unit_diff): Likewise.
	(diff_stats): Likewise.
	(diff_node_visitor): Likewise.
	* include/abg-corpus.h (corpus): Likewise.
	(exported_decls_builder): Likewise.
	(corpus_group): Likewise.
	* include/abg-ini.h (property): Likewise.
	(property_value): Likewise.
	(string_property_value): Likewise.
	(list_property_value): Likewise.
	(tuple_property_value): Likewise.
	(simple_property): Likewise.
	(list_property): Likewise.
	(tuple_property): Likewise.
	(config): Likewise.
	(section): Likewise.
	(function_call_expr): Likewise.
	* include/abg-interned-str.h (interned_string_pool): Likewise.
	* include/abg-ir.h (environment): Likewise.
	(location_manager): Likewise.
	(type_maps): Likewise.
	(translation_unit): Likewise.
	(elf_symbol::version): Likewise.
	(type_or_decl_base): Likewise.
	(scope_decl): Likewise.
	(qualified_type_def): Likewise.
	(pointer_type_def): Likewise.
	(array_type_def): Likewise.
	(subrange_type): Likewise.
	(enum_type_decl): Likewise.
	(enum_type_decl::enumerator): Likewise.
	(typedef_decl): Likewise.
	(dm_context_rel): Likewise.
	(var_decl): Likewise.
	(function_decl::parameter): Likewise.
	(function_type): Likewise.
	(method_type): Likewise.
	(template_decl): Likewise.
	(template_parameter): Likewise.
	(type_tparameter): Likewise.
	(non_type_tparameter): Likewise.
	(template_tparameter): Likewise.
	(type_composition): Likewise.
	(function_tdecl): Likewise.
	(class_tdecl): Likewise.
	(class_decl::base_spec): Likewise.
	(ir_node_visitor): Likewise.
	* include/abg-suppression.h (suppression_base): Likewise.
	(type_suppression::insertion_range): Likewise.
	(type_suppression::insertion_range::boundary): Likewise.
	(type_suppression::insertion_range::integer_boundary): Likewise.
	(type_suppression::insertion_range::fn_call_expr_boundary): Likewise.
	(function_suppression): Likewise.
	(function_suppression::parameter_spec): Likewise.
	(file_suppression): Likewise.
	* include/abg-tools-utils.h (temp_file): Likewise.
	(timer): Likewise.
	* include/abg-traverse.h (traversable_base): Likewise.
	* include/abg-workers.h (queue): Likewise.
	* src/abg-comparison.cc (diff_context): add default destructor.
	(diff_maps): Likewise.
	(corpus_diff): Likewise.
	(diff_node_visitor): Likewise.
	(class_or_union_diff::get_priv): adjust return type.
	(class_diff::get_priv): adjust return type.
	* src/abg-corpus.cc (corpus): add default destructor.
	* src/abg-ir.cc (location_manager): Likewise.
	(type_maps): Likewise.
	(elf_symbol::version): Likewise.
	(array_type_def::subrange_type): Likewise.
	(enum_type_decl::enumerator): Likewise.
	(function_decl::parameter): Likewise.
	(class_decl::base_spec): Likewise.
	(ir_node_visitor): Likewise.

Signed-off-by: Matthias Maennich <maennich@google.com>
This commit is contained in:
Matthias Maennich 2021-07-05 10:45:29 +01:00 committed by Dodji Seketeli
parent 578ba12139
commit 86c06ad684
12 changed files with 164 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
include/abg-comparison.h
View File

@ -10,6 +10,7 @@
/// @file
#include <memory>
#include <ostream>
#include <unordered_map>
#include <unordered_set>
@ -502,13 +503,14 @@ class corpus_diff;
class diff_maps
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
diff_maps();
~diff_maps();
const string_diff_ptr_map&
get_type_decl_diff_map() const;
@ -598,7 +600,7 @@ typedef shared_ptr<corpus_diff> corpus_diff_sptr;
class diff_context
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
diff_sptr
has_diff_for(const type_or_decl_base_sptr first,
@ -638,6 +640,8 @@ class diff_context
public:
diff_context();
~diff_context();
void
set_corpus_diff(const corpus_diff_sptr&);
@ -895,14 +899,12 @@ class diff : public diff_traversable_base
{
friend class diff_context;
struct priv;
typedef shared_ptr<priv> priv_sptr;
// Forbidden
diff();
protected:
priv_sptr priv_;
struct priv;
std::unique_ptr<priv> priv_;
diff(type_or_decl_base_sptr first_subject,
type_or_decl_base_sptr second_subject);
@ -1063,9 +1065,7 @@ compute_diff(const type_base_sptr,
class type_diff_base : public diff
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
type_diff_base();
@ -1086,9 +1086,7 @@ public:
class decl_diff_base : public diff
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
protected:
decl_diff_base(decl_base_sptr first_subject,
@ -1116,8 +1114,7 @@ typedef shared_ptr<distinct_diff> distinct_diff_sptr;
class distinct_diff : public diff
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
protected:
distinct_diff(type_or_decl_base_sptr first,
@ -1172,8 +1169,7 @@ compute_diff_for_distinct_kinds(const type_or_decl_base_sptr,
class var_diff : public decl_diff_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
protected:
var_diff(var_decl_sptr first,
@ -1227,7 +1223,7 @@ typedef shared_ptr<pointer_diff> pointer_diff_sptr;
class pointer_diff : public type_diff_base
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
protected:
pointer_diff(pointer_type_def_sptr first,
@ -1287,7 +1283,7 @@ typedef shared_ptr<reference_diff> reference_diff_sptr;
class reference_diff : public type_diff_base
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
protected:
reference_diff(const reference_type_def_sptr first,
@ -1347,7 +1343,7 @@ typedef shared_ptr<array_diff> array_diff_sptr;
class array_diff : public type_diff_base
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
protected:
array_diff(const array_type_def_sptr first,
@ -1404,8 +1400,7 @@ typedef class shared_ptr<qualified_type_diff> qualified_type_diff_sptr;
class qualified_type_diff : public type_diff_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
protected:
qualified_type_diff(qualified_type_def_sptr first,
@ -1465,8 +1460,7 @@ typedef shared_ptr<enum_diff> enum_diff_sptr;
class enum_diff : public type_diff_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
void
clear_lookup_tables();
@ -1536,8 +1530,8 @@ class class_or_union_diff : public type_diff_base
{
protected:
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
typedef std::unique_ptr<priv> priv_ptr;
priv_ptr priv_;
void
clear_lookup_tables(void);
@ -1561,7 +1555,7 @@ protected:
public:
const class_or_union_diff::priv_sptr&
const class_or_union_diff::priv_ptr&
get_priv() const;
//TODO: add change of the name of the type.
@ -1656,10 +1650,10 @@ public:
class class_diff : public class_or_union_diff
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
typedef std::unique_ptr<priv> priv_ptr;
priv_ptr priv_;
const priv_sptr& get_priv()const;
const priv_ptr& get_priv()const;
void
clear_lookup_tables(void);
@ -1791,7 +1785,7 @@ compute_diff(const union_decl_sptr first,
class base_diff : public diff
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
protected:
base_diff(class_decl::base_spec_sptr first,
@ -1850,7 +1844,7 @@ typedef shared_ptr<scope_diff> scope_diff_sptr;
class scope_diff : public diff
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
bool
lookup_tables_empty() const;
@ -1958,9 +1952,7 @@ compute_diff(const scope_decl_sptr first_scope,
class fn_parm_diff : public decl_diff_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
virtual void
finish_diff_type();
@ -2015,8 +2007,7 @@ typedef shared_ptr<function_type_diff> function_type_diff_sptr;
class function_type_diff: public type_diff_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
void
ensure_lookup_tables_populated();
@ -2093,7 +2084,7 @@ compute_diff(const function_type_sptr first,
class function_decl_diff : public decl_diff_base
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
void
ensure_lookup_tables_populated();
@ -2201,7 +2192,7 @@ typedef shared_ptr<typedef_diff> typedef_diff_sptr;
class typedef_diff : public type_diff_base
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
typedef_diff();
@ -2266,8 +2257,7 @@ typedef shared_ptr<translation_unit_diff> translation_unit_diff_sptr;
class translation_unit_diff : public scope_diff
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
protected:
translation_unit_diff(translation_unit_sptr first,
@ -2306,8 +2296,7 @@ compute_diff(const translation_unit_sptr first,
class corpus_diff
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
protected:
corpus_diff(corpus_sptr first,
@ -2321,7 +2310,7 @@ public:
class diff_stats;
virtual ~corpus_diff() {}
virtual ~corpus_diff();
/// A convenience typedef for a shared pointer to @ref diff_stats
typedef shared_ptr<diff_stats> diff_stats_sptr;
@ -2479,9 +2468,7 @@ compute_diff(const corpus_group_sptr&,
class corpus_diff::diff_stats
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
diff_stats();
@ -2628,14 +2615,13 @@ class diff_node_visitor : public node_visitor_base
{
protected:
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
diff_node_visitor();
virtual ~diff_node_visitor() {}
virtual ~diff_node_visitor();
diff_node_visitor(visiting_kind k);

24
include/abg-corpus.h
View File

@ -24,10 +24,6 @@ namespace ir
class corpus
{
public:
struct priv;
/// Convenience typedef for shared_ptr of corpus::priv
typedef shared_ptr<priv> priv_sptr;
/// A convenience typedef for std::vector<string>.
typedef vector<string> strings_type;
@ -60,11 +56,12 @@ private:
void init_format_version();
public:
shared_ptr<priv> priv_;
struct priv;
std::unique_ptr<priv> priv_;
corpus(ir::environment*, const string& path= "");
virtual ~corpus() {}
virtual ~corpus();
const environment*
get_environment() const;
@ -290,21 +287,14 @@ public:
/// parameters needed.
class corpus::exported_decls_builder
{
public:
class priv;
/// Convenience typedef for shared_ptr<priv>
typedef shared_ptr<priv> priv_sptr;
friend class corpus;
private:
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbid default construction.
exported_decls_builder();
public:
friend class corpus;
exported_decls_builder(functions& fns,
variables& vars,
@ -344,9 +334,7 @@ public:
class corpus_group : public corpus
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbid copy
corpus_group(const corpus_group&);

49
include/abg-ini.h
View File

@ -40,8 +40,7 @@ typedef shared_ptr<property> property_sptr;
class property
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
@ -66,6 +65,9 @@ typedef shared_ptr<property_value> property_value_sptr;
/// Base class of propertie values.
class property_value
{
struct priv;
std::unique_ptr<priv> priv_;
public:
enum value_kind
{
@ -75,13 +77,6 @@ public:
TUPLE_PROPERTY_VALUE = 3,
};
private:
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
public:
property_value();
property_value(value_kind);
@ -105,8 +100,7 @@ typedef shared_ptr<string_property_value> string_property_value_sptr;
class string_property_value : public property_value
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
string_property_value();
@ -147,9 +141,7 @@ typedef shared_ptr<list_property_value> list_property_value_sptr;
class list_property_value : public property_value
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
list_property_value();
@ -184,8 +176,7 @@ typedef shared_ptr<tuple_property_value> tuple_property_value_sptr;
class tuple_property_value : public property_value
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
tuple_property_value(const vector<property_value_sptr>&);
@ -219,9 +210,7 @@ typedef shared_ptr<simple_property> simple_property_sptr;
class simple_property : public property
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
simple_property();
@ -265,9 +254,7 @@ typedef shared_ptr<list_property> list_property_sptr;
class list_property : public property
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
list_property();
@ -299,9 +286,7 @@ typedef shared_ptr<tuple_property> tuple_property_sptr;
class tuple_property : public property
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
tuple_property();
@ -336,7 +321,7 @@ typedef shared_ptr<config> config_sptr;
class config
{
class priv;
typedef shared_ptr<priv> priv_sptr;
std::unique_ptr<priv> priv_;
public:
class section;
@ -349,11 +334,6 @@ public:
/// A convenience typedef for a vector of @ref property_sptr
typedef vector<property_sptr> properties_type;
private:
priv_sptr priv_;
public:
config();
config(const string& path,
@ -378,9 +358,7 @@ public:
class config::section
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbid this
section();
@ -455,8 +433,7 @@ typedef shared_ptr<function_call_expr> function_call_expr_sptr;
class function_call_expr
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
function_call_expr();

5
include/abg-interned-str.h
View File

@ -27,7 +27,6 @@ namespace abigail
{
// Inject some std types into this namespace.
using std::unordered_set;
using std::shared_ptr;
using std::string;
using std::ostream;
@ -227,9 +226,7 @@ struct hash_interned_string
class interned_string_pool
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:

153
include/abg-ir.h
View File

@ -133,6 +133,9 @@ typedef vector<type_base_sptr> type_base_sptrs_type;
/// that you can de-allocate the environment instance.
class environment
{
struct priv;
std::unique_ptr<priv> priv_;
public:
/// A convenience typedef for a map of canonical types. The key is
@ -141,15 +144,8 @@ public:
/// representation string.
typedef std::unordered_map<string, std::vector<type_base_sptr> >
canonical_types_map_type;
private:
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
public:
environment();
virtual ~environment();
canonical_types_map_type&
@ -401,14 +397,14 @@ public:
class location_manager
{
struct priv;
/// Pimpl.
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
public:
location_manager();
~location_manager();
location
create_new_location(const std::string& fle, size_t lne, size_t col);
@ -541,13 +537,14 @@ istring_type_or_decl_base_sptr_map_type;
class type_maps
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
type_maps();
~type_maps();
bool
empty() const;
@ -627,12 +624,10 @@ public:
class translation_unit : public traversable_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden
translation_unit();
translation_unit() = delete;
public:
/// Convenience typedef for a shared pointer on a @ref global_scope.
@ -908,7 +903,7 @@ public:
private:
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
elf_symbol();
@ -1140,7 +1135,7 @@ compute_aliases_for_elf_symbol(const elf_symbol& symbol,
class elf_symbol::version
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
public:
version();
@ -1150,6 +1145,8 @@ public:
version(const version& v);
~version();
operator const string&() const;
const string&
@ -1312,8 +1309,7 @@ equals(const decl_base&, const decl_base&, change_kind*);
class type_or_decl_base : public ir_traversable_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
mutable priv_sptr priv_;
mutable std::unique_ptr<priv> priv_;
type_or_decl_base();
@ -1767,6 +1763,9 @@ equals(const scope_decl&, const scope_decl&, change_kind*);
/// A declaration that introduces a scope.
class scope_decl : public virtual decl_base
{
struct priv;
std::unique_ptr<priv> priv_;
public:
/// Convenience typedef for a vector of @ref decl_base_sptr.
@ -1775,13 +1774,6 @@ public:
typedef std::vector<function_type_sptr > function_types;
/// Convenience typedef for a vector of @ref scope_decl_sptr.
typedef std::vector<scope_decl_sptr> scopes;
/// The type of the private data of @ref scope_decl.
struct priv;
/// A convenience typedef for a shared pointer to scope_decl::priv.
typedef shared_ptr<priv> priv_sptr;
private:
priv_sptr priv_;
scope_decl();
@ -2153,8 +2145,7 @@ equals(const qualified_type_def&, const qualified_type_def&, change_kind*);
class qualified_type_def : public virtual type_base, public virtual decl_base
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden.
qualified_type_def();
@ -2262,9 +2253,7 @@ equals(const pointer_type_def&, const pointer_type_def&, change_kind*);
class pointer_type_def : public virtual type_base, public virtual decl_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden.
pointer_type_def();
@ -2391,10 +2380,8 @@ equals(const array_type_def&, const array_type_def&, change_kind*);
/// The abstraction of an array type.
class array_type_def : public virtual type_base, public virtual decl_base
{
private:
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden.
array_type_def();
@ -2420,13 +2407,13 @@ public:
class subrange_type : public virtual type_base, public virtual decl_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden.
subrange_type();
public:
virtual ~subrange_type();
/// This class is to hold the value of the bound of a subrange.
/// The value can be either signed or unsigned, at least when it
/// comes from DWARF. The class keeps the sign information, but
@ -2613,6 +2600,12 @@ equals(const enum_type_decl&, const enum_type_decl&, change_kind*);
/// Abstracts a declaration for an enum type.
class enum_type_decl : public virtual type_base, public virtual decl_base
{
class priv;
std::unique_ptr<priv> priv_;
// Forbidden
enum_type_decl();
public:
/// A hasher for an enum_type_decl.
@ -2624,18 +2617,6 @@ public:
/// Convenience typedef for a list of @ref enumerator.
typedef std::vector<enumerator> enumerators;
private:
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
// Forbidden
enum_type_decl();
public:
/// Constructor of an enum type declaration.
///
/// @param name the name of the enum
@ -2702,14 +2683,14 @@ enum_has_non_name_change(const enum_type_decl& l,
class enum_type_decl::enumerator
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
enumerator();
~enumerator();
enumerator(const environment* env, const string& name, int64_t value);
enumerator(const enumerator&);
@ -2755,9 +2736,7 @@ equals(const typedef_decl&, const typedef_decl&, change_kind*);
class typedef_decl : public virtual type_base, public virtual decl_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden
typedef_decl();
@ -2816,9 +2795,7 @@ class dm_context_rel : public context_rel
{
protected:
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
dm_context_rel();
@ -2868,7 +2845,7 @@ equals_modulo_cv_qualifier(const array_type_def*, const array_type_def*);
class var_decl : public virtual decl_base
{
struct priv;
shared_ptr<priv> priv_;
std::unique_ptr<priv> priv_;
// Forbidden
var_decl();
@ -3140,9 +3117,7 @@ struct type_or_decl_base_comp
class function_decl::parameter : public decl_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
@ -3172,6 +3147,8 @@ public:
unsigned index = 0,
bool variadic_marker = false);
virtual ~parameter();
const type_base_sptr
get_type()const;
@ -3243,9 +3220,6 @@ equals(const function_type&, const function_type&, change_kind*);
/// Abstraction of a function type.
class function_type : public virtual type_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
protected:
virtual void on_canonical_type_set();
@ -3259,7 +3233,8 @@ public:
/// Convenience typedef for a vector of @ref parameter_sptr
typedef std::vector<parameter_sptr> parameters;
priv_sptr priv_;
struct priv;
std::unique_ptr<priv> priv_;
private:
function_type();
@ -3342,8 +3317,7 @@ struct function_type::hash
class method_type : public function_type
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
method_type();
@ -3399,8 +3373,7 @@ public:
class template_decl : public virtual decl_base
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
template_decl();
@ -3432,8 +3405,7 @@ public:
class template_parameter
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden
template_parameter();
@ -3479,9 +3451,7 @@ struct template_decl::hash
class type_tparameter : public template_parameter, public virtual type_decl
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden
type_tparameter();
@ -3512,9 +3482,7 @@ public:
class non_type_tparameter : public template_parameter, public virtual decl_base
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
type_base_wptr type_;
@ -3561,8 +3529,7 @@ class template_tparameter;
class template_tparameter : public type_tparameter, public template_decl
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden
template_tparameter();
@ -3597,9 +3564,7 @@ public:
class type_composition : public template_parameter, public virtual decl_base
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
type_composition();
@ -3637,9 +3602,7 @@ struct type_composition::hash
class function_tdecl : public template_decl, public scope_decl
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden
function_tdecl();
@ -3688,9 +3651,7 @@ public:
class class_tdecl : public template_decl, public scope_decl
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden
class_tdecl();
@ -4308,9 +4269,7 @@ class class_decl::base_spec : public member_base,
public virtual decl_base
{
struct priv;
typedef shared_ptr<priv>priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbidden
base_spec();
@ -4326,6 +4285,8 @@ public:
base_spec(const type_base_sptr& base, access_specifier a,
long offset_in_bits = -1, bool is_virtual = false);
virtual ~base_spec();
class_decl_sptr
get_base_class() const;
@ -4825,14 +4786,14 @@ struct class_tdecl::shared_ptr_hash
class ir_node_visitor : public node_visitor_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
ir_node_visitor();
virtual ~ir_node_visitor();
void allow_visiting_already_visited_type_node(bool);
bool allow_visiting_already_visited_type_node() const;
void mark_type_node_as_visited(type_base *);

52
include/abg-suppression.h
View File

@ -38,14 +38,14 @@ using std::unordered_set;
/// it matches the supppression specification.
class suppression_base
{
class priv;
typedef shared_ptr<priv> priv_sptr;
public:
class priv; // declare publicly to allow subclasses to reuse the priv
private:
// Forbid default constructor
suppression_base();
public:
priv_sptr priv_;
std::unique_ptr<priv> priv_;
suppression_base(const string& label);
@ -139,14 +139,12 @@ typedef vector<type_suppression_sptr> type_suppressions_type;
class type_suppression : public suppression_base
{
class priv;
typedef shared_ptr<priv> priv_sptr;
// Forbid this;
type_suppression();
public:
priv_sptr priv_;
std::unique_ptr<priv> priv_;
/// The kind of the type the current type suppression is supposed to
/// be about.
@ -289,6 +287,9 @@ is_type_suppression(const suppression_sptr);
/// might get inserted.
class type_suppression::insertion_range
{
struct priv;
std::unique_ptr<priv> priv_;
public:
class boundary;
@ -305,13 +306,6 @@ public:
/// fn_call_expr_boundary
typedef shared_ptr<fn_call_expr_boundary> fn_call_expr_boundary_sptr;
private:
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
public:
insertion_range();
insertion_range(boundary_sptr begin, boundary_sptr end);
@ -348,9 +342,7 @@ is_fn_call_expr_boundary(type_suppression::insertion_range::boundary_sptr);
class type_suppression::insertion_range::boundary
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
boundary();
@ -363,9 +355,7 @@ class type_suppression::insertion_range::integer_boundary
: public type_suppression::insertion_range::boundary
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
integer_boundary();
@ -383,9 +373,7 @@ class type_suppression::insertion_range::fn_call_expr_boundary
: public type_suppression::insertion_range::boundary
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
fn_call_expr_boundary();
@ -412,11 +400,10 @@ typedef vector<function_suppression_sptr> function_suppressions_type;
class function_suppression : public suppression_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
public:
priv_sptr priv_;
std::unique_ptr<priv> priv_;
class parameter_spec;
/// Convenience typedef for shared_ptr of @ref parameter_spec.
@ -582,12 +569,10 @@ operator|(function_suppression::change_kind l,
/// function suppression specification.
class function_suppression::parameter_spec
{
class priv;
typedef shared_ptr<priv> priv_sptr;
friend class function_suppression;
priv_sptr priv_;
class priv;
std::unique_ptr<priv> priv_;
// Forbid this.
parameter_spec();
@ -657,11 +642,9 @@ public:
private:
struct priv;
typedef shared_ptr<priv> priv_sptr;
public:
priv_sptr priv_;
std::unique_ptr<priv> priv_;
variable_suppression(const string& label = "",
const string& name = "",
@ -791,10 +774,7 @@ typedef shared_ptr<file_suppression> file_suppression_sptr;
/// which file it has to avoid loading.
class file_suppression: public suppression_base
{
class priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
// Forbid this
file_suppression();

8
include/abg-tools-utils.h
View File

@ -135,9 +135,7 @@ typedef shared_ptr<temp_file> temp_file_sptr;
class temp_file
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
temp_file();
@ -249,9 +247,7 @@ abidiff_status_has_incompatible_abi_change(abidiff_status s);
class timer
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
public:
enum kind

4
include/abg-traverse.h
View File

@ -38,9 +38,7 @@ struct node_visitor_base
class traversable_base
{
struct priv;
typedef shared_ptr<priv> priv_sptr;
priv_sptr priv_;
std::unique_ptr<priv> priv_;
protected:

3
include/abg-workers.h
View File

@ -68,13 +68,12 @@ class queue
{
public:
struct priv;
typedef shared_ptr<priv> priv_sptr;
/// A convenience typedef for a vector of @ref task_sptr
typedef std::vector<task_sptr> tasks_type;
private:
priv_sptr p_;
std::unique_ptr<priv> p_;
public:
struct task_done_notify;

14
src/abg-comparison.cc
View File

@ -914,6 +914,8 @@ diff_context::diff_context()
// add_diff_filter(f);
}
diff_context::~diff_context() = default;
/// Set the corpus diff relevant to this context.
///
/// @param d the corpus_diff we are interested in.
@ -4954,7 +4956,7 @@ class_or_union_diff::finish_diff_type()
///
/// @return the (possibly) shared private data of the current instance
/// of @ref class_or_union_diff.
const class_or_union_diff::priv_sptr&
const class_or_union_diff::priv_ptr&
class_or_union_diff::get_priv() const
{
if (priv_)
@ -5310,7 +5312,7 @@ class_diff::ensure_lookup_tables_populated(void) const
get_priv()->sorted_changed_bases_);
{
const class_or_union_diff::priv_sptr &p = class_or_union_diff::get_priv();
const class_or_union_diff::priv_ptr &p = class_or_union_diff::get_priv();
edit_script& e = p->member_fns_changes_;
@ -5531,7 +5533,7 @@ class_diff::~class_diff()
///
/// @return the (possibly) shared private data of the current instance
/// of class_diff.
const class_diff::priv_sptr&
const class_diff::priv_ptr&
class_diff::get_priv() const
{
if (priv_)
@ -7664,6 +7666,8 @@ diff_maps::diff_maps()
: priv_(new diff_maps::priv())
{}
diff_maps::~diff_maps() = default;
/// Getter of the map that contains basic type diffs.
///
/// @return the map that contains basic type diffs.
@ -10402,6 +10406,8 @@ corpus_diff::corpus_diff(corpus_sptr first,
: priv_(new priv(first, second, ctxt))
{}
corpus_diff::~corpus_diff() = default;
/// Finish building the current instance of @ref corpus_diff.
void
corpus_diff::finish_diff_type()
@ -11183,6 +11189,8 @@ diff_node_visitor::diff_node_visitor()
: priv_(new priv)
{}
diff_node_visitor::~diff_node_visitor() = default;
/// Constructor of the @ref diff_node_visitor type.
///
/// @param k how the visiting has to be performed.

2
src/abg-corpus.cc
View File

@ -602,6 +602,8 @@ corpus::corpus(ir::environment* env, const string& path)
init_format_version();
}
corpus::~corpus() = default;
/// Getter of the enviroment of the corpus.
///
/// @return the environment of this corpus.

19
src/abg-ir.cc
View File

@ -360,7 +360,10 @@ struct location_manager::priv
};
location_manager::location_manager()
{priv_ = shared_ptr<location_manager::priv>(new location_manager::priv);}
: priv_(new location_manager::priv)
{}
location_manager::~location_manager() = default;
/// Insert the triplet representing a source locus into our internal
/// vector of location triplet. Return an instance of location type,
@ -434,6 +437,8 @@ type_maps::type_maps()
: priv_(new priv)
{}
type_maps::~type_maps() = default;
/// Test if the type_maps is empty.
///
/// @return true iff the type_maps is empty.
@ -2680,6 +2685,8 @@ elf_symbol::version::version(const elf_symbol::version& v)
{
}
elf_symbol::version::~version() = default;
/// Cast the version_type into a string that is its name.
///
/// @return the name of the version.
@ -15760,6 +15767,7 @@ operator!=(const reference_type_def_sptr& l, const reference_type_def_sptr& r)
// <array_type_def definitions>
// <array_type_def::subrange_type>
array_type_def::subrange_type::~subrange_type() = default;
// <array_type_def::subrante_type::bound_value>
@ -17153,6 +17161,9 @@ enum_type_decl::enumerator::enumerator()
: priv_(new priv)
{}
enum_type_decl::enumerator::~enumerator() = default;
/// Constructor of the @ref enum_type_decl::enumerator type.
///
/// @param env the environment we are operating from.
@ -19594,6 +19605,8 @@ function_decl::parameter::parameter(const type_base_sptr type,
runtime_type_instance(this);
}
function_decl::parameter::~parameter() = default;
const type_base_sptr
function_decl::parameter::get_type()const
{return priv_->type_.lock();}
@ -21846,6 +21859,8 @@ class_decl::base_spec::base_spec(const type_base_sptr& base,
runtime_type_instance(this);
}
class_decl::base_spec::~base_spec() = default;
/// Compares two instances of @ref class_decl::base_spec.
///
/// If the two intances are different, set a bitfield to give some
@ -25113,6 +25128,8 @@ ir_node_visitor::ir_node_visitor()
: priv_(new priv)
{}
ir_node_visitor::~ir_node_visitor() = default;
/// Set if the walker using this visitor is allowed to re-visit a type
/// node that was previously visited or not.
///