This file is indexed.

/usr/lib/ocaml/galax/nodeid.mli is in libgalax-ocaml-dev 1.1-12.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
(***********************************************************************)
(*                                                                     *)
(*                                 GALAX                               *)
(*                              XQuery Engine                          *)
(*                                                                     *)
(*  Copyright 2001-2007.                                               *)
(*  Distributed only by permission.                                    *)
(*                                                                     *)
(***********************************************************************)

(* $Id: nodeid.mli,v 1.4 2007/02/01 22:08:46 simeon Exp $ *)

(* Module: Nodeid
   Description:
     This module implements the node-id and document order support
     that must be common to all implementations connected to Galax. It
     also implements the main nodeid type which is used within the
     Galax query processor.
*)

(*************************)
(* Generic id structures *)
(*************************)

(* Common components *)

type implemid  = int
type docid     = int

(* gId = group identifier, mId = member identifier. *)
type int64_pair = {gId: int64; mId: int64}

type preorder  = int
type postorder = int
type large_preorder = int64_pair

(* Document order *)

type prepostint_docorder  = docid * preorder * postorder
type preint_docorder      = docid * preorder
type postint_docorder     = docid * postorder
type pre_intpair_docorder = docid * large_preorder

type partial_docorder =
  | PrePostInt of prepostint_docorder
  | PreInt of preint_docorder
  | PreIntPair of pre_intpair_docorder

type docorder = (implemid * partial_docorder)

(* Node identity *)

type partial_nodeid =
  | IntId of docid * int
  | IntPairId of docid * int64_pair

type nodeid = (implemid * partial_nodeid)


(*****************************************)
(* Generic access operations on node-ids *)
(*****************************************)


val get_implemid  : docorder -> implemid          (* Get the implementation id *)
val get_docid     : docorder -> docid             (* Get the document id *)
val get_partialid : docorder -> partial_docorder  (* Get the node-id internal *)


(******************************)
(* Node comparison operations *)
(******************************)

val nodeid_is         : nodeid -> nodeid -> bool      (* node equality *)

val docorder_precedes : docorder -> docorder -> bool  (* preceding *)
val docorder_follows  : docorder -> docorder -> bool  (* following *)
val docorder_compare  : docorder -> docorder -> int   (* Document order compare function *)

(* XPath semantics of foll/prec/anc/desc *)
val is_descendant_xpath : docorder -> docorder -> bool
val is_ancestor_xpath   : docorder -> docorder -> bool
val is_preceding_xpath  : docorder -> docorder -> bool
val is_following_xpath  : docorder -> docorder -> bool


(************)
(* Printing *)
(************)

val string_of_docorder : docorder -> string


(*************************************)
(* Generates a new implementation id *)
(*************************************)

val new_implemid  : string -> implemid
    (* The input string should be a short-name for the implementation *)


(*****************************)
(* Generic doc id generation *)
(*****************************)

type docid_gen

val build_docid_gen : unit -> docid_gen

val new_docid : docid_gen -> docid

(* Build node id from a pre/post pair *)

val build_docorder_from_pre_post : implemid -> docid -> (preorder * postorder) -> docorder
val merge_docorder_from_pre_post : preint_docorder -> postint_docorder -> prepostint_docorder

(* Special node ids *)

val min_preorder  : preorder
val min_postorder : postorder

val max_preorder  : preorder
val max_postorder : postorder

val large_preorder_to_big_int : large_preorder -> Big_int.big_int 
val big_int_to_large_preorder : Big_int.big_int -> large_preorder

val big_int_pair_of_docorder : docorder -> (Big_int.big_int * Big_int.big_int)