opendp_tooling 0.14.2-dev.20260419.1

Tooling for proc-macros and code generation.
Documentation 
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

use std::collections::HashMap;
use std::path::PathBuf;

use crate::Function;

use self::{
    c::{generate_Ropendp_h, generate_c_module, generate_lib_c},
    r::generate_r_module,
};

mod c;
pub(crate) mod r;

// some functions are called directly by R's C layer instead of through the codegen
const BLOCKLIST: &'static [&'static str] = &[
    // core
    "_error_free",
    "bool_free",
    "error_free",
    "_function_free",
    "_measurement_free",
    "_transformation_free",
    "_odometer_free",
    "_function_free",
    "_metric_free",
    "_measure_free",
    "_domain_free",
    // data
    "object_as_slice",
    "ffislice_of_anyobjectptrs",
    "slice_as_object",
    "str_free",
    "slice_free",
    "object_free",
    "extrinsic_object_free",
    "fill_bytes",
    "erfc",
    "debias_randomized_response_bitvec",
    // plugins
    "make_user_transformation",
    "make_user_measurement",
    "new_function",
    "new_queryable",
    "new_privacy_profile",
    "user_domain",
    "user_distance",
    "_make_transformation",
    "_make_measurement",
    "_new_pure_function",
    "_extrinsic_domain",
    "_extrinsic_domain_descriptor",
    "_extrinsic_metric_descriptor",
    "_extrinsic_distance",
    "_extrinsic_divergence",
    // polars
    "new_arrow_array",
    "series_domain",
    "_series_domain_get_element_domain",
    "_series_domain_get_name",
    "_series_domain_get_nullable",
    "categorical_domain",
    "enum_domain",
    "array_domain",
    "datetime_domain",
    "arrow_array_free",
    "dataframe_domain",
    "lazyframe_domain",
    "_lazyframe_domain_get_columns",
    "_lazyframe_domain_get_margin",
    "_lazyframe_domain_get_series_domain",
    "_lazyframe_from_domain",
    "with_margin",
    "wild_expr_domain",
    "_get_bound",
    "make_stable_lazyframe",
    "make_stable_expr",
    "make_private_lazyframe",
    "make_private_expr",
    "onceframe_collect",
    "onceframe_lazy",
    "summarize_polars_measurement",
    "change_one_id_distance",
    "_change_one_id_distance_get_identifier",
    "symmetric_id_distance",
    "_symmetric_id_distance_get_identifier",
    "frame_distance",
    "_frame_distance_get_inner_metric",
];

/// Top-level function to generate R bindings, including all modules.
///
/// Data passes from R -> C -> Rust -> C -> R.
/// This codegen handles the R and C portions.
pub fn generate_bindings(modules: &HashMap<String, Vec<Function>>) -> HashMap<PathBuf, String> {
    let hierarchy: HashMap<String, Vec<String>> =
        serde_json::from_str(&include_str!("../type_hierarchy.json")).unwrap();

    let r_bindings = modules
        .into_iter()
        .filter(|(name, _)| name.as_str() != "internal")
        .map(|(module_name, module)| {
            (
                PathBuf::from(format!("R/{}.R", module_name)),
                generate_r_module(module_name, module, &hierarchy),
            )
        })
        .collect::<HashMap<_, _>>();

    let mut c_bindings = modules
        .into_iter()
        .filter(|(name, _)| name.as_str() != "internal")
        .map(|(module_name, module)| {
            (
                PathBuf::from(format!("src/{}.c", module_name)),
                generate_c_module(module_name, module),
            )
        })
        .collect::<HashMap<_, _>>();

    c_bindings.insert(PathBuf::from("src/lib.c"), generate_lib_c(modules));
    c_bindings.insert(PathBuf::from("src/Ropendp.h"), generate_Ropendp_h(modules));

    (r_bindings.into_iter())
        .chain(c_bindings.into_iter())
        .collect()
}