ring-lang-rs 0.1.17

Rust bindings for the Ring programming language
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

use crate::ffi_types::{CString, c_char, c_int, c_uint};

use crate::ffi::{self, RingString};

#[inline]
pub fn ring_string_new(s: &[u8]) -> RingString {
    unsafe { ffi::ring_string_new(s.as_ptr() as *const c_char) }
}

/// String variant of [`ring_string_new`] - accepts `&str` instead of `&[u8]`.
#[inline]
pub fn ring_string_new_str(s: &str) -> RingString {
    if let Ok(cstr) = CString::new(s) {
        unsafe { ffi::ring_string_new(cstr.as_ptr()) }
    } else {
        unsafe { ffi::ring_string_new(b"\0".as_ptr() as *const c_char) }
    }
}

#[inline]
pub fn ring_string_new2(s: &[u8]) -> RingString {
    unsafe { ffi::ring_string_new2(s.as_ptr() as *const c_char, s.len() as c_uint) }
}

#[inline]
pub fn ring_string_delete(s: RingString) -> RingString {
    unsafe { ffi::ring_string_delete(s) }
}

#[inline]
pub fn ring_string_set(s: RingString, val: &[u8]) {
    unsafe { ffi::ring_string_set(s, val.as_ptr() as *const c_char) }
}

/// String variant of [`ring_string_set`].
#[inline]
pub fn ring_string_set_str(s: RingString, val: &str) {
    if let Ok(cstr) = CString::new(val) {
        unsafe { ffi::ring_string_set(s, cstr.as_ptr()) }
    }
}

#[inline]
pub fn ring_string_set2(s: RingString, val: &[u8]) {
    unsafe { ffi::ring_string_set2(s, val.as_ptr() as *const c_char, val.len() as c_uint) }
}

#[inline]
pub fn ring_string_add(s: RingString, val: &[u8]) {
    unsafe { ffi::ring_string_add(s, val.as_ptr() as *const c_char) }
}

/// String variant of [`ring_string_add`].
#[inline]
pub fn ring_string_add_str(s: RingString, val: &str) {
    if let Ok(cstr) = CString::new(val) {
        unsafe { ffi::ring_string_add(s, cstr.as_ptr()) }
    }
}

#[inline]
pub fn ring_string_add2(s: RingString, val: &[u8]) {
    unsafe { ffi::ring_string_add2(s, val.as_ptr() as *const c_char, val.len() as c_uint) }
}

#[inline]
pub fn ring_string_setfromint(s: RingString, x: c_int) {
    unsafe { ffi::ring_string_setfromint(s, x) }
}

#[inline]
pub fn ring_string_size(s: RingString) -> c_uint {
    unsafe { ffi::ring_string_size(s) }
}

#[inline]
pub fn ring_string_print(s: RingString) {
    unsafe { ffi::ring_string_print(s) }
}

#[inline]
pub fn ring_string_strdup(s: &[u8]) -> *mut c_char {
    unsafe { ffi::ring_string_strdup(s.as_ptr() as *const c_char) }
}

/// String variant of [`ring_string_strdup`].
#[inline]
pub fn ring_string_strdup_str(s: &str) -> *mut c_char {
    if let Ok(cstr) = CString::new(s) {
        unsafe { ffi::ring_string_strdup(cstr.as_ptr()) }
    } else {
        std::ptr::null_mut()
    }
}