cjaggerx 0.1.1

Rust bindings for the CJaggerX library
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

pub mod raw;

pub mod include {
    pub use crate::string::debug::raw::*;
}

pub struct DebugString {
    pub inner: include::RawString,
}

impl DebugString {

    pub fn new(value: std::ffi::CString) -> Self {
        Self {
            inner: include::RawString::new(value.as_ptr()),
        }
    }

    pub fn push_cstring(&mut self, value: std::ffi::CString) -> Result<(), Box<dyn std::error::Error>> {
        self.inner.push(value.as_ptr()).unwrap();
        Ok(())
    }

    pub fn push_cstr(&mut self, value: &std::ffi::CStr) -> Result<(), Box<dyn std::error::Error>> {
        self.inner.push(value.as_ptr()).unwrap();
        Ok(())
    }

    pub fn get_cstring(&self) -> Option<std::ffi::CString> {
        let res = self.inner.get().unwrap();
        Some(unsafe { std::ffi::CString::from_raw(res as *mut ::std::os::raw::c_char) })
    }

    pub fn destroy(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        self.inner.destroy().unwrap();
        Ok(())
    }

    pub fn get_cstr(&self) -> Option<&std::ffi::CStr> {
        let res = self.inner.get().unwrap();
        Some(unsafe { std::ffi::CStr::from_ptr(res) })
    }

    pub fn get_cstring_index(&self, index: usize) -> Option<std::ffi::CString> {
        let res = self.inner.get_index(index).unwrap();
        Some(unsafe { std::ffi::CString::from_raw(res as *mut ::std::os::raw::c_char) })
    }

    pub fn get_cstr_index(&self, index: usize) -> Option<&std::ffi::CStr> {
        let res = self.inner.get_index(index).unwrap();
        Some(unsafe { std::ffi::CStr::from_ptr(res) })
    }

    pub fn get_cstring_exact(&self, start: usize, end: usize) -> Option<std::ffi::CString> {
        let res = self.inner.get_exact(start, end).unwrap();
        Some(unsafe { std::ffi::CString::from_raw(res as *mut ::std::os::raw::c_char) })
    }

    pub fn get_cstr_exact(&self, start: usize, end: usize) -> Option<&std::ffi::CStr> {
        let res = self.inner.get_exact(start, end).unwrap();
        Some(unsafe { std::ffi::CStr::from_ptr(res) })
    }

    pub fn remove_cstring(&mut self, value: std::ffi::CString) -> Result<(), Box<dyn std::error::Error>> {
        self.inner.remove(value.as_ptr()).unwrap();
        Ok(())
    }

    pub fn remove_cstr(&mut self, value: &std::ffi::CStr) -> Result<(), Box<dyn std::error::Error>> {
        self.inner.remove(value.as_ptr()).unwrap();
        Ok(())
    }

    pub fn len(&self) -> Option<usize> {
        let res = self.inner.len().unwrap();
        Some(res)
    }

    pub fn size(&self) -> Option<usize> {
        let res = self.inner.size().unwrap();
        Some(res)
    }

    pub fn size_from(&self, index: usize) -> Option<usize> {
        let res = self.inner.size_from(index).unwrap();
        Some(res)
    }

    pub fn status(&self) -> Option<usize> {
        let res = self.inner.status().unwrap();
        Some(res)
    }

    pub fn replace(&mut self, start: usize, end: usize) -> Result<(), Box<dyn std::error::Error>> {
        self.inner.replace(start, end).unwrap();
        Ok(())
    }

    pub fn instance(&self) -> Option<DebugString> {
        let new = Self::default();
        Some(new)
    }
}

impl Default for DebugString {
    fn default() -> Self {
        Self {
            inner: include::RawString::new(std::ptr::null()),
        }
    }
}

impl Clone for DebugString {
    fn clone(&self) -> Self {
        Self {
            inner: self.inner.clone(),
        }
    }
    fn clone_from(&mut self, source: &Self) {
        self.inner = source.inner.clone();
    }
}

impl From<std::ffi::CString> for DebugString {
    fn from(value: std::ffi::CString) -> Self {
        Self {
            inner: include::RawString::new(value.as_ptr()),
        }
    }
}

impl From<&std::ffi::CStr> for DebugString {
    fn from(value: &std::ffi::CStr) -> Self {
        Self {
            inner: include::RawString::new(value.as_ptr()),
        }
    }
}

impl From<include::RawString> for DebugString {
    fn from(value: include::RawString) -> Self {
        Self {
            inner: value,
        }
    }
}

impl Copy for DebugString {}
unsafe impl Send for DebugString {}
unsafe impl Sync for DebugString {}