
void  apply_filters (corpus_diff_sptr diff_tree) 
 Apply the diff tree filters that have been associated to the context of the a given corpus_diff tree. As a result, the nodes of the @diff tree are going to be categorized into one of several of the categories of diff_category.


void  apply_suppressions (const corpus_diff *diff_tree) 
 Walk a corpus_diff tree and appply the suppressions carried by the context. If the suppression applies to a given node then categorize the node into the SUPPRESSED_CATEGORY category and propagate that categorization.


void  apply_suppressions (corpus_diff_sptr diff_tree) 
 Walk a diff tree and appply the suppressions carried by the context. If the suppression applies to a given node than categorize the node into the SUPPRESSED_CATEGORY category and propagate that categorization.


void  apply_suppressions (diff *diff_tree) 
 Walk a given diffsub tree and appply the suppressions carried by the context. If the suppression applies to a given node than categorize the node into the SUPPRESSED_CATEGORY category and propagate that categorization.


void  apply_suppressions (diff_sptr diff_tree) 
 Walk a given diffsub tree and appply the suppressions carried by the context. If the suppression applies to a given node than categorize the node into the SUPPRESSED_CATEGORY category and propagate that categorization.


void  categorize_redundancy (corpus_diff *diff_tree) 
 Walk a given corpus_diff tree to categorize each of the nodes with respect to the REDUNDANT_CATEGORY.


void  categorize_redundancy (corpus_diff_sptr diff_tree) 
 Walk a given corpus_diff tree to categorize each of the nodes with respect to the REDUNDANT_CATEGORY.


void  categorize_redundancy (diff *diff_tree) 
 Walk a given diff subtree to categorize each of the nodes with respect to the REDUNDANT_CATEGORY.


void  categorize_redundancy (diff_sptr diff_tree) 
 Walk a given diff subtree to categorize each of the nodes with respect to the REDUNDANT_CATEGORY.


void  clear_redundancy_categorization (corpus_diff *diff_tree) 
 Walk a given corpus_diff tree to clear the REDUNDANT_CATEGORY out of the category of the nodes.


void  clear_redundancy_categorization (corpus_diff_sptr diff_tree) 
 Walk a given corpus_diff tree to clear the REDUNDANT_CATEGORY out of the category of the nodes.


void  clear_redundancy_categorization (diff *diff_tree) 
 Walk a given diff subtree to clear the REDUNDANT_CATEGORY out of the category of the nodes.


void  clear_redundancy_categorization (diff_sptr diff_tree) 
 Walk a given diff subtree to clear the REDUNDANT_CATEGORY out of the category of the nodes.


subrange_diff_sptr  compute_diff (array_type_def::subrange_sptr first, array_type_def::subrange_sptr second, diff_context_sptr ctxt) 
 Compute the diff between two instances of subrange_diff.


array_diff_sptr  compute_diff (array_type_def_sptr first, array_type_def_sptr second, diff_context_sptr ctxt) 
 Compute the diff between two arrays.


base_diff_sptr  compute_diff (const class_decl::base_spec_sptr first, const class_decl::base_spec_sptr second, diff_context_sptr ctxt) 
 Constructs the diff object representing a diff between two base class specifications.


class_diff_sptr  compute_diff (const class_decl_sptr first, const class_decl_sptr second, diff_context_sptr ctxt) 
 Compute the set of changes between two instances of class_decl.


corpus_diff_sptr  compute_diff (const corpus_group_sptr &f, const corpus_group_sptr &s, diff_context_sptr ctxt) 
 Compute the diff between two instances of corpus_group.


corpus_diff_sptr  compute_diff (const corpus_sptr f, const corpus_sptr s, diff_context_sptr ctxt=diff_context_sptr()) 
 Compute the diff between two instances of corpus.


diff_sptr  compute_diff (const decl_base_sptr first, const decl_base_sptr second, diff_context_sptr ctxt) 
 Compute the difference between two decls. The decls can represent either type declarations, or nontype declaration.


enum_diff_sptr  compute_diff (const enum_type_decl_sptr first, const enum_type_decl_sptr second, diff_context_sptr ctxt) 
 Compute the set of changes between two instances of enum_type_decl.


fn_parm_diff_sptr  compute_diff (const function_decl::parameter_sptr first, const function_decl::parameter_sptr second, diff_context_sptr ctxt) 
 Compute the difference between two function_decl::parameter_sptr; that is, between two function parameters. Return a resulting fn_parm_diff_sptr that represents the changes.


function_decl_diff_sptr  compute_diff (const function_decl_sptr first, const function_decl_sptr second, diff_context_sptr ctxt) 
 Compute the diff between two function_decl.


function_type_diff_sptr  compute_diff (const function_type_sptr first, const function_type_sptr second, diff_context_sptr ctxt) 
 Compute the diff between two instances of function_type.


ptr_to_mbr_diff_sptr  compute_diff (const ptr_to_mbr_type_sptr &first, const ptr_to_mbr_type_sptr &second, diff_context_sptr &ctxt) 
 Compute the diff between two ptr_to_mbr_type types.


qualified_type_diff_sptr  compute_diff (const qualified_type_def_sptr first, const qualified_type_def_sptr second, diff_context_sptr ctxt) 
 Compute the diff between two qualified types.


scope_diff_sptr  compute_diff (const scope_decl_sptr first, const scope_decl_sptr second, scope_diff_sptr d, diff_context_sptr ctxt) 
 Compute the diff between two scopes.


scope_diff_sptr  compute_diff (const scope_decl_sptr first_scope, const scope_decl_sptr second_scope, diff_context_sptr ctxt) 
 Compute the diff between two scopes.


translation_unit_diff_sptr  compute_diff (const translation_unit_sptr first, const translation_unit_sptr second, diff_context_sptr ctxt=diff_context_sptr()) 
 Compute the diff between two translation_units.


diff_sptr  compute_diff (const type_base_sptr first, const type_base_sptr second, diff_context_sptr ctxt) 
 Compute the difference between two types.


type_decl_diff_sptr  compute_diff (const type_decl_sptr first, const type_decl_sptr second, diff_context_sptr ctxt) 
 Compute a diff between two type_decl.


typedef_diff_sptr  compute_diff (const typedef_decl_sptr first, const typedef_decl_sptr second, diff_context_sptr ctxt) 
 Compute a diff between two typedef_decl.


union_diff_sptr  compute_diff (const union_decl_sptr first, const union_decl_sptr second, diff_context_sptr ctxt) 
 Compute the difference between two union_decl types.


var_diff_sptr  compute_diff (const var_decl_sptr first, const var_decl_sptr second, diff_context_sptr ctxt) 
 Compute the diff between two instances of var_decl.


pointer_diff_sptr  compute_diff (pointer_type_def_sptr first, pointer_type_def_sptr second, diff_context_sptr ctxt) 
 Compute the diff between between two pointers.


reference_diff_sptr  compute_diff (reference_type_def_sptr first, reference_type_def_sptr second, diff_context_sptr ctxt) 
 Compute the diff between two references.


distinct_diff_sptr  compute_diff_for_distinct_kinds (const type_or_decl_base_sptr first, const type_or_decl_base_sptr second, diff_context_sptr ctxt) 
 Try to diff entities that are of distinct kinds.


diff_category  get_default_harmful_categories_bitmap () 
 Getter of a bitmap made of the set of change categories that are considered harmful.


diff_category  get_default_harmless_categories_bitmap () 
 Getter of a bitmap made of the set of change categories that are considered harmless.


string  get_pretty_representation (diff *d) 
 Get a copy of the pretty representation of a diff node.


const diff *  get_typedef_diff_underlying_type_diff (const diff *diff) 
 Return the leaf underlying diff node of a typedef_diff node.


bool  has_basic_type_change_only (const diff *d) 
 Test if a diff node is a decl diff that only carries a basic type change on its type diff subnode.


const class_or_union_diff *  is_anonymous_class_or_union_diff (const diff *d) 
 Test if a diff node is a class_or_union_diff between two anonymous classes or unions.


const subrange_diff *  is_anonymous_subrange_diff (const diff *d) 
 Test if a diff node is a subrange_diff between two anonymous subranges.


const array_diff *  is_array_diff (const diff *diff) 
 Test if a diff node is a array_diff node.


const base_diff *  is_base_diff (const diff *diff) 
 Test if a diff node is about differences between two base class specifiers.


bool  is_child_node_of_base_diff (const diff *diff) 
 Test if a diff node is a child node of a base diff node.


bool  is_child_node_of_function_parm_diff (const diff *diff) 
 Test if a diff node is a child node of a function parameter diff node.


const class_diff *  is_class_diff (const diff *diff) 
 Test if a diff node is a class_diff node.


const class_or_union_diff *  is_class_or_union_diff (const diff *d) 
 Test if a diff node is a class_or_union_diff node.


const corpus_diff *  is_corpus_diff (const diff *diff) 
 Test if a diff node is a corpus_diff node.


const decl_diff_base *  is_decl_diff (const diff *diff) 
 Test if a diff node is about differences between declarations.


const type_decl_diff *  is_diff_of_basic_type (const diff *d) 
 Test if a diff node represents a diff between two basic types.


const type_decl_diff *  is_diff_of_basic_type (const diff *diff, bool allow_indirect_type) 
 Test if a diff node represents a diff between two basic types, or between pointers, references or qualified type to basic types.


const class_or_union_diff *  is_diff_of_class_or_union_type (const diff *d) 
 Test if a diff node represents a diff between two class or union types.


bool  is_diff_of_variadic_parameter (const diff *d) 
 Test if a diff node represents the difference between a variadic parameter and something else.


bool  is_diff_of_variadic_parameter (const diff_sptr &d) 
 Test if a diff node represents the difference between a variadic parameter and something else.


bool  is_diff_of_variadic_parameter_type (const diff *d) 
 Test if a diff node represents the difference between a variadic parameter type and something else.


bool  is_diff_of_variadic_parameter_type (const diff_sptr &d) 
 Test if a diff node represents the difference between a variadic parameter type and something else.


const distinct_diff *  is_distinct_diff (const diff *diff) 
 Test if a diff node is about differences between two diff nodes of different kinds.


const enum_diff *  is_enum_diff (const diff *diff) 
 Test if a diff node is a enum_diff node.


const fn_parm_diff *  is_fn_parm_diff (const diff *diff) 
 Test if a diff node is about differences between two function parameters.


const function_decl_diff *  is_function_decl_diff (const diff *diff) 
 Test if a diff node is about differences between functions.


const function_type_diff *  is_function_type_diff (const diff *diff) 
 Test if a diff node is a function_type_diff node.


const function_type_diff *  is_function_type_diff_with_local_changes (const diff *diff) 
 Test if a given diff node carries a function type change with local changes.


const pointer_diff *  is_pointer_diff (const diff *diff) 
 Test if a diff node is about differences between two pointers.


const qualified_type_diff *  is_qualified_type_diff (const diff *diff) 
 Test if a diff node is about differences between two qualified types.


const reference_diff *  is_reference_diff (const diff *diff) 
 Test if a diff node is about differences between two references.


const subrange_diff *  is_subrange_diff (const diff *diff) 
 Test if a diff node is a subrange_diff node.


const type_diff_base *  is_type_diff (const diff *diff) 
 Test if a diff node is about differences between types.


const typedef_diff *  is_typedef_diff (const diff *diff) 
 Test if a diff node is a typedef_diff node.


const union_diff *  is_union_diff (const diff *diff) 
 Test if a diff node is a union_diff node.


const var_diff *  is_var_diff (const diff *diff) 
 Test if a diff node is about differences between variables.


diff_category  operator& (diff_category c1, diff_category c2) 

visiting_kind  operator& (visiting_kind l, visiting_kind r) 
 The overloaded and operator for visiting_kind.


diff_category &  operator&= (diff_category &c1, diff_category c2) 

ostream &  operator<< (ostream &o, diff_category c) 
 Serialize an instance of diff_category to an output stream.


diff_category  operator^ (diff_category c1, diff_category c2) 

diff_category  operator (diff_category c1, diff_category c2) 

visiting_kind  operator (visiting_kind l, visiting_kind r) 
 The overloaded or operator for visiting_kind.


diff_category &  operator= (diff_category &c1, diff_category c2) 

diff_category  operator~ (diff_category c) 

visiting_kind  operator~ (visiting_kind l) 
 The overloaded 'bit inversion' operator for visiting_kind.


const diff *  peel_fn_parm_diff (const diff *dif) 
 If a diff node is about changes between two function parameters get the diff node about changes between the types of the parameters.


const diff *  peel_pointer_diff (const diff *dif) 
 If a diff node is about changes between two pointer types, get the diff node about changes between the underlying (pointedto) types.


const diff *  peel_pointer_or_qualified_type_diff (const diff *dif) 
 If a diff node is about changes between two pointer, reference or qualified types, get the diff node about changes between the underlying types.


const diff *  peel_qualified_diff (const diff *dif) 
 If a diff node is about changes between two qualified types, get the diff node about changes between the underlying (nonqualified) types.


const diff *  peel_reference_diff (const diff *dif) 
 If a diff node is about changes between two reference types, get the diff node about changes between the underlying (pointedto) types.


const diff *  peel_typedef_diff (const diff *dif) 
 If a diff node is about changes between two typedef types, get the diff node about changes between the underlying types.


const diff *  peel_typedef_or_qualified_type_diff (const diff *dif) 
 If a diff node is about changes between two typedefs or qualified types, get the diff node about changes between the underlying types.


const diff *  peel_typedef_qualified_type_or_parameter_diff (const diff *dif) 
 If a diff node is about changes between two typedefs or qualified types, get the diff node about changes between the underlying types.


void  print_diff_tree (corpus_diff *diff_tree, std::ostream &out) 
 Emit a textual representation of a corpus_diff tree to an output stream.


void  print_diff_tree (corpus_diff_sptr diff_tree, std::ostream &o) 
 Emit a textual representation of a corpus_diff tree to an output stream.


void  print_diff_tree (diff *diff_tree, std::ostream &) 

void  print_diff_tree (diff_sptr diff_tree, std::ostream &o) 
 Emit a textual representation of a diff subtree to an output stream.


void  propagate_categories (corpus_diff *diff_tree) 
 Visit all the nodes of a given corpus tree. For each node that has a particular category set, propagate that category set up to its parent nodes.


void  propagate_categories (corpus_diff_sptr diff_tree) 
 Visit all the nodes of a given corpus tree. For each node that has a particular category set, propagate that category set up to its parent nodes.


void  propagate_categories (diff *diff_tree) 
 Visit all the nodes of a given subtree. For each node that has a particular category set, propagate that category set up to its parent nodes.


void  propagate_categories (diff_sptr diff_tree) 
 Visit all the nodes of a given subtree. For each node that has a particular category set, propagate that category set up to its parent nodes.

