  abg_compat | |
   optional | Simplified implementation of std::optional just enough to be used as a replacement for our purposes and when compiling with pre C++17 |
| abigail | Toplevel namespace for libabigail |
 comparison | Utilities to compare abi artifacts |
| filtering | Facilities to walk, categorize and possibly filter nodes of the diff tree |
 filter_base | The base class for the diff tree node filter |
| harmless_filter | A filter that walks the diff nodes tree and tags relevant diff nodes into categories considered to represent harmless changes |
| 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 |
| array_diff | The abstraction of a diff between two arrays |
| priv | |
| base_diff | An abstraction of a diff between two instances of class_decl::base_spec |
| priv | |
| base_diff_comp | A comparison function for instances of base_diff |
| base_spec_comp | A functor to compare instances of class_decl::base_spec |
| changed_enumerator_comp | A functor to compare two changed enumerators, based on their initial value |
| class_diff | This type abstracts changes for a class_decl |
| priv | The type of the private data (pimpl sub-object) of the class_diff type |
| class_or_union_diff | This is the base class of class_diff and union_diff |
| priv | The type of private data of class_or_union_diff |
| corpus_diff | An abstraction of a diff between between two abi corpus |
| diff_stats | This is a document class that aims to capture statistics about the changes carried by a corpus_diff type |
| priv | The type of the private data of corpus_diff::diff_stats |
| priv | |
| data_member_comp | A comparison functor to compare two data members based on their offset |
| data_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 |
| decl_diff_base | The base class of diff between decls |
| priv | |
| default_reporter | The default, initial, reporter of the libabigail comparison engine |
| diff | The abstraction of a change between two ABI artifacts |
| priv | Private data for the diff type |
| diff_comp | A comparison functor for instances of diff |
| diff_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 |
| priv | The private member (pimpl) for diff_context |
| diff_equal | A comparison functor for using diff_sptr and diff* in a hash map or set |
| diff_hash | A hashing functor for using diff_sptr and diff* in a hash map or set |
| diff_less_than_functor | A functor to compare two instances of diff_sptr |
| diff_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 |
| diff_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 |
| diff_sptr_hasher | Hasher for diff_sptr |
| diff_traversable_base | The base class for the diff classes that are to be traversed |
| distinct_diff | An abstraction of a diff between entities that are of a different kind (disctinct) |
| priv | The private data structure for distinct_diff |
| elf_symbol_comp | A functor to compare instances of elf_symbol base on their names |
| enum_diff | Abstraction of a diff between two enums |
| priv | |
| enumerator_value_comp | A functor to compare two enumerators based on their value. This implements the "less than" operator |
| fn_parm_diff | Abstraction of a diff between two function parameters |
| priv | |
| fn_parm_diff_comp | A comparison functor to compare two instances of fn_parm_diff based on their indexes |
| function_comp | "Less than" functor to compare instances of function_decl |
| function_decl_diff | Abstraction of a diff between two function_decl |
| priv | |
| function_decl_diff_comp | A "Less Than" functor to compare instance of function_decl_diff |
| function_type_diff | Abstraction of a diff between two function types |
| priv | |
| leaf_reporter | A reporter that only reports leaf changes |
| parm_comp | Functor that compares two function parameters for the purpose of sorting them |
| pointer_diff | The abstraction of a diff between two pointers |
| priv | The internal type for the impl idiom implementation of pointer_diff |
| qualified_type_diff | Abstraction of a diff between two qualified types |
| priv | |
| reference_diff | The abstraction of a diff between two references |
| priv | |
| reporter_base | The base class of all the reporting classes |
| scope_diff | An abstractions of the changes between two scopes |
| priv | |
| translation_unit_diff | An abstraction of a diff between two translation units |
| priv | |
| type_decl_diff | Abstraction of a diff between two basic type declarations |
| type_diff_base | The base class of diff between types |
| priv | |
| typedef_diff | Abstraction of a diff between two typedef_decl |
| priv | |
| types_or_decls_equal | An equality functor for types_or_decls_type |
| types_or_decls_hash | A hashing functor for types_or_decls_type |
| union_diff | |
| var_comp | A functor to compare instances of var_decl base on their qualified names |
| var_diff | Abstracts a diff between two instances of var_decl |
| priv | The internal type for the impl idiom implementation of var_diff |
| var_diff_sptr_comp | Functor to sort instances of var_diff_sptr |
| virtual_member_function_diff_comp | A comparison functor for instances of function_decl_diff that represent changes between two virtual member functions |
| diff_utils | Libabigail's core diffing algorithms |
| d_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 |
| deep_ptr_eq_functor | An equality functor to deeply compare pointers |
| default_eq_functor | The default equality functor used by the core diffing algorithms |
| deletion | The abstraction of the deletion of one element of a sequence A |
| edit_script | The abstraction of an edit script for transforming a sequence A into a sequence B |
| insertion | 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 |
| point | 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) |
| snake | The abstraction of the Snake concept, from the paper |
| dwarf_reader | The namespace for the DWARF reader |
| hashing | Namespace for hashing |
| ini | Namespace for handling ini-style files |
| config | The abstraction of the structured content of an .ini file. This roughly follows what is explained at http://en.wikipedia.org/wiki/INI_file |
| section | The abstraction of one section of the .ini config |
| function_call_expr | The abstraction of a function call expression |
| list_property | A class representing a list property |
| list_property_value | Abstracts the value of a property representing a list of strings |
| property | The base class of the different kinds of properties of an INI file |
| property_value | Base class of propertie values |
| simple_property | A simple property. That is, one which value is a string_property_value |
| string_property_value | A property value which is a string |
| tuple_property | Abstraction of a tuple property. A tuple property is a property which value is a tuple_property_value |
| tuple_property_value | A property value that is a tuple |
| ir | The namespace of the internal representation of ABI artifacts like types and decls |
| array_type_def | The abstraction of an array type |
 subrange_type | Abstraction for an array range type, like in Ada, or just for an array dimension like in C or C++ |
 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 |
| canonical_type_hash | Functor to hash a canonical type by using its pointer value |
| class_decl | Abstracts a class declaration |
| base_spec | Abstraction of a base specifier in a class declaration |
| hash | The hashing functor for class_decl::base_spec |
| hash | Hasher for the class_decl type |
| class_or_union | The base type of class_decl and union_decl |
| hash | Hasher for the class_or_union type |
| priv | |
| class_tdecl | Abstract a class template |
| hash | |
| shared_ptr_hash | |
| context_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 |
| corpus | 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 |
| exported_decls_builder | Abstracts the building of the set of exported variables and functions |
| priv | The type of the private data of corpus::exported_decls_builder type |
| priv | The private data of the corpus type |
| corpus_group | Abstraction of a group of corpora |
| decl_base | The base type of all declarations |
| dm_context_rel | The abstraction for a data member context relationship. This relates a data member to its parent class |
| elf_symbol | Abstraction of an elf symbol |
| version | The abstraction of the version of an ELF symbol |
| enum_type_decl | Abstracts a declaration for an enum type |
| enumerator | The abstraction of an enumerator |
| environment | This is an abstraction of the set of resources necessary to manage several aspects of the internal representations of the Abigail library |
| priv | The private data of the environment type |
| function_decl | Abstraction for a function declaration |
| hash | A hashing functor fo instances and pointers of function_decl |
| parameter | Abstraction of a function parameter |
| hash | A hashing functor for a function_decl::parameter |
| ptr_equal | Equality functor for instances of function_decl |
| function_tdecl | Abstract a function template declaration |
| hash | |
| shared_ptr_hash | |
| function_type | Abstraction of a function type |
| hash | The hashing functor for function_type |
| global_scope | This abstracts the global scope of a given translation unit |
| integral_type | The internal representation of an integral type |
| ir_node_visitor | The base class for the visitor type hierarchy used for traversing a translation unit |
| ir_traversable_base | The base of an entity of the intermediate representation that is to be traversed |
| location | The source location of a token |
| location_manager | The entry point to manage locations |
| mem_fn_context_rel | Abstraction of a member function context relationship. This relates a member function to its parent class |
| member_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 |
| hash | The hashing functor for member_base |
| member_class_template | Abstracts a member class template template |
| hash | The hashing functor for member_class_template |
| member_function_template | Abstract a member function template |
| hash | The hashing functor for member_function_template |
| method_decl | Abstraction of the declaration of a method |
| method_type | Abstracts the type of a class member function |
| namespace_decl | The abstraction of a namespace declaration |
| node_visitor_base | The base class for the visitor type hierarchy used for traversing a hierarchy of nodes |
| non_type_tparameter | Abstracts non type template parameters |
| hash | Hasher for the non_type_tparameter type |
| pointer_type_def | The abstraction of a pointer type |
| qualified_type_def | The abstraction of a qualified type |
| reference_type_def | Abstracts a reference type |
| scope_decl | A declaration that introduces a scope |
| hash | Hasher for the scope_decl type |
| scope_type_decl | A type that introduces a scope |
| shared_translation_unit_comp | A comparison functor to compare translation units based on their absolute paths |
| template_decl | The base class of templates |
| hash | |
| template_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 |
| template_tparameter | Abstracts a template template parameter |
| translation_unit | This is the abstraction of the set of relevant artefacts (types, variable declarations, functions, templates, etc) bundled together into a translation unit |
| priv | Private type to hold private members of translation_unit |
| traversable_base | The interface for types which are feeling social and want to be visited during the traversal of a hierarchy of nodes |
| type_base | An abstraction helper for type declarations |
| dynamic_hash | |
| hash | Hash functor for instances of type_base |
| priv | Definition of the private data of type_base |
| shared_ptr_hash | |
| type_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 |
| hash | Hasher for the type_composition type |
| type_decl | A basic type declaration that introduces no scope |
| type_maps | This is a type that aggregates maps of all the kinds of types that are supported by libabigail |
| type_or_decl_base | The base class of both types and declarations |
| type_or_decl_base_comp | A comparison functor to compare pointer to instances of type_or_decl_base |
| type_or_decl_equal | The comparison functor for using instances of type_or_decl_base as values in a hash map or set |
| type_or_decl_hash | The hashing functor for using instances of type_or_decl_base as values in a hash map or set |
| type_ptr_equal | A predicate for deep equality of instances of type_base* |
| type_shared_ptr_equal | A predicate for deep equality of instances of shared_ptr<type_base> |
| type_tparameter | Abstracts a type template parameter |
| typedef_decl | The abstraction of a typedef declaration |
| union_decl | Abstracts a union type declaration |
| var_decl | Abstracts a variable declaration |
| hash | A hashing functor for instances and pointers of var_decl |
| ptr_equal | A comparison functor for pointers to var_decl |
| regex | Namespace for regex types and functions |
| escape | A class to hold a reference to a string to regex escape |
| regex_t_deleter | A delete functor for a shared_ptr of regex_t |
| sptr_utils | Namespace for the utilities to wrap C types into std::shared_ptr |
| noop_deleter | A deleter for shared pointers that ... doesn't delete the object managed by the shared pointer |
| suppr | Engine to suppress the parts of the result of comparing two sets of ABI artifacts |
| file_suppression | Abstraction of a suppression specification to avoid loading a file |
| function_suppression | Abstraction of a function suppression specification |
| parameter_spec | Abstraction of the specification of a function parameter in a function suppression specification |
| priv | |
| priv | The type of the private data of the function_suppression type |
| suppression_base | Base type of the suppression specifications types |
| priv | The private data of suppression_base |
| type_suppression | Abstraction of a type suppression specification |
| insertion_range | The abstraction of a range of offsets in which a member of a type might get inserted |
| boundary | The abstraction of the boundary of an insertion_range, in the context of a type_suppression |
| 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 |
| integer_boundary | An insertion_range boundary that is expressed as an integer value. That integer value is usually a bit offset |
| priv | The private data for type_suppression |
| variable_suppression | The abstraction of a variable suppression specification |
| priv | The type of the private data of the variable_suppression type |
| symtab_reader | |
| filtered_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) |
| symtab | Symtab is the actual data container of the symtab_reader implementation |
| symtab_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 |
| symtab_iterator | An iterator to walk a vector of elf_symbols filtered by symtab_filter |
| tools_utils | Namespace for a set of utility function used by tools based on libabigail |
| temp_file | A temporary file |
| timer | A type used to time various part of the libabigail system |
| workers | 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 |
| queue | This represents a queue of tasks to be performed |
| task_done_notify | This functor is to notify listeners that a given task scheduled for execution has been fully executed |
| task | This represents a task to be performed |
| xml | Internal namespace for xml manipulation utilities |
| charDeleter | This functor is used to instantiate a shared_ptr for xmlChar |
| textReaderDeleter | This functor is used to instantiate a shared_ptr for the xmlTextReader |
| xml_reader | The namespace for the native XML file format reader |
| xml_writer | The namespace for the native XML file format writer |
| canvas | |
| child_node | |
| config | This type abstracts the configuration information of the library |
| dot | |
| hash_interned_string | A functor to hash instances of interned_string |
| interned_string | The abstraction of an interned string |
| interned_string_pool | The interned string pool |
| node_base | Base class for graph nodes |
| parent_node | |
| row | |
| style | Datum consolidating style preferences |
| svg | |
| typography | |
| base_iterator | |
1.8.5
