abg-comp-filter.h File Reference

This header declares filters for the diff trees resulting from comparing ABI Corpora. More...

#include "abg-comparison.h"

Include dependency graph for abg-comp-filter.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	filter_base
	The base class for the diff tree node filter. More...
class	harmless_filter
	A filter that walks the diff nodes tree and tags relevant diff nodes into categories considered to represent harmless changes. More...
class	harmless_harmful_filter
	A filter that walks the diff nodes tree and tags relevant diff nodes into categories considered to represent potentially harmless or harmful changes. More...

Namespaces
namespace	abigail
	Toplevel namespace for libabigail.
namespace	abigail::comparison
	utilities to compare abi artifacts
namespace	abigail::comparison::filtering
	Facilities to walk, categorize and possibly filter nodes of the diff tree.

Typedefs
typedef shared_ptr< filter_base >	filter_base_sptr
	Convenience typedef for a shared pointer to filter_base.
typedef std::vector< filter_base_sptr >	filters
	Convenience typedef for a vector of filter_base_sptr.
typedef shared_ptr< harmless_harmful_filter >	harmful_harmless_filter_sptr
	A convenience typedef for a shared pointer to harmful_filter.
typedef shared_ptr< harmless_filter >	harmless_filter_sptr
	Convenience typedef for a shared pointer to a harmless_filter.

Functions
void	apply_filter (filter_base &filter, corpus_diff_sptr d)
	Walk the diff sub-trees of a a corpus_diff and apply a filter to the nodes visted. The filter categorizes each node, assigning it into one or several categories.
void	apply_filter (filter_base &filter, diff_sptr d)
	Walk a diff sub-tree and apply a filter to the nodes visted. The filter categorizes each node, assigning it into one or several categories.
void	apply_filter (filter_base_sptr filter, diff_sptr d)
	Walk a diff sub-tree and apply a filter to the nodes visted. The filter categorizes each node, assigning it into one or several categories.
bool	has_anonymous_data_member_change (const diff *d)
	Test if a diff node carries a non-anonymous data member to anonymous data member change, or vice-versa.
bool	has_anonymous_data_member_change (const diff_sptr &d)
	Test if a diff node carries a non-anonymous data member to anonymous data member change, or vice-versa.
bool	has_basic_or_class_type_name_change (const diff *d)
	Test if a diff node carries a basic or class type name change.
bool	has_basic_type_name_change (const diff *d)
	Test if a diff node carries a basic type name change.
bool	has_benign_array_of_unknown_size_change (const diff *dif)
	Test if a diff node carries a benign change to the size of a variable of type array.
bool	has_class_decl_only_def_change (const class_or_union_sptr &first, const class_or_union_sptr &second)
	Test if two class_or_union_sptr are different just by the fact that one is decl-only and the other one is defined.
bool	has_class_decl_only_def_change (const diff *diff)
	Test if a class_or_union_diff carries a change in which the two classes are different by the fact that one is a decl-only and the other one is defined.
bool	has_class_or_union_type_name_change (const diff *d)
	Test if a diff node carries a class or union type name change.
bool	has_data_member_replaced_by_anon_dm (const diff *diff)
	Test if a class_or_union_diff has a data member replaced by an anonymous data member in a harmless way. That means, the new anonymous data member somehow contains the replaced data member and it doesn't break the layout of the containing class.
bool	has_decl_only_def_change (const decl_base_sptr &first, const decl_base_sptr &second)
	Test if two decl_base_sptr are different just by the fact that one is decl-only and the other one is defined.
bool	has_decl_only_def_change (const diff *d)
	Test if a diff carries a change in which the two decls are different by the fact that one is a decl-only and the other one is defined.
bool	has_enum_decl_only_def_change (const diff *diff)
	Test if a enum_diff carries a change in which the two enums are different by the fact that one is a decl-only and the other one is defined.
bool	has_enum_decl_only_def_change (const enum_type_decl_sptr &first, const enum_type_decl_sptr &second)
	Test if two enum_sptr are different just by the fact that one is decl-only and the other one is defined.
bool	has_harmful_name_change (const decl_base_sptr &f, const decl_base_sptr &s)
	Test if two decls represents a harmful name change.
bool	has_harmful_name_change (const diff *dif)
	Test if a diff node represents a harmful name change.
bool	has_harmless_enum_to_int_change (const diff *diff)
	Test if a diff node carries a harmless change of an enum into an integer (or vice-versa).
bool	has_harmless_name_change (const decl_base_sptr &f, const decl_base_sptr &s)
	Test if two decls represents a harmless name change.
bool	has_lvalue_reference_ness_change (const diff *dif)
	Test if a diff node carries a change where an lvalue reference changed into a rvalue reference, or vice versa.
bool	has_strict_fam_conversion (const class_decl_sptr &first, const class_decl_sptr &second)
	Test if a class with a fake flexible data member got changed into a class with a real fexible data member.
bool	has_strict_fam_conversion (const diff *dif)
	Test if a diff node carries a change from class with a fake flexible data member into a class with a real fexible data member.
bool	has_virtual_mem_fn_change (const function_decl_diff *diff)
	Test if the function_decl_diff node has a change involving virtual member functions.
bool	has_void_ptr_to_ptr_change (const diff *dif)
	Test if a diff node carries a void* to pointer type change.
bool	is_decl_only_class_with_size_change (const class_or_union &first, const class_or_union &second)
	Test if two classes that are decl-only (have the decl-only flag and carry no data members) but are different just by their size.
bool	is_decl_only_class_with_size_change (const class_or_union_sptr &first, const class_or_union_sptr &second)
	Test if two classes that are decl-only (have the decl-only flag and carry no data members) but are different just by their size.
bool	is_decl_only_class_with_size_change (const diff *diff)
	Test if a diff node is for two classes that are decl-only (have the decl-only flag and carry no data members) but are different just by their size.
bool	is_mostly_distinct_diff (const diff *d)
	Test if a diff node carries a distinct type change or a pointer/reference/typedef to distinct type change.
bool	is_var_1_dim_unknown_size_array_change (const diff *diff)
	Test if we are looking at a diff that carries a change of variables which types are both one dimension array, with one of them being of unknow size and the two variables having the same symbol size.
bool	is_var_1_dim_unknown_size_array_change (const var_decl_sptr &var1, const var_decl_sptr &var2)
	Test if we are looking at two variables which types are both one dimension array, with one of them being of unknow size and the two variables having the same symbol size.
bool	union_diff_has_harmless_changes (const diff *d)
	Test if a union diff node does have changes that don't impact its size.

Detailed Description

This header declares filters for the diff trees resulting from comparing ABI Corpora.

Definition in file abg-comp-filter.h.