Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

Coptional< T >	Simplified implementation of std::optional just enough to be used as a replacement for our purposes and when compiling with pre C++17
Cvector
Cd_path_vec	The array containing the furthest D-path end-points, for each value of K. MAX_D is the maximum value of the D-Path. That is, M+N if M is the size of the first input string, and N is the size of the second
Ccanvas
Carray_diff::priv
Cbase_diff::priv
Cbase_diff_comp	A comparison function for instances of base_diff
Cbase_spec_comp	A functor to compare instances of base_spec
Cchanged_enumerator_comp	A functor to compare two changed enumerators, based on their initial value
Cclass_diff::priv	The type of the private data (pimpl sub-object) of the class_diff type
Cclass_or_union_diff::priv	The type of private data of class_or_union_diff
Ccorpus_diff	An abstraction of a diff between between two abi corpus
Ccorpus_diff::diff_stats	This is a document class that aims to capture statistics about the changes carried by a corpus_diff type
Ccorpus_diff::diff_stats::priv	The type of the private data of corpus_diff::diff_stats
Ccorpus_diff::priv
Cdata_member_comp	A comparison functor to compare two data members based on their offset
Cdata_member_diff_comp	A comparison functor to compare two instances of var_diff that represent changed data members based on the offset of the initial data members, or if equal, based on their qualified name. If equal again, then the offset and qualified name of the new data members are considered
Cdecl_diff_base::priv
Cdeletion	The abstraction of the deletion of one element of a sequence A
Cpriv	Private data for the diff type. The details of generic view of the diff node are expressed here
Cdiff_comp	A comparison functor for instances of diff
Cdiff_context	The context of the diff. This type holds various bits of information that is going to be used throughout the diffing of two entities and the reporting that follows
Cdiff_context::priv	The private member (pimpl) for diff_context
Cdiff_equal	A comparison functor for using diff_sptr and diff* in a hash map or set
Cdiff_hash	A hashing functor for using diff_sptr and diff* in a hash map or set
Cdiff_less_than_functor	A functor to compare two instances of diff_sptr
Cdiff_maps	This type contains maps. Each map associates a type name to a diff of that type. Not all kinds of diffs are present; only those that carry leaf changes are, for now
Cdiff_sptr_hasher	Hasher for diff_sptr
Cdistinct_diff::priv	The private data structure for distinct_diff
Cedit_script	The abstraction of an edit script for transforming a sequence A into a sequence B
Celf_symbol_comp	A functor to compare instances of elf_symbol base on their names
Cenum_diff::priv
Cenumerator_value_comp	A functor to compare two enumerators based on their value. This implements the "less than" operator
Cfn_parm_diff::priv
Cfn_parm_diff_comp	A comparison functor to compare two instances of fn_parm_diff based on their indexes
Cfunction_comp	"Less than" functor to compare instances of function_decl
Cfunction_decl_diff::priv
Cfunction_decl_diff_comp	A "Less Than" functor to compare instance of function_decl_diff
Cfunction_type_diff::priv
Cinsertion	The abstration of an insertion of elements of a sequence B into a sequence A. This is used to represent the edit script for transforming a sequence A into a sequence B
Cnoop_deleter	A deleter for shared pointers that ... doesn't delete the object managed by the shared pointer
Cparm_comp	Functor that compares two function parameters for the purpose of sorting them
Cpointer_diff::priv	The internal type for the impl idiom implementation of pointer_diff
Cptr_to_mbr_diff::priv	The private data of the ptr_to_mbr_diff type
Cqualified_type_diff::priv
Creference_diff::priv
Creporter_base	The base class of all the reporting classes
Cdefault_reporter	The default, initial, reporter of the libabigail comparison engine
Cleaf_reporter	A reporter that only reports leaf changes
Cscope_diff::priv
Csubrange_diff::priv	The internal type for the impl idiom implementation of subrange_diff
Ctranslation_unit_diff::priv
Ctype_diff_base::priv
Ctypedef_diff::priv
Ctypes_or_decls_equal	An equality functor for types_or_decls_type
Ctypes_or_decls_hash	A hashing functor for types_or_decls_type
Cvar_comp	A functor to compare instances of var_decl base on their qualified names
Cvar_diff::priv	The internal type for the impl idiom implementation of var_diff
Cvar_diff_sptr_comp	Functor to sort instances of var_diff_sptr
Cvector
Cd_path_vec	The array containing the furthest D-path end-points, for each value of K. MAX_D is the maximum value of the D-Path. That is, M+N if M is the size of the first input string, and N is the size of the second
Cvirtual_member_function_diff_comp	A comparison functor for instances of function_decl_diff that represent changes between two virtual member functions
Cconfig	This type abstracts the configuration information of the library
Cdeep_ptr_eq_functor	An equality functor to deeply compare pointers
Cdefault_eq_functor	The default equality functor used by the core diffing algorithms
Cdeletion	The abstraction of the deletion of one element of a sequence A
Cedit_script	The abstraction of an edit script for transforming a sequence A into a sequence B
Cinsertion	The abstration of an insertion of elements of a sequence B into a sequence A. This is used to represent the edit script for transforming a sequence A into a sequence B
Cpoint	A class representing a vertex in an edit graph, as explained in the paper. A vertex is a basically a pair of coordinates (abscissa and ordinate)
Csnake	The abstraction of the Snake concept, from the paper
Cvector
Cd_path_vec	The array containing the furthest D-path end-points, for each value of K. MAX_D is the maximum value of the D-Path. That is, M+N if M is the size of the first input string, and N is the size of the second
Cdot
Coptional< T >	Simplified implementation of std::optional just enough to be used as a replacement for our purposes and when compiling with pre C++17
Cdwfl_deleter	A functor used by dwfl_sptr
Cfe_iface	The base class of all libabigail front-ends: The Front End Interface
Creader	This is the interface an ELF reader
Celf_based_reader	The common interface of readers based on ELF
Cfe_iface::options_type	The generic options that control the behaviour of all Front-End interfaces
Cfunction_decl::ptr_equal	Equality functor for instances of function_decl
Chash_interned_string	A functor to hash instances of interned_string
Cconfig	The abstraction of the structured content of an .ini file. This roughly follows what is explained at http://en.wikipedia.org/wiki/INI_file
Cconfig::section	The abstraction of one section of the .ini config
Cfunction_call_expr	The abstraction of a function call expression
Cproperty	The base class of the different kinds of properties of an INI file
Clist_property	A class representing a list property
Csimple_property	A simple property. That is, one which value is a string_property_value
Ctuple_property	Abstraction of a tuple property. A tuple property is a property which value is a tuple_property_value
Cproperty_value	Base class of propertie values
Clist_property_value	Abstracts the value of a property representing a list of strings
Cstring_property_value	A property value which is a string
Ctuple_property_value	A property value that is a tuple
Cvector
Cd_path_vec	The array containing the furthest D-path end-points, for each value of K. MAX_D is the maximum value of the D-Path. That is, M+N if M is the size of the first input string, and N is the size of the second
Cinterned_string	The abstraction of an interned string
Cinterned_string_pool	The interned string pool
Carray_type_def::hash	Hash functor for instances of hash
Carray_type_def::subrange_type::bound_value	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 allows users to access the value as signed or unsigned as they see fit
Carray_type_def::subrange_type::hash	Hash functor for instances of subrange_type
Ccanonical_type_hash	Functor to hash a canonical type by using its pointer value
Cclass_decl::base_spec::hash	The hashing functor for class_decl::base_spec
Cclass_decl::hash	Hasher for the class_decl type
Cclass_or_union::hash	Hasher for the class_or_union type
Cclass_or_union::priv
Ccontext_rel	The abstraction of the relationship between an entity and its containing scope (its context). That relationship can carry properties like access rights (if the parent is a class_decl), etc
Cdm_context_rel	The abstraction for a data member context relationship. This relates a data member to its parent class
Cmem_fn_context_rel	Abstraction of a member function context relationship. This relates a member function to its parent class
Ccorpus	This is the abstraction of a set of translation units (themselves seen as bundles of unitary abi artefacts like types and decls) bundled together as a corpus. A corpus is thus the Application binary interface of a program, a library or just a set of modules put together
Ccorpus_group	Abstraction of a group of corpora
Ccorpus::exported_decls_builder	Abstracts the building of the set of exported variables and functions
Ccorpus::exported_decls_builder::priv	The type of the private data of exported_decls_builder type
Ccorpus::priv	The private data of the corpus type
Cdecl_base::hash
Cdecl_topo_comp	A functor to sort decls somewhat topologically. That is, types are sorted in a way that makes the ones that are defined "first" to come first
Celf_symbol	Abstraction of an elf symbol
Celf_symbol::version	The abstraction of the version of an ELF symbol
Cenum_type_decl::enumerator	The abstraction of an enumerator
Cenum_type_decl::hash	Hash functor for instances of enum_type_decl
Cenvironment	This is an abstraction of the set of resources necessary to manage several aspects of the internal representations of the Abigail library
Cenvironment::priv	The private data of the environment type
Cfunction_decl::ptr_equal	Equality functor for instances of function_decl
Cfunction_type::hash	The hashing functor for function_type
Cfunction_type::priv	The type of the private data of the function_type type
Clocation	The source location of a token
Clocation_manager	The entry point to manage locations
Cmember_base	The base class for member types, data members and member functions. Its purpose is mainly to carry the access specifier (and possibly other properties that might be shared by all class members) for the member
Cclass_decl::base_spec	Abstraction of a base specifier in a class declaration
Cmember_class_template	Abstracts a member class template template
Cmember_function_template	Abstract a member function template
Cmember_base::hash	The hashing functor for member_base
Cmethod_type::hash	Hashing functor for the method_type type
Cnode_visitor_base	The base class for the visitor type hierarchy used for traversing a hierarchy of nodes
Cdiff_node_visitor	The base class for the node visitors. These are the types used to visit each node traversed by the diff_traversable_base::traverse() method
Cfilter_base	The base class for the diff tree node filter
Charmless_filter	A filter that walks the diff nodes tree and tags relevant diff nodes into categories considered to represent harmless changes
Charmless_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
Cir_node_visitor	The base class for the visitor type hierarchy used for traversing a translation unit
Coptional< T >	Simplified implementation of std::optional just enough to be used as a replacement for our purposes and when compiling with pre C++17
Cpointer_type_def::hash	Hash functor for instances of pointer_type_def
Cptr_to_mbr_type::hash	Hash functor for instances of ptr_to_mbr_type
Cqualified_type_def::hash	Hash functor for instances of qualified_type_def
Creal_type	The internal representation of an integral type
Creference_type_def::hash	Hash functor for instances of reference_type_def
Cshared_translation_unit_comp	A comparison functor to compare translation units based on their absolute paths
Csort_for_hash_functor	Functor used to sort types before hashing them
Ctemplate_parameter	Base class for a template parameter. Client code should use the more specialized type_template_parameter, non_type_template_parameter and template_template_parameter below
Cnon_type_tparameter	Abstracts non type template parameters
Ctype_composition	This abstracts a composition of types based on template type parameters. The result of the composition is a type that can be referred to by a template non-type parameter. Instances of this type can appear at the same level as template parameters, in the scope of a template_decl
Ctype_tparameter	Abstracts a type template parameter
Ctemplate_tparameter	Abstracts a template template parameter
Ctranslation_unit::priv	Private type to hold private members of translation_unit
Ctraversable_base	The interface for types which are feeling social and want to be visited during the traversal of a hierarchy of nodes
Cdiff_traversable_base	The base class for the diff classes that are to be traversed
Cdiff	The abstraction of a change between two ABI artifacts, a.k.a an artifact change
Cbase_diff	An abstraction of a diff between two instances of class_decl::base_spec
Cdecl_diff_base	The base class of diff between decls
Cfn_parm_diff	Abstraction of a diff between two function parameters
Cfunction_decl_diff	Abstraction of a diff between two function_decl
Cvar_diff	Abstracts a diff between two instances of var_decl
Cdistinct_diff	An abstraction of a diff between entities that are of a different kind (disctinct)
Cscope_diff	An abstractions of the changes between two scopes
Ctranslation_unit_diff	An abstraction of a diff between two translation units
Ctype_diff_base	The base class of diff between types
Carray_diff	The abstraction of a diff between two arrays
Cclass_or_union_diff	This is the base class of class_diff and union_diff
Cclass_diff	This type abstracts changes for a class_decl
Cunion_diff
Cenum_diff	Abstraction of a diff between two enums
Cfunction_type_diff	Abstraction of a diff between two function types
Cpointer_diff	The abstraction of a diff between two pointers
Cptr_to_mbr_diff	The abstraction of a diff between two ptr_to_mbr_type
Cqualified_type_diff	Abstraction of a diff between two qualified types
Creference_diff	The abstraction of a diff between two references
Csubrange_diff	The abstraction of the diff between two subrange types
Ctype_decl_diff	Abstraction of a diff between two basic type declarations
Ctypedef_diff	Abstraction of a diff between two typedef_decl
Cir_traversable_base	The base of an entity of the intermediate representation that is to be traversed
Ctype_or_decl_base	The base class of both types and declarations
Cdecl_base	The base type of all declarations
Carray_type_def	The abstraction of an array type
Carray_type_def::subrange_type	Abstraction for an array range type, like in Ada, or just for an array dimension like in C or C++
Cclass_decl::base_spec	Abstraction of a base specifier in a class declaration
Cenum_type_decl	Abstracts a declaration for an enum type
Cfunction_decl	Abstraction for a function declaration
Cmethod_decl	Abstraction of the declaration of a method
Cfunction_decl::parameter	Abstraction of a function parameter
Cmember_class_template	Abstracts a member class template template
Cmember_function_template	Abstract a member function template
Cnon_type_tparameter	Abstracts non type template parameters
Cpointer_type_def	The abstraction of a pointer type
Cptr_to_mbr_type	The abstraction of a pointer-to-member type
Cqualified_type_def	The abstraction of a qualified type
Creference_type_def	Abstracts a reference type
Cscope_decl	A declaration that introduces a scope
Cclass_tdecl	Abstract a class template
Cfunction_tdecl	Abstract a function template declaration
Cglobal_scope	This abstracts the global scope of a given translation unit
Cnamespace_decl	The abstraction of a namespace declaration
Cscope_type_decl	A type that introduces a scope
Cclass_or_union	The base type of class_decl and union_decl
Cclass_decl	Abstracts a class declaration
Cunion_decl	Abstracts a union type declaration
Ctemplate_decl	The base class of templates
Cclass_tdecl	Abstract a class template
Cfunction_tdecl	Abstract a function template declaration
Ctemplate_tparameter	Abstracts a template template parameter
Ctype_composition	This abstracts a composition of types based on template type parameters. The result of the composition is a type that can be referred to by a template non-type parameter. Instances of this type can appear at the same level as template parameters, in the scope of a template_decl
Ctype_decl	A basic type declaration that introduces no scope
Ctype_tparameter	Abstracts a type template parameter
Ctypedef_decl	The abstraction of a typedef declaration
Cvar_decl	Abstracts a variable declaration
Ctype_base	An abstraction helper for type declarations
Carray_type_def	The abstraction of an array type
Carray_type_def::subrange_type	Abstraction for an array range type, like in Ada, or just for an array dimension like in C or C++
Cenum_type_decl	Abstracts a declaration for an enum type
Cfunction_type	Abstraction of a function type
Cmethod_type	Abstracts the type of a class member function
Cpointer_type_def	The abstraction of a pointer type
Cptr_to_mbr_type	The abstraction of a pointer-to-member type
Cqualified_type_def	The abstraction of a qualified type
Creference_type_def	Abstracts a reference type
Cscope_type_decl	A type that introduces a scope
Ctype_decl	A basic type declaration that introduces no scope
Ctypedef_decl	The abstraction of a typedef declaration
Ctranslation_unit	This is the abstraction of the set of relevant artefacts (types, variable declarations, functions, templates, etc) bundled together into a translation unit
Ctype_base::hash	Hash functor for instances of type_base
Ctype_base::priv	Definition of the private data of type_base
Ctype_decl::hash	Hash functor for instances of type_decl
Ctype_maps	This is a type that aggregates maps of all the kinds of types that are supported by libabigail
Ctype_or_decl_base::priv	The private data of type_or_decl_base
Ctype_or_decl_base_comp	A comparison functor to compare pointer to instances of type_or_decl_base
Ctype_or_decl_equal	The comparison functor for using instances of type_or_decl_base as values in a hash map or set
Ctype_or_decl_hash	The hashing functor for using instances of type_or_decl_base as values in a hash map or set
Ctype_ptr_equal	A predicate for deep equality of instances of type_base*
Ctype_shared_ptr_equal	A predicate for deep equality of instances of shared_ptr<type_base>
Ctype_topo_comp	A functor to sort types somewhat topologically. That is, types are sorted in a way that makes the ones that are defined "first" to come first
Ctypedef_decl::hash	Hash functor for instances of typedef_decl
Cuint64_t_pair_hash	The hashing functor for a pair of uint64_t
Cunion_decl::hash	Hash functor for instances of union_decl type
Cvar_decl::ptr_equal	A comparison functor for pointers to var_decl
Cvector
Cd_path_vec	The array containing the furthest D-path end-points, for each value of K. MAX_D is the maximum value of the D-Path. That is, M+N if M is the size of the first input string, and N is the size of the second
Cnode_base	Base class for graph nodes
Cchild_node
Cparent_node
Cnoop_deleter	A deleter for shared pointers that ... doesn't delete the object managed by the shared pointer
Cescape	A class to hold a reference to a string to regex escape
Cregex_t_deleter	A delete functor for a shared_ptr of regex_t
Crow
Cnoop_deleter	A deleter for shared pointers that ... doesn't delete the object managed by the shared pointer
Cstyle	Datum consolidating style preferences
Cfunction_suppression::parameter_spec	Abstraction of the specification of a function parameter in a function suppression specification
Cfunction_suppression::parameter_spec::priv
Cfunction_suppression::priv	The type of the private data of the function_suppression type
Cnegated_suppression_base	The base class of suppression specifications that are defined by the negation of matching clauses
Cnegated_type_suppression	Abstraction of a negated type suppression specification
Csuppression_base	Base type of a direct suppression specifications types
Cfile_suppression	Abstraction of a suppression specification to avoid loading a file
Cfunction_suppression	Abstraction of a function suppression specification
Ctype_suppression	Abstraction of a type suppression specification
Cnegated_type_suppression	Abstraction of a negated type suppression specification
Cvariable_suppression	The abstraction of a variable suppression specification
Csuppression_base::priv	The private data of suppression_base
Ctype_suppression::insertion_range	The abstraction of a range of offsets in which a member of a type might get inserted
Ctype_suppression::insertion_range::boundary	The abstraction of the boundary of an insertion_range, in the context of a type_suppression
Ctype_suppression::insertion_range::fn_call_expr_boundary	An insertion_range boundary that is expressed as function call expression. The (integer) value of that expression is usually a bit offset
Ctype_suppression::insertion_range::integer_boundary	An insertion_range boundary that is expressed as an integer value. That integer value is usually a bit offset
Ctype_suppression::insertion_range::named_boundary	An insertion_range boundary that is expressed as a named constant that is to be evaluated later in the context of a given type and resolved to a bit offset
Ctype_suppression::priv	The private data for type_suppression
Cvariable_suppression::priv	The type of the private data of the variable_suppression type
Cvector
Cd_path_vec	The array containing the furthest D-path end-points, for each value of K. MAX_D is the maximum value of the D-Path. That is, M+N if M is the size of the first input string, and N is the size of the second
Csvg
Cfiltered_symtab	Helper class to allow range-for loops on symtabs for C++11 and later code. It serves as a proxy for the symtab iterator and provides a begin() method without arguments, as required for range-for loops (and possibly other iterator based transformations)
Csymtab	Symtab is the actual data container of the symtab_reader implementation
Csymtab_filter	The symtab filter is the object passed to the symtab object in order to iterate over the symbols in the symtab while applying filters
CInOutSpec	This is an aggregate that specifies where a test shall get its input from, and where it shall write its output to
Coptions	An abstraction for valid test options
Ctemp_file	A temporary file
Ctimer	A type used to time various part of the libabigail system
Ctypography
Cvector
Cd_path_vec	The array containing the furthest D-path end-points, for each value of K. MAX_D is the maximum value of the D-Path. That is, M+N if M is the size of the first input string, and N is the size of the second
Cqueue	This represents a queue of tasks to be performed
Cqueue::task_done_notify	This functor is to notify listeners that a given task scheduled for execution has been fully executed
Ctask	This represents a task to be performed
Ctest_task	The task that performs the tests
CcharDeleter	This functor is used to instantiate a shared_ptr for xmlChar
CtextReaderDeleter	This functor is used to instantiate a shared_ptr for the xmlTextReader
Cbase_iterator
Csymtab_iterator	An iterator to walk a vector of elf_symbols filtered by symtab_filter
Cstreambuf
Cxz_decompressor_type	This is a custom std::streambuf that knows how to decompress an input stream that was compressed using xz
Cvector
Cd_path_vec	The array containing the furthest D-path end-points, for each value of K. MAX_D is the maximum value of the D-Path. That is, M+N if M is the size of the first input string, and N is the size of the second
Celf_symbols
Cstring_elf_symbols_map_type
Cuint32_t