1use std::ffi::CString;
8
9use crate::error::{Error, Result};
10use crate::{Environment, ffi};
11
12#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14#[repr(u32)]
15pub enum SaveScope {
16 Local = 0,
18 Visible = 1,
20}
21
22#[derive(Debug, Clone, Copy, PartialEq, Eq)]
24pub enum PersistenceError {
25 SaveConstructs,
28 BinarySaveConstructs,
30 BinaryLoadConstructs,
32 SaveFacts,
34 LoadFacts,
36 BinarySaveFacts,
38 BinaryLoadFacts,
40 SaveInstances,
42 LoadInstances,
44 RestoreInstances,
46 BinarySaveInstances,
48 BinaryLoadInstances,
50}
51
52fn count(result: std::ffi::c_long, operation: PersistenceError) -> Result<usize> {
53 usize::try_from(result).map_err(|_| Error::Persistence(operation))
54}
55
56impl Environment {
57 pub fn save_constructs(&self, path: &str) -> Result<()> {
59 let path = CString::new(path)?;
60 unsafe { ffi::Save(self.raw.as_ptr(), path.as_ptr()) }
61 .then_some(())
62 .ok_or(Error::Persistence(PersistenceError::SaveConstructs))
63 }
64
65 pub fn binary_save_constructs(&self, path: &str) -> Result<()> {
67 let path = CString::new(path)?;
68 unsafe { ffi::Bsave(self.raw.as_ptr(), path.as_ptr()) }
69 .then_some(())
70 .ok_or(Error::Persistence(PersistenceError::BinarySaveConstructs))
71 }
72
73 pub fn binary_load_constructs(&mut self, path: &str) -> Result<()> {
75 let path = CString::new(path)?;
76 unsafe { ffi::Bload(self.raw.as_ptr(), path.as_ptr()) }
77 .then_some(())
78 .ok_or(Error::Persistence(PersistenceError::BinaryLoadConstructs))
79 }
80
81 pub fn constructs_are_binary_loaded(&self) -> bool {
86 unsafe { ffi::Bloaded(self.raw.as_ptr()) }
87 }
88
89 pub fn save_facts(&self, path: &str, scope: SaveScope) -> Result<usize> {
91 let path = CString::new(path)?;
92 count(
93 unsafe { ffi::SaveFacts(self.raw.as_ptr(), path.as_ptr(), scope as u32) },
94 PersistenceError::SaveFacts,
95 )
96 }
97
98 pub fn load_facts(&mut self, path: &str) -> Result<usize> {
104 let path = CString::new(path)?;
105 count(
106 unsafe { ffi::LoadFacts(self.raw.as_ptr(), path.as_ptr()) },
107 PersistenceError::LoadFacts,
108 )
109 }
110
111 pub fn load_facts_str(&mut self, source: &str) -> Result<usize> {
113 let source = CString::new(source)?;
114 count(
115 unsafe {
116 ffi::LoadFactsFromString(
117 self.raw.as_ptr(),
118 source.as_ptr(),
119 source.as_bytes().len(),
120 )
121 },
122 PersistenceError::LoadFacts,
123 )
124 }
125
126 pub fn binary_save_facts(&self, path: &str, scope: SaveScope) -> Result<usize> {
129 let path = CString::new(path)?;
130 count(
131 unsafe { ffi::BinarySaveFacts(self.raw.as_ptr(), path.as_ptr(), scope as u32) },
132 PersistenceError::BinarySaveFacts,
133 )
134 }
135
136 pub fn binary_load_facts(&mut self, path: &str) -> Result<usize> {
138 let path = CString::new(path)?;
139 count(
140 unsafe { ffi::BinaryLoadFacts(self.raw.as_ptr(), path.as_ptr()) },
141 PersistenceError::BinaryLoadFacts,
142 )
143 }
144
145 pub fn save_instances(&self, path: &str, scope: SaveScope) -> Result<usize> {
147 let path = CString::new(path)?;
148 count(
149 unsafe { ffi::SaveInstances(self.raw.as_ptr(), path.as_ptr(), scope as u32) },
150 PersistenceError::SaveInstances,
151 )
152 }
153
154 pub fn load_instances(&mut self, path: &str) -> Result<usize> {
159 let path = CString::new(path)?;
160 count(
161 unsafe { ffi::LoadInstances(self.raw.as_ptr(), path.as_ptr()) },
162 PersistenceError::LoadInstances,
163 )
164 }
165
166 pub fn load_instances_str(&mut self, source: &str) -> Result<usize> {
169 let source = CString::new(source)?;
170 count(
171 unsafe {
172 ffi::LoadInstancesFromString(
173 self.raw.as_ptr(),
174 source.as_ptr(),
175 source.as_bytes().len(),
176 )
177 },
178 PersistenceError::LoadInstances,
179 )
180 }
181
182 pub fn restore_instances(&mut self, path: &str) -> Result<usize> {
188 let path = CString::new(path)?;
189 count(
190 unsafe { ffi::RestoreInstances(self.raw.as_ptr(), path.as_ptr()) },
191 PersistenceError::RestoreInstances,
192 )
193 }
194
195 pub fn restore_instances_str(&mut self, source: &str) -> Result<usize> {
198 let source = CString::new(source)?;
199 count(
200 unsafe {
201 ffi::RestoreInstancesFromString(
202 self.raw.as_ptr(),
203 source.as_ptr(),
204 source.as_bytes().len(),
205 )
206 },
207 PersistenceError::RestoreInstances,
208 )
209 }
210
211 pub fn binary_save_instances(&self, path: &str, scope: SaveScope) -> Result<usize> {
213 let path = CString::new(path)?;
214 count(
215 unsafe { ffi::BinarySaveInstances(self.raw.as_ptr(), path.as_ptr(), scope as u32) },
216 PersistenceError::BinarySaveInstances,
217 )
218 }
219
220 pub fn binary_load_instances(&mut self, path: &str) -> Result<usize> {
222 let path = CString::new(path)?;
223 count(
224 unsafe { ffi::BinaryLoadInstances(self.raw.as_ptr(), path.as_ptr()) },
225 PersistenceError::BinaryLoadInstances,
226 )
227 }
228}