Debian Codegraph @

modules/lsp-runtime-lib/src/main/io/OutSequence.cpp

raw
1 /*
2 * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2025 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 18 июн. 2018 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/io/charset.h>
23 #include <lsp-plug.in/io/StdioFile.h>
24 #include <lsp-plug.in/io/NativeFile.h>
25 #include <lsp-plug.in/io/OutFileStream.h>
26 #include <lsp-plug.in/io/OutSequence.h>
27
28 #include <errno.h>
29
30 #define CBUF_SIZE 0x1000
31 #define BBUF_SIZE 0x4000
32
33 namespace lsp
34 {
35 namespace io
36 {
37 OutSequence::OutSequence()
38 {
39 pOS = NULL;
40 nWrapFlags = 0;
41 }
42
43 OutSequence::~OutSequence()
44 {
45 // Close file descriptor
46 if (pOS != NULL)
47 {
48 flush_buffer_internal(true);
49
50 if (nWrapFlags & WRAP_CLOSE)
51 pOS->close();
52 if (nWrapFlags & WRAP_DELETE)
53 delete pOS;
54 pOS = NULL;
55 }
56 nWrapFlags = 0;
57
58 // Close encoder
59 sEncoder.close();
60 }
61
62 status_t OutSequence::close()
63 {
64 status_t res = STATUS_OK, tres;
65
66 // Close file descriptor
67 if (pOS != NULL)
68 {
69 // Flush buffers
70 res = flush();
71
72 // Perform close
73 if (nWrapFlags & WRAP_CLOSE)
74 {
75 tres = pOS->close();
76 if (res == STATUS_OK)
77 res = tres;
78 }
79 if (nWrapFlags & WRAP_DELETE)
80 delete pOS;
81 pOS = NULL;
82 }
83 nWrapFlags = 0;
84
85 // Close encoder
86 sEncoder.close();
87
88 // Return result
89 return set_error(res);
90 }
91
92 status_t OutSequence::wrap(FILE *fd, bool close, const char *charset)
93 {
94 if (pOS != NULL)
95 return set_error(STATUS_BAD_STATE);
96 else if (fd == NULL)
97 return set_error(STATUS_BAD_ARGUMENTS);
98
99 OutFileStream *f = new OutFileStream();
100 if (f == NULL)
101 return set_error(STATUS_NO_MEM);
102 status_t res = f->wrap(fd, close);
103 if (res != STATUS_OK)
104 {
105 f->close();
106 delete f;
107 return set_error(res);
108 }
109
110 res = wrap(f, WRAP_CLOSE | WRAP_DELETE, charset);
111 if (res != STATUS_OK)
112 {
113 f->close();
114 delete f;
115 }
116
117 return set_error(STATUS_OK);
118 }
119
120 status_t OutSequence::wrap_native(fhandle_t fd, bool close, const char *charset)
121 {
122 if (pOS != NULL)
123 return set_error(STATUS_BAD_STATE);
124
125 OutFileStream *f = new OutFileStream();
126 if (f == NULL)
127 return set_error(STATUS_NO_MEM);
128 status_t res = f->wrap_native(fd, close);
129 if (res != STATUS_OK)
130 {
131 f->close();
132 delete f;
133 return set_error(res);
134 }
135
136 res = wrap(f, WRAP_CLOSE | WRAP_DELETE, charset);
137 if (res != STATUS_OK)
138 {
139 f->close();
140 delete f;
141 }
142
143 return set_error(STATUS_OK);
144 }
145
146 status_t OutSequence::wrap(File *fd, size_t flags, const char *charset)
147 {
148 if (pOS != NULL)
149 return set_error(STATUS_BAD_STATE);
150 else if (fd == NULL)
151 return set_error(STATUS_BAD_ARGUMENTS);
152
153 OutFileStream *f = new OutFileStream();
154 if (f == NULL)
155 return set_error(STATUS_NO_MEM);
156 status_t res = f->wrap(fd, flags);
157 if (res != STATUS_OK)
158 {
159 f->close();
160 delete f;
161 return set_error(res);
162 }
163
164 res = wrap(f, WRAP_CLOSE | WRAP_DELETE, charset);
165 if (res != STATUS_OK)
166 {
167 f->close();
168 delete f;
169 }
170
171 return set_error(STATUS_OK);
172 }
173
174 status_t OutSequence::wrap(IOutStream *os, size_t flags, const char *charset)
175 {
176 if (pOS != NULL)
177 return set_error(STATUS_BAD_STATE);
178 else if (os == NULL)
179 return set_error(STATUS_BAD_ARGUMENTS);
180
181 // Initialize decoder
182 status_t res = sEncoder.init(charset);
183 if (res != STATUS_OK)
184 {
185 sEncoder.close();
186 return set_error(res);
187 }
188
189 // Store pointers
190 pOS = os;
191 nWrapFlags = flags;
192
193 return set_error(STATUS_OK);
194 }
195
196 status_t OutSequence::open(const char *path, size_t mode, const char *charset)
197 {
198 if (pOS != NULL)
199 return set_error(STATUS_BAD_STATE);
200 else if (path == NULL)
201 return set_error(STATUS_BAD_ARGUMENTS);
202
203 LSPString tmp;
204 if (!tmp.set_utf8(path))
205 return set_error(STATUS_NO_MEM);
206 return open(&tmp, mode, charset);
207 }
208
209 status_t OutSequence::open(const LSPString *path, size_t mode, const char *charset)
210 {
211 if (pOS != NULL)
212 return set_error(STATUS_BAD_STATE);
213 else if (path == NULL)
214 return set_error(STATUS_BAD_ARGUMENTS);
215
216 OutFileStream *f = new OutFileStream();
217 if (f == NULL)
218 return set_error(STATUS_NO_MEM);
219 status_t res = f->open(path, mode);
220 if (res != STATUS_OK)
221 {
222 f->close();
223 delete f;
224 return set_error(res);
225 }
226
227 res = wrap(f, WRAP_CLOSE | WRAP_DELETE, charset);
228 if (res != STATUS_OK)
229 {
230 f->close();
231 delete f;
232 return set_error(res);
233 }
234
235 return set_error(STATUS_OK);
236 }
237
238 status_t OutSequence::open(const Path *path, size_t mode, const char *charset)
239 {
240 return open(path->as_string(), mode, charset);
241 }
242
243 status_t OutSequence::flush_buffer_internal(bool force)
244 {
245 // Flush all character data to stream
246 ssize_t fetch;
247 do
248 {
249 fetch = sEncoder.fetch(pOS);
250 } while (fetch > 0);
251
252 if ((fetch < 0) && (fetch != -STATUS_EOF))
253 return set_error(status_t(-fetch));
254
255 return set_error((force) ? pOS->flush() : STATUS_OK);
256 }
257
258 status_t OutSequence::write(lsp_wchar_t c)
259 {
260 if (pOS == NULL)
261 return set_error(STATUS_CLOSED);
262
263 ssize_t filled = sEncoder.fill(c);
264 if (filled > 0)
265 return set_error(STATUS_OK);
266
267 status_t res = flush_buffer_internal(false);
268 if (res != STATUS_OK)
269 return set_error(res);
270
271 filled = sEncoder.fill(c);
272 return set_error((filled > 0) ? STATUS_OK : STATUS_UNKNOWN_ERR);
273 }
274
275 status_t OutSequence::write(const lsp_wchar_t *c, size_t count)
276 {
277 if (pOS == NULL)
278 return set_error(STATUS_CLOSED);
279
280 size_t written = 0;
281
282 while (written < count)
283 {
284 // Try to fill data
285 ssize_t filled = sEncoder.fill(c, count - written);
286 if (filled > 0)
287 {
288 c += filled;
289 written += filled;
290 continue;
291 }
292
293 // Try to fetch data
294 ssize_t fetched = sEncoder.fetch(pOS);
295 if (fetched > 0)
296 continue;
297
298 // Nothing to do more? Skip any errors if there was data processed
299 if (written > 0)
300 break;
301
302 // Analyze errors
303 if (filled < 0)
304 return -set_error(status_t(-filled));
305 else if (fetched < 0)
306 return -set_error(status_t(-fetched));
307
308 break;
309 }
310
311 return set_error(STATUS_OK);
312 }
313
314 status_t OutSequence::write_ascii(const char *s, size_t count)
315 {
316 if (pOS == NULL)
317 return set_error(STATUS_CLOSED);
318
319 size_t written = 0;
320
321 while (written < count)
322 {
323 // Try to fill data
324 ssize_t filled = sEncoder.fill(s, count - written);
325 if (filled > 0)
326 {
327 s += filled;
328 written += filled;
329 continue;
330 }
331
332 // Try to fetch data
333 ssize_t fetched = sEncoder.fetch(pOS);
334 if (fetched > 0)
335 continue;
336
337 // Nothing to do more? Skip any errors if there was data processed
338 if (written > 0)
339 break;
340
341 // Analyze errors
342 if (filled < 0)
343 return -set_error(status_t(-filled));
344 else if (fetched < 0)
345 return -set_error(status_t(-fetched));
346
347 break;
348 }
349
350 return set_error(STATUS_OK);
351 }
352
353 status_t OutSequence::flush()
354 {
355 if (pOS == NULL)
356 return set_error(STATUS_CLOSED);
357
358 return flush_buffer_internal(true);
359 }
360 }
361
362 } /* namespace lsp */