package diffast-core

You can search for identifiers within the package.

in-package search v0.2.0

diffast-core
- Diffast_core
  - Adiff
  - Analyzing
    
    F
    
    Label
    
    Postprocessing
    
    mid_data
    
    tree_comparator
  - Astml
    
    Attr
  - Cache
  - Change_base
    
    F
    
    L
    
    c
    
    change_set
  - Charpool
  - Comparison
    
    c
    
    multiple_node_matches
    
    multiple_subtree_matches
    
    pairs
  - Const
  - Delta
    
    Edit
    
    seq
  - Delta_base
    
    Fmt
    
    Irr
    
    Rev
    
    edit_tbl
    
    node_tbl
    
    boundary_path
    
    path_c
  - Delta_common
  - Delta_format
    
    Format
    
    IrreversibleFormat
    
    ReversibleFormat
  - Delta_interpret
    
    interpreter
  - Delta_options
    
    c
  - Dirtree
    
    c
    
    diff_result
    
    node_data
    
    node_map
  - Dirtree_base
    
    c
    
    node_data
  - Edit
    
    formatters_base
    
    seq
    
    seq_base
  - Edit_base
    
    formatters_base
    
    seq_base
  - Editop
  - Engine_options
    
    c
  - Entity
  - Fact_base
    
    F
    
    L
    
    extractor_base
    
    fact_buffer_tbl
    
    fact_store
    
    separate_fact_buffer_tbl
    
    unified_fact_buffer_tbl
  - Fact_options
    
    c
  - Flattreediff
  - GIDfragment
    
    c
  - Info
  - Key
  - Lang
    
    c
    
    lang_t
    
    make_null_tree_patcher
    
    tree_comparator
    
    tree_patcher
  - Lang_base
    
    c
    
    lang_t
    
    tree_builder
    
    tree_factory
  - Misc
    
    Tbl1
    
    Tbl2
    
    Tbl3
    
    Tbl4
    
    counter
    
    stopwatch
  - Moveid
    
    generator
  - Node
    
    M
    
    Tbl
  - Node_mapping
    
    Json
    
    c
  - Options
    
    c
  - Parser_options
    
    c
  - Postprocessing
    
    F
    
    Label
    
    mid_data
  - Proximity
    
    node_proximity
  - Pruned
    
    nodes
  - Sites
    
    Plugins
    
    Lang_specs
    
    Langs
    
    Sites
  - Sourcecode
    
    Tree
    
    L
    
    c
    
    node_data
    
    node_maker
    
    ordinal_tbl
    
    stack
    
    visitor
  - Spec
    
    LABEL_T
    
    nmapping_t
    
    node_data_t
    
    npairs_t
    
    tree_t
  - Spec_base
    
    OutChannel
    
    node_data_t_shared
    
    tree_factory_t
    
    tree_t_shared
  - Stat
    
    Dir
    
    File
  - Treediff
  - Triple
    
    buffer
    
    buffer_base
    
    buffer_directory
    
    buffer_odbc
    
    buffer_virtuoso
    
    dumper
    
    dumper_gen

Legend:
Library
Module
Module type
Parameter
Class
Class type

constraint 'a = Nodetbl.key


  constraint
    'b =
    < _initial_size : int
    ; fast_scan_whole_initial : 
      (< data : < to_be_notified : bool.. >.. > -> unit) ->
      'c
    ; fast_scan_whole_initial_subtree : 
      Diffast_core.Node_mapping.Nodetbl.key ->
      (Diffast_core.Node_mapping.Nodetbl.key -> unit) ->
      'd
    ; fast_whole_initial_subtree_size : 
      Diffast_core.Node_mapping.Nodetbl.key ->
      int
    ; get : 
      Diffast_misc.Otree.index ->
      < collapse_locked : bool
      ; data : 
        < _anonymized_label : 'f
        ; _stripped_label : 'g
        ; digest : 'h
        ; eq : 'e -> bool
        ; equals : 'e -> bool
        ; get_name : 'i
        ; weight : int.. > as 'e
      ; gindex : GI.t
      ; is_collapsed : bool
      ; path : < equals : 'j -> bool.. > as 'j.. >
    ; get_digest : 'a -> Diffast_misc.Xhash.t
    ; get_units_to_be_notified : Nodetbl.key list
    ; ignored_regions : segment list
    ; in_subtree_mutually : 
      Diffast_core.Node_mapping.Nodetbl.key ->
      Diffast_core.Node_mapping.Nodetbl.key ->
      bool
    ; init : 'k
    ; initial_ancestor_nodeposs : 
      Diffast_core.Node_mapping.Nodetbl.key ->
      (Diffast_core.Node_mapping.Nodetbl.key * int) list
    ; initial_ancestor_nodes : Nodetbl.key -> Nodetbl.key list
    ; initial_leftmost : 
      Diffast_core__Node_mapping.node_t ->
      Diffast_core__Node_mapping.node_t
    ; initial_subtree_mem : 'a -> 'a -> bool
    ; is_initial_ancestor : 
      Diffast_core.Node_mapping.Nodetbl.key ->
      Diffast_core.Node_mapping.Nodetbl.key ->
      bool
    ; iter_initial_ancestor_nodes : 'a -> (Nodetbl.key -> unit) -> unit
    ; keynodes : Diffast_misc.Otree.index list
    ; leftmost : Diffast_misc.Otree.index -> Diffast_misc.Otree.index
    ; make_subtree_copy : ?find_hook:('a -> 'a -> unit) -> 'a -> 'b
    ; mem_uid : Diffast_misc.UID.t -> bool
    ; misparsed_regions : segment list
    ; preorder_scan_whole_initial_subtree : 'a -> ('a -> unit) -> 'l
    ; prune_cluster : Nodetbl.key -> Nodetbl.key list -> unit
    ; recover_true_children : initial_only:bool -> unit -> unit
    ; root : Diffast_core.Node_mapping.Nodetbl.key
    ; scan_cluster : (Nodetbl.key * Nodetbl.key list) -> ('a -> unit) -> unit
    ; scan_initial_cluster : ('a * 'a list) -> ('a -> unit) -> unit
    ; scan_whole_initial : 
      (< data : < binding : Diffast_core.Comparison.B.t.. >.. > -> unit) ->
      unit
    ; search_node_by_gindex : GI.t -> Diffast_core__Node_mapping.node_t
    ; search_node_by_uid : 
      Diffast_misc.UID.t ->
      Diffast_core.Node_mapping.Nodetbl.key
    ; size : int
    ; size_of_initial_cluster : ('a * 'a list) -> int
    ; to_dot : ?mklab:(Nodetbl.key -> string) -> 'm list -> Buffer.t
    ; to_dot_initial : ?mklab:(Nodetbl.key -> string) -> 'n list -> Buffer.t.. >

val mutable del_tbl : 'a t Nodetbl.t

val mutable ins_tbl : 'a t Nodetbl.t

val mutable rel1_tbl : 'a t Nodetbl.t

val mutable rel2_tbl : 'a t Nodetbl.t

val mutable mov1_tbl : 'a t Nodetbl.t

val mutable mov2_tbl : 'a t Nodetbl.t

val mutable tables : 'a t Nodetbl.t list

val mutable mov_gr_tbl : (MID.t, move_id) Hashtbl.t

val mutable mov_gr_mem_tbl : (move_id, 'a t list) Hashtbl.t

val mutable list : 'a t list

val mutable indivisible_moves : MID.t Xset.t

method _init : unit

method _indivisible_moves : MID.t Xset.t

method _set_indivisible_moves : MID.t Xset.t -> unit

method _set_mov_gr_tbl : (MID.t, move_id) Hashtbl.t -> unit

method _set_mov_gr_mem_tbl : (move_id, 'a t list) Hashtbl.t -> unit

method add_indivisible_move : MID.t -> unit

method remove_indivisible_move : MID.t -> unit

method is_indivisible_move : MID.t -> bool

method _mov_gr_tbl : (MID.t, move_id) Hashtbl.t

method _mov_gr_mem_tbl : (move_id, 'a t list) Hashtbl.t

method find_mov_gr : MID.t -> move_id

method find_mov_gr_mems : move_id -> 'a t list

method _del_tbl : 'a t Nodetbl.t

method _ins_tbl : 'a t Nodetbl.t

method _rel1_tbl : 'a t Nodetbl.t

method _rel2_tbl : 'a t Nodetbl.t

method _mov1_tbl : 'a t Nodetbl.t

method _mov2_tbl : 'a t Nodetbl.t

method content : 'a t list

method _set_del_tbl : 'a t Nodetbl.t -> unit

method _set_ins_tbl : 'a t Nodetbl.t -> unit

method _set_rel1_tbl : 'a t Nodetbl.t -> unit

method _set_rel2_tbl : 'a t Nodetbl.t -> unit

method _set_mov1_tbl : 'a t Nodetbl.t -> unit

method _set_mov2_tbl : 'a t Nodetbl.t -> unit

method copy : ('a, 'b) seq_base

method private edit_tbl_to_list : 'a t Nodetbl.t -> 'a t list

method clear : unit

method is_consistent_with : 'a t -> bool

method add_edit : 'a t -> unit

method add_edits : 'o -> unit

method remove_edit : 'a t -> unit

method remove_del : Nodetbl.key -> unit

method remove_ins : Nodetbl.key -> unit

method is_empty : bool

method iter : ('a t -> unit) -> unit

method iter_deletes_and_inserts : ('a t -> unit) -> unit

method iter_deletes : ('a t -> unit) -> unit

method iter_inserts : ('a t -> unit) -> unit

method iter_moves : ('a t -> unit) -> unit

method iter_moves_topdown : ('a t -> unit) -> unit

method iter_moves_bottomup : ('a t -> unit) -> unit

method iter_relabels : ('a t -> unit) -> unit

method relabel_exists : ('a t -> bool) -> bool

method get_ndeletes : int

method get_ninserts : int

method get_nmoves : int

method get_nmoves_of_move_id_filt : (Nodetbl.key -> Nodetbl.key -> bool) ->
  move_id ->
  int

method get_nmoves_of_move_id : move_id -> int

method get_nmove_groups : int

method get_nrelabels : int

method get_nedits : int

method size : int

method get_ndeleted_nodes : int

method get_ninserted_nodes : int

method get_nmoved_nodes : ?minsize:int -> unit -> int

method get_nrelabeled_nodes : ?orig:bool -> unit -> int

method get_nedited_nodes : int

method get_nmoved_and_relabeled_nodes : ?minsize:int ->
  ?orig:bool ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  int

method get_moved_nodes : 'b -> Diffast_core.Node_mapping.Nodetbl.key Xset.t

method _get_moved_nodes_of_move_id : move_id -> Nodetbl.key Xset.t

method private setup_multi_mov_gr_tbl : Diffast_core.Node_mapping.Nodetbl.key
                                          Diffast_core.Node_mapping.c ->
  ('a -> bool) ->
  unit

method finalize : Diffast_core.Node_mapping.Nodetbl.key
                    Diffast_core.Node_mapping.c ->
  ('a -> bool) ->
  unit

method to_string : string

method to_string_gid : string

method private _find12 : ('a t Nodetbl.t * 'a t Nodetbl.t) list ->
  'a ->
  'a ->
  'a t list

method find12 : 'a -> 'a -> 'a t list

method find21 : 'a -> 'a -> 'a t list

method find_mov12 : 'a -> 'a -> Nodetbl.key t

method find_mid12 : 'a -> 'a -> move_id

method find_rel12 : 'a -> 'a -> 'a t

method find_maps_of_relabels : ('a * 'a) list

method find1 : 'a -> 'a t list

method find_del : 'a -> 'a t

method find2 : 'a -> 'a t list

method find_ins : 'a -> 'a t

method find_mov1 : Nodetbl.key -> 'a t

method find_mov2 : Nodetbl.key -> 'a t

method mem1 : 'a -> bool

method mem2 : 'a -> bool

method mem_del : 'a -> bool

method mem_ins : 'a -> bool

method mem_mov12 : 'a -> 'a -> bool

method mem_mov21 : 'a -> 'a -> bool

method mem_mov1 : 'a -> bool

method mem_mov2 : 'a -> bool

method mem_rel12 : 'a -> 'a -> bool

method mem_rel1 : 'a -> bool

method mem_rel2 : 'a -> bool

method mem12 : 'a -> 'a -> bool

method sort_topdown : unit

method sync : unit

method iter_topdown : ('a t -> unit) -> unit

method filter : ('a t -> bool) -> unit

method filter_deletes : ('a t -> bool) -> unit

method filter_inserts : ('a t -> bool) -> unit

method filter_relabels : ('a t -> bool) -> unit

method filter_moves : ('a t -> bool) -> unit

method get_line_align : 'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  line_match list

method dump_line_align_ch : formatters:formatters_base ->
  line_match list ->
  out_channel ->
  unit

method dump_diff_simple : ?line_align:line_match list ->
  'b ->
  'b ->
  string ->
  unit

method dump_diff_simple_ch : ?line_align:line_match list ->
  'b ->
  'b ->
  out_channel ->
  unit

method dump_diff_json : ?line_align:line_match list ->
  'b ->
  'b ->
  string ->
  unit

method dump_diff_json_ch : ?line_align:line_match list ->
  'b ->
  'b ->
  out_channel ->
  unit

method private dump_diff_ch : header:string ->
  footer:string ->
  formatters:formatters_base ->
  ?line_align:line_match list ->
  ?minimal:bool ->
  'b ->
  'b ->
  out_channel ->
  unit

method dump_gdiff_json : ?comp:Compression.c -> 'b -> 'b -> string -> unit

method dump_diff_info : string -> 'b -> 'b -> unit

method dump_diff_info_ch : 'b -> 'b -> out_channel -> unit

method get_diff_summary : 'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  (string ref * 'a t list ref * int ref) Nodetbl.t
  * (string ref * 'a t list ref * int ref) Nodetbl.t
  * Nodetbl.key list
  * Nodetbl.key list

method dump_diff_summary : string ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  unit

method dump_diff_summary_ch : 'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  out_channel ->
  unit

method get_spm : Diffast_core.Node_mapping.Nodetbl.key
                   Diffast_core.Node_mapping.c ->
  int

method get_diff_stat : 'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  Diffast_core.Stat.File.diff_stat

method dump_diff_stat_ch : ?short:bool ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  out_channel ->
  unit

method dump_diff_stat : ?short:bool ->
  string ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  unit

method show_diff_stat : ?short:bool ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  unit

method private get_cluster : (unit -> int) ->
  string ->
  string ->
  string ->
  'b ->
  'a Diffast_core.Info.t ->
  'a Diffast_core.Info.t list ref ->
  Buffer.t

method dump_dot_ch1 : ?final:bool ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  out_channel ->
  unit

method dump_dot_ch2 : ?final:bool ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  out_channel ->
  unit

method dump_dot1 : ?final:bool ->
  string ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  unit

method dump_dot2 : ?final:bool ->
  string ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  unit

method check : 'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  bool

method remove_unmapped : 'b -> 'b -> Nodetbl.key list * Nodetbl.key list

method ungroup : 'b -> 'b -> unit

method private get_non_ghost_children : 'a -> 'a list

method cleanup_ghost : 'b -> 'b -> unit

method shrink_moves_rp : (Diffast_core.Node_mapping.Nodetbl.key, 'b)
                           Diffast_core.Comparison.c ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  move_region_tbl_t ->
  (move_id, 'a t list) Hashtbl.t

method shrink_moves : (Diffast_core.Node_mapping.Nodetbl.key, 'b)
                        Diffast_core.Comparison.c ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  move_region_tbl_t ->
  (MID.t, 'a t list) Hashtbl.t ->
  unit

method is_crossing_with_untouched : ?full_scan:bool ->
  ?mask:
    (Diffast_core.Node_mapping.Nodetbl.key
     * Diffast_core.Node_mapping.Nodetbl.key)
      list ->
  ?incompatible_only:bool ->
  ?weak:bool ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  Diffast_core.Node_mapping.Nodetbl.key ->
  Diffast_core.Node_mapping.Nodetbl.key ->
  bool

method dump_delta : ?extra_ns_decls:(string * string) list ->
  ?info_file_path:string ->
  'b ->
  'b ->
  Diffast_core.Node_mapping.Nodetbl.key Diffast_core.Node_mapping.c ->
  'o ->
  string ->
  unit