  optional< T > | Simplified implementation of std::optional just enough to be used as a replacement for our purposes and when compiling with pre C++17 |
| canvas | |
| array_diff::priv | |
| base_diff::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::priv | The type of the private data (pimpl sub-object) of the class_diff type |
| class_or_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 |
| corpus_diff::diff_stats | This is a document class that aims to capture statistics about the changes carried by a corpus_diff type |
| corpus_diff::diff_stats::priv | The type of the private data of corpus_diff::diff_stats |
| corpus_diff::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::priv | |
| diff::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 |
| diff_context::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_sptr_hasher | Hasher for diff_sptr |
| distinct_diff::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::priv | |
| enumerator_value_comp | A functor to compare two enumerators based on their value. This implements the "less than" operator |
| fn_parm_diff::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::priv | |
| function_decl_diff_comp | A "Less Than" functor to compare instance of function_decl_diff |
| function_type_diff::priv | |
| parm_comp | Functor that compares two function parameters for the purpose of sorting them |
| pointer_diff::priv | The internal type for the impl idiom implementation of pointer_diff |
| qualified_type_diff::priv | |
| reference_diff::priv | |
 reporter_base | The base class of all the reporting classes |
  default_reporter | The default, initial, reporter of the libabigail comparison engine |
  leaf_reporter | A reporter that only reports leaf changes |
| scope_diff::priv | |
| translation_unit_diff::priv | |
| type_diff_base::priv | |
| typedef_diff::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 |
| var_comp | A functor to compare instances of var_decl base on their qualified names |
| var_diff::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 |
| config | This type abstracts the configuration information of the library |
| 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 |
| dot | |
| hash_interned_string | A functor to hash instances of interned_string |
| 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 |
| config::section | The abstraction of one section of the .ini config |
| function_call_expr | The abstraction of a function call expression |
| property | The base class of the different kinds of properties of an INI file |
| list_property | A class representing a list property |
| simple_property | A simple property. That is, one which value is a string_property_value |
| tuple_property | Abstraction of a tuple property. A tuple property is a property which value is a tuple_property_value |
| property_value | Base class of propertie values |
| list_property_value | Abstracts the value of a property representing a list of strings |
| string_property_value | A property value which is a string |
| tuple_property_value | A property value that is a tuple |
| interned_string | The abstraction of an interned string |
| interned_string_pool | The interned string pool |
| array_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 |
| canonical_type_hash | Functor to hash a canonical type by using its pointer value |
| class_decl::base_spec::hash | The hashing functor for class_decl::base_spec |
| class_decl::hash | Hasher for the class_decl type |
| class_or_union::hash | Hasher for the class_or_union type |
| class_or_union::priv | |
| class_tdecl::hash | |
| class_tdecl::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 |
| dm_context_rel | The abstraction for a data member context relationship. This relates a data member to its parent class |
| mem_fn_context_rel | Abstraction of a member function context relationship. This relates a member function to its parent class |
| 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 |
| corpus_group | Abstraction of a group of corpora |
| corpus::exported_decls_builder | Abstracts the building of the set of exported variables and functions |
| corpus::exported_decls_builder::priv | The type of the private data of corpus::exported_decls_builder type |
| corpus::priv | The private data of the corpus type |
| elf_symbol | Abstraction of an elf symbol |
| elf_symbol::version | The abstraction of the version of an ELF symbol |
| enum_type_decl::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 |
| environment::priv | The private data of the environment type |
| function_decl::hash | A hashing functor fo instances and pointers of function_decl |
| function_decl::parameter::hash | A hashing functor for a function_decl::parameter |
| function_decl::ptr_equal | Equality functor for instances of function_decl |
| function_tdecl::hash | |
| function_tdecl::shared_ptr_hash | |
| function_type::hash | The hashing functor for function_type |
| integral_type | The internal representation of an integral type |
| location | The source location of a token |
| location_manager | The entry point to manage locations |
| 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 |
| class_decl::base_spec | Abstraction of a base specifier in a class declaration |
| member_class_template | Abstracts a member class template template |
| member_function_template | Abstract a member function template |
| member_base::hash | The hashing functor for member_base |
| member_class_template::hash | The hashing functor for member_class_template |
| member_function_template::hash | The hashing functor for member_function_template |
| node_visitor_base | The base class for the visitor type hierarchy used for traversing a hierarchy of nodes |
| 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 |
| 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 |
| ir_node_visitor | The base class for the visitor type hierarchy used for traversing a translation unit |
| non_type_tparameter::hash | Hasher for the non_type_tparameter type |
| scope_decl::hash | Hasher for the scope_decl type |
| shared_translation_unit_comp | A comparison functor to compare translation units based on their absolute paths |
| template_decl::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 |
| non_type_tparameter | Abstracts non type template parameters |
| 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 |
| type_tparameter | Abstracts a type template parameter |
| template_tparameter | Abstracts a template template parameter |
| 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 |
| diff_traversable_base | The base class for the diff classes that are to be traversed |
| diff | The abstraction of a change between two ABI artifacts |
| base_diff | An abstraction of a diff between two instances of class_decl::base_spec |
| decl_diff_base | The base class of diff between decls |
| fn_parm_diff | Abstraction of a diff between two function parameters |
| function_decl_diff | Abstraction of a diff between two function_decl |
| var_diff | Abstracts a diff between two instances of var_decl |
| distinct_diff | An abstraction of a diff between entities that are of a different kind (disctinct) |
| scope_diff | An abstractions of the changes between two scopes |
| translation_unit_diff | An abstraction of a diff between two translation units |
| type_diff_base | The base class of diff between types |
| array_diff | The abstraction of a diff between two arrays |
| class_or_union_diff | This is the base class of class_diff and union_diff |
| class_diff | This type abstracts changes for a class_decl |
| union_diff | |
| enum_diff | Abstraction of a diff between two enums |
| function_type_diff | Abstraction of a diff between two function types |
| pointer_diff | The abstraction of a diff between two pointers |
| qualified_type_diff | Abstraction of a diff between two qualified types |
| reference_diff | The abstraction of a diff between two references |
| type_decl_diff | Abstraction of a diff between two basic type declarations |
| typedef_diff | Abstraction of a diff between two typedef_decl |
| ir_traversable_base | The base of an entity of the intermediate representation that is to be traversed |
| type_or_decl_base | The base class of both types and declarations |
| decl_base | The base type of all declarations |
| array_type_def | The abstraction of an array type |
| array_type_def::subrange_type | Abstraction for an array range type, like in Ada, or just for an array dimension like in C or C++ |
| class_decl::base_spec | Abstraction of a base specifier in a class declaration |
| enum_type_decl | Abstracts a declaration for an enum type |
| function_decl | Abstraction for a function declaration |
| method_decl | Abstraction of the declaration of a method |
| function_decl::parameter | Abstraction of a function parameter |
| member_class_template | Abstracts a member class template template |
| member_function_template | Abstract a member function template |
| non_type_tparameter | Abstracts non type template parameters |
| 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 |
| class_tdecl | Abstract a class template |
| function_tdecl | Abstract a function template declaration |
| global_scope | This abstracts the global scope of a given translation unit |
| namespace_decl | The abstraction of a namespace declaration |
| scope_type_decl | A type that introduces a scope |
| class_or_union | The base type of class_decl and union_decl |
| class_decl | Abstracts a class declaration |
| union_decl | Abstracts a union type declaration |
| template_decl | The base class of templates |
| class_tdecl | Abstract a class template |
| function_tdecl | Abstract a function template declaration |
| template_tparameter | Abstracts a template template parameter |
| 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 |
| type_decl | A basic type declaration that introduces no scope |
| type_tparameter | Abstracts a type template parameter |
| typedef_decl | The abstraction of a typedef declaration |
| var_decl | Abstracts a variable declaration |
| type_base | An abstraction helper for type declarations |
| array_type_def | The abstraction of an array type |
| array_type_def::subrange_type | Abstraction for an array range type, like in Ada, or just for an array dimension like in C or C++ |
| enum_type_decl | Abstracts a declaration for an enum type |
| function_type | Abstraction of a function type |
| method_type | Abstracts the type of a class member function |
| 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_type_decl | A type that introduces a scope |
| type_decl | A basic type declaration that introduces no scope |
| typedef_decl | The abstraction of a typedef declaration |
| translation_unit | This is the abstraction of the set of relevant artefacts (types, variable declarations, functions, templates, etc) bundled together into a translation unit |
| type_base::dynamic_hash | |
| type_base::hash | Hash functor for instances of type_base |
| type_base::priv | Definition of the private data of type_base |
| type_base::shared_ptr_hash | |
| type_composition::hash | Hasher for the type_composition type |
| type_maps | This is a type that aggregates maps of all the kinds of types that are supported by libabigail |
| 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> |
| var_decl::hash | A hashing functor for instances and pointers of var_decl |
| var_decl::ptr_equal | A comparison functor for pointers to var_decl |
| node_base | Base class for graph nodes |
| child_node | |
| parent_node | |
| 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 |
| row | |
| noop_deleter | A deleter for shared pointers that ... doesn't delete the object managed by the shared pointer |
| style | Datum consolidating style preferences |
| function_suppression::parameter_spec | Abstraction of the specification of a function parameter in a function suppression specification |
| function_suppression::parameter_spec::priv | |
| function_suppression::priv | The type of the private data of the function_suppression type |
| suppression_base | Base type of the suppression specifications types |
| file_suppression | Abstraction of a suppression specification to avoid loading a file |
| function_suppression | Abstraction of a function suppression specification |
| type_suppression | Abstraction of a type suppression specification |
| variable_suppression | The abstraction of a variable suppression specification |
| suppression_base::priv | The private data of suppression_base |
| type_suppression::insertion_range | The abstraction of a range of offsets in which a member of a type might get inserted |
| type_suppression::insertion_range::boundary | The abstraction of the boundary of an insertion_range, in the context of a type_suppression |
| type_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 |
| type_suppression::insertion_range::integer_boundary | An insertion_range boundary that is expressed as an integer value. That integer value is usually a bit offset |
| type_suppression::priv | The private data for type_suppression |
| variable_suppression::priv | The type of the private data of the variable_suppression type |
| svg | |
| 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 |
| temp_file | A temporary file |
| timer | A type used to time various part of the libabigail system |
| typography | |
| queue | This represents a queue of tasks to be performed |
| queue::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 |
| 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 |
| base_iterator | |
| symtab_iterator | An iterator to walk a vector of elf_symbols filtered by symtab_filter |
| optional< bool > | |
| optional< elf_symbols > | |
| optional< string_elf_symbols_map_type > | |
| vector | |
| 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 |
1.8.5
