Loading...
Searching...
No Matches
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
| Nabg_compat | |
| Coptional | Simplified implementation of std::optional just enough to be used as a replacement for our purposes and when compiling with pre C++17 |
| Nabigail | Toplevel namespace for libabigail |
| Nabixml | The namespace for the native XML file format reader |
| Cvector | |
| Ncomparison | Utilities to compare abi artifacts |
| Nfiltering | Facilities to walk, categorize and possibly filter nodes of the diff tree |
| 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 |
| Carray_diff | The abstraction of a diff between two arrays |
| Cpriv | |
| Cbase_diff | An abstraction of a diff between two instances of class_decl::base_spec |
| Cpriv | |
| 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 | This type abstracts changes for a class_decl |
| Cpriv | The type of the private data (pimpl sub-object) of the class_diff type |
| Cclass_or_union_diff | This is the base class of class_diff and union_diff |
| Cpriv | The type of private data of class_or_union_diff |
| Ccorpus_diff | An abstraction of a diff between between two abi corpus |
| Cdiff_stats | This is a document class that aims to capture statistics about the changes carried by a corpus_diff type |
| Cpriv | The type of the private data of corpus_diff::diff_stats |
| Cpriv | |
| 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 | The base class of diff between decls |
| Cpriv | |
| Cdefault_reporter | The default, initial, reporter of the libabigail comparison engine |
| Cdeletion | The abstraction of the deletion of one element of a sequence A |
| Cdiff | The abstraction of a change between two ABI artifacts, a.k.a an artifact change |
| 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 |
| Cpriv | 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_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 |
| Cdiff_sptr_hasher | Hasher for diff_sptr |
| Cdiff_traversable_base | The base class for the diff classes that are to be traversed |
| Cdistinct_diff | An abstraction of a diff between entities that are of a different kind (disctinct) |
| Cpriv | 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 | Abstraction of a diff between two enums |
| Cpriv | |
| Cenumerator_value_comp | A functor to compare two enumerators based on their value. This implements the "less than" operator |
| Cfn_parm_diff | Abstraction of a diff between two function parameters |
| Cpriv | |
| 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 | Abstraction of a diff between two function_decl |
| Cpriv | |
| Cfunction_decl_diff_comp | A "Less Than" functor to compare instance of function_decl_diff |
| Cfunction_type_diff | Abstraction of a diff between two function types |
| Cpriv | |
| 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 |
| Cleaf_reporter | A reporter that only reports leaf changes |
| 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 | The abstraction of a diff between two pointers |
| Cpriv | The internal type for the impl idiom implementation of pointer_diff |
| Cptr_to_mbr_diff | The abstraction of a diff between two ptr_to_mbr_type |
| Cpriv | The private data of the ptr_to_mbr_diff type |
| Cqualified_type_diff | Abstraction of a diff between two qualified types |
| Cpriv | |
| Creference_diff | The abstraction of a diff between two references |
| Cpriv | |
| Creporter_base | The base class of all the reporting classes |
| Cscope_diff | An abstractions of the changes between two scopes |
| Cpriv | |
| Csubrange_diff | The abstraction of the diff between two subrange types |
| Cpriv | The internal type for the impl idiom implementation of subrange_diff |
| Ctranslation_unit_diff | An abstraction of a diff between two translation units |
| Cpriv | |
| Ctype_decl_diff | Abstraction of a diff between two basic type declarations |
| Ctype_diff_base | The base class of diff between types |
| Cpriv | |
| Ctypedef_diff | Abstraction of a diff between two typedef_decl |
| Cpriv | |
| Ctypes_or_decls_equal | An equality functor for types_or_decls_type |
| Ctypes_or_decls_hash | A hashing functor for types_or_decls_type |
| Cunion_diff | |
| Cvar_comp | A functor to compare instances of var_decl base on their qualified names |
| Cvar_diff | Abstracts a diff between two instances of var_decl |
| Cpriv | The internal type for the impl idiom implementation of var_diff |
| Cvar_diff_sptr_comp | Functor to sort instances of var_diff_sptr |
| Cvector | |
| Cvirtual_member_function_diff_comp | A comparison functor for instances of function_decl_diff that represent changes between two virtual member functions |
| Ndiff_utils | Libabigail's core diffing algorithms |
| 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 |
| 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 | |
| Ndwarf | The namespace for the DWARF reader |
| Coptional | Simplified implementation of std::optional just enough to be used as a replacement for our purposes and when compiling with pre C++17 |
| Nelf | The namespace for the ELF Reader |
| Creader | This is the interface an ELF reader |
| Nelf_helpers | |
| Cdwfl_deleter | A functor used by dwfl_sptr |
| Nini | Namespace for handling ini-style files |
| 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 |
| Csection | The abstraction of one section of the .ini config |
| Cfunction_call_expr | The abstraction of a function call expression |
| Clist_property | A class representing a list property |
| Clist_property_value | Abstracts the value of a property representing a list of strings |
| Cproperty | The base class of the different kinds of properties of an INI file |
| Cproperty_value | Base class of propertie values |
| Csimple_property | A simple property. That is, one which value is a string_property_value |
| Cstring_property_value | A property value which is a string |
| Ctuple_property | Abstraction of a tuple property. A tuple property is a property which value is a tuple_property_value |
| Ctuple_property_value | A property value that is a tuple |
| Cvector | |
| Nir | The namespace of the internal representation of ABI artifacts like types and decls |
| Carray_type_def | The abstraction of an array type |
| Chash | Hash functor for instances of hash |
| Csubrange_type | Abstraction for an array range type, like in Ada, or just for an array dimension like in C or C++ |
| Cbound_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 |
| Chash | Hash functor for instances of subrange_type |
| Ccanonical_type_hash | Functor to hash a canonical type by using its pointer value |
| Cclass_decl | Abstracts a class declaration |
| Cbase_spec | Abstraction of a base specifier in a class declaration |
| Chash | The hashing functor for class_decl::base_spec |
| Chash | Hasher for the class_decl type |
| Cclass_or_union | The base type of class_decl and union_decl |
| Chash | Hasher for the class_or_union type |
| Cpriv | |
| Cclass_tdecl | Abstract a class template |
| 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 |
| 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 |
| Cexported_decls_builder | Abstracts the building of the set of exported variables and functions |
| Cpriv | The type of the private data of exported_decls_builder type |
| Cpriv | The private data of the corpus type |
| Ccorpus_group | Abstraction of a group of corpora |
| Cdecl_base | The base type of all declarations |
| Chash | |
| 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 |
| Cdm_context_rel | The abstraction for a data member context relationship. This relates a data member to its parent class |
| Celf_symbol | Abstraction of an elf symbol |
| Cversion | The abstraction of the version of an ELF symbol |
| Cenum_type_decl | Abstracts a declaration for an enum type |
| Cenumerator | The abstraction of an enumerator |
| Chash | 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 |
| Cpriv | The private data of the environment type |
| Cfunction_decl | Abstraction for a function declaration |
| Cparameter | Abstraction of a function parameter |
| Cptr_equal | Equality functor for instances of function_decl |
| Cfunction_tdecl | Abstract a function template declaration |
| Cfunction_type | Abstraction of a function type |
| Chash | The hashing functor for function_type |
| Cpriv | The type of the private data of the function_type type |
| Cglobal_scope | This abstracts the global scope of a given translation unit |
| Cir_node_visitor | The base class for the visitor type hierarchy used for traversing a translation unit |
| Cir_traversable_base | The base of an entity of the intermediate representation that is to be traversed |
| Clocation | The source location of a token |
| Clocation_manager | The entry point to manage locations |
| Cmem_fn_context_rel | Abstraction of a member function context relationship. This relates a member function to its parent class |
| 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 |
| Chash | The hashing functor for member_base |
| Cmember_class_template | Abstracts a member class template template |
| Cmember_function_template | Abstract a member function template |
| Cmethod_decl | Abstraction of the declaration of a method |
| Cmethod_type | Abstracts the type of a class member function |
| Chash | Hashing functor for the method_type type |
| Cnamespace_decl | The abstraction of a namespace declaration |
| Cnode_visitor_base | The base class for the visitor type hierarchy used for traversing a hierarchy of nodes |
| Cnon_type_tparameter | Abstracts non type template parameters |
| Coptional | 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 | The abstraction of a pointer type |
| Chash | Hash functor for instances of pointer_type_def |
| Cptr_to_mbr_type | The abstraction of a pointer-to-member type |
| Chash | Hash functor for instances of ptr_to_mbr_type |
| Cqualified_type_def | The abstraction of a qualified type |
| Chash | Hash functor for instances of qualified_type_def |
| Creal_type | The internal representation of an integral type |
| Creference_type_def | Abstracts a reference type |
| Chash | Hash functor for instances of reference_type_def |
| Cscope_decl | A declaration that introduces a scope |
| Cscope_type_decl | A type that introduces a scope |
| 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_decl | The base class of templates |
| 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 |
| Ctemplate_tparameter | Abstracts a template template parameter |
| Ctranslation_unit | This is the abstraction of the set of relevant artefacts (types, variable declarations, functions, templates, etc) bundled together into a translation unit |
| Cpriv | 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 |
| Ctype_base | An abstraction helper for type declarations |
| Chash | Hash functor for instances of type_base |
| Cpriv | Definition of the private data of type_base |
| 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 |
| Chash | 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 | The base class of both types and declarations |
| Cpriv | 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 |
| Ctype_tparameter | Abstracts a type template parameter |
| Ctypedef_decl | The abstraction of a typedef declaration |
| Chash | Hash functor for instances of typedef_decl |
| Cuint64_t_pair_hash | The hashing functor for a pair of uint64_t |
| Cunion_decl | Abstracts a union type declaration |
| Chash | Hash functor for instances of union_decl type |
| Cvar_decl | Abstracts a variable declaration |
| Cptr_equal | A comparison functor for pointers to var_decl |
| Cvector | |
| Nregex | Namespace for regex types and functions |
| 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 |
| Nsptr_utils | Namespace for the utilities to wrap C types into std::shared_ptr |
| Cnoop_deleter | A deleter for shared pointers that ... doesn't delete the object managed by the shared pointer |
| Nsuppr | Engine to suppress the parts of the result of comparing two sets of ABI artifacts |
| Cdiff | The abstraction of a change between two ABI artifacts, a.k.a an artifact change |
| Cfile_suppression | Abstraction of a suppression specification to avoid loading a file |
| Cfunction_suppression | Abstraction of a function suppression specification |
| Cparameter_spec | Abstraction of the specification of a function parameter in a function suppression specification |
| Cpriv | |
| Cpriv | 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 |
| Cpriv | The private data of suppression_base |
| Ctype_suppression | Abstraction of a type suppression specification |
| Cinsertion_range | The abstraction of a range of offsets in which a member of a type might get inserted |
| Cboundary | The abstraction of the boundary of an insertion_range, in the context of a type_suppression |
| Cfn_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 |
| Cinteger_boundary | An insertion_range boundary that is expressed as an integer value. That integer value is usually a bit offset |
| Cnamed_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 |
| Cpriv | The private data for type_suppression |
| Cvariable_suppression | The abstraction of a variable suppression specification |
| Cpriv | The type of the private data of the variable_suppression type |
| Cvector | |
| Nsymtab_reader | |
| 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 |
| Csymtab_iterator | An iterator to walk a vector of elf_symbols filtered by symtab_filter |
| Ntests | |
| Nread_common | |
| 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 |
| Ctest_task | The task that performs the tests |
| Ntools_utils | Namespace for a set of utility function used by tools based on libabigail |
| Ctemp_file | A temporary file |
| Ctimer | A type used to time various part of the libabigail system |
| Cxz_decompressor_type | This is a custom std::streambuf that knows how to decompress an input stream that was compressed using xz |
| Nworkers | The namespace of the worker threads (or thread pool) implementation of libabigail. This was modelled after the article https://en.wikipedia.org/wiki/Thread_pool |
| Cqueue | This represents a queue of tasks to be performed |
| Ctask_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 |
| Nxml | Internal namespace for xml manipulation utilities |
| 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 |
| Cxz_decompressor_type | This is a custom std::streambuf that knows how to decompress an input stream that was compressed using xz |
| Ccanvas | |
| Cchild_node | |
| Cconfig | This type abstracts the configuration information of the library |
| Cdot | |
| Celf_based_reader | The common interface of readers based on ELF |
| Cfe_iface | The base class of all libabigail front-ends: The Front End Interface |
| Coptions_type | The generic options that control the behaviour of all Front-End interfaces |
| Cfunction_decl | Abstraction for a function declaration |
| Cparameter | Abstraction of a function parameter |
| Cptr_equal | Equality functor for instances of function_decl |
| Chash_interned_string | A functor to hash instances of interned_string |
| Cinterned_string | The abstraction of an interned string |
| Cinterned_string_pool | The interned string pool |
| Cnode_base | Base class for graph nodes |
| Cnoop_deleter | A deleter for shared pointers that ... doesn't delete the object managed by the shared pointer |
| Cparent_node | |
| Crow | |
| Cstyle | Datum consolidating style preferences |
| Csvg | |
| Ctypography | |
| Cvector | |
| Ncomparison | |
| Ndiff | |
| Cpriv | Private data for the diff type. The details of generic view of the diff node are expressed here |
| Cbase_iterator |
Generated by
1.17.0