rdkit 0.4.12

High level RDKit functionality for rust
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
127
128

use cxx::SharedPtr;

use crate::{ROMol, RWMol};

pub struct CleanupParameters {
    pub(crate) ptr: SharedPtr<rdkit_sys::mol_standardize_ffi::CleanupParameters>,
}

impl Default for CleanupParameters {
    fn default() -> Self {
        CleanupParameters {
            ptr: rdkit_sys::mol_standardize_ffi::default_cleanup_parameters(),
        }
    }
}

pub struct TautomerEnumerator {
    pub(crate) ptr: SharedPtr<rdkit_sys::mol_standardize_ffi::TautomerEnumerator>,
}

impl Default for TautomerEnumerator {
    fn default() -> Self {
        TautomerEnumerator::new()
    }
}

impl TautomerEnumerator {
    pub fn new() -> Self {
        let ptr = rdkit_sys::mol_standardize_ffi::tautomer_enumerator();

        TautomerEnumerator { ptr }
    }

    pub fn enumerate(&self, ro_mol: &crate::ROMol) -> TautomerEnumeratorResult {
        let t_enumerator_result =
            rdkit_sys::mol_standardize_ffi::tautomer_enumerate(&self.ptr, &ro_mol.ptr);
        let size = rdkit_sys::mol_standardize_ffi::tautomer_enumerator_result_tautomers_size(
            &t_enumerator_result,
        ) as usize;

        TautomerEnumeratorResult {
            pos: 0,
            size,
            t_enumerator_result,
        }
    }

    pub fn canonicalize(&self, ro_mol: &crate::ROMol) -> Result<crate::ROMol, cxx::Exception> {
        let canonical_mol_ptr = rdkit_sys::mol_standardize_ffi::tautomer_enumerator_canonicalize(
            &self.ptr,
            &ro_mol.ptr,
        );
        Ok(crate::ROMol {
            ptr: canonical_mol_ptr?,
        })
    }
}

pub struct TautomerEnumeratorResult {
    // t_enumerator: SharedPtr<TautomerEnumerator>,
    pub(crate) t_enumerator_result:
        SharedPtr<rdkit_sys::mol_standardize_ffi::TautomerEnumeratorResult>,
    pos: usize,
    size: usize,
}

impl Iterator for TautomerEnumeratorResult {
    type Item = crate::ROMol;

    fn next(&mut self) -> Option<Self::Item> {
        if self.pos >= self.size {
            None
        } else {
            let next = rdkit_sys::mol_standardize_ffi::tautomer_enumerator_result_tautomers_at(
                &self.t_enumerator_result,
                self.pos,
            );
            if next.is_null() {
                log::warn!(
                    "got a null ptr from tautomer_enumerator_result->at({})",
                    self.pos
                );
                None
            } else {
                self.pos += 1;
                Some(crate::ROMol { ptr: next })
            }
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let size = rdkit_sys::mol_standardize_ffi::tautomer_enumerator_result_tautomers_size(
            &self.t_enumerator_result,
        );
        (size as usize, Some(size as usize))
    }
}

pub fn fragment_parent(
    rw_mol: &RWMol,
    cleanup_params: &CleanupParameters,
    skip_standardize: bool,
) -> RWMol {
    let ptr = rdkit_sys::mol_standardize_ffi::fragment_parent(
        &rw_mol.ptr,
        &cleanup_params.ptr,
        skip_standardize,
    );
    RWMol { ptr }
}

pub struct Uncharger {
    pub(crate) ptr: SharedPtr<rdkit_sys::mol_standardize_ffi::Uncharger>,
}

impl Uncharger {
    pub fn new(standardize: bool) -> Self {
        Uncharger {
            ptr: rdkit_sys::mol_standardize_ffi::new_uncharger(standardize),
        }
    }

    pub fn uncharge(&self, mol: &ROMol) -> ROMol {
        ROMol {
            ptr: rdkit_sys::mol_standardize_ffi::uncharger_uncharge(&self.ptr, &mol.ptr),
        }
    }
}