Debian Codegraph @

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

raw
1 /*
2 * Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2020 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 13 мар. 2019 г.
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/StdioFile.h>
23 #include <lsp-plug.in/io/NativeFile.h>
24 #include <lsp-plug.in/io/OutFileStream.h>
25 #include <lsp-plug.in/stdlib/stdio.h>
26
27 namespace lsp
28 {
29 namespace io
30 {
31
32 OutFileStream::OutFileStream()
33 {
34 pFD = NULL;
35 nWrapFlags = 0;
36 }
37
38 OutFileStream::~OutFileStream()
39 {
40 // Close file descriptor
41 if (pFD != NULL)
42 {
43 if (nWrapFlags & WRAP_CLOSE)
44 pFD->close();
45 if (nWrapFlags & WRAP_DELETE)
46 delete pFD;
47 pFD = NULL;
48 }
49 nWrapFlags = 0;
50 }
51
52 status_t OutFileStream::close()
53 {
54 status_t res = STATUS_OK;
55
56 if (pFD != NULL)
57 {
58 // Perform close
59 if (nWrapFlags & WRAP_CLOSE)
60 res = pFD->close();
61 if (nWrapFlags & WRAP_DELETE)
62 delete pFD;
63 pFD = NULL;
64 }
65 nWrapFlags = 0;
66
67 return set_error(res);
68 }
69
70 status_t OutFileStream::wrap(FILE *fd, bool close)
71 {
72 if (pFD != NULL)
73 return set_error(STATUS_BAD_STATE);
74 else if (fd == NULL)
75 return set_error(STATUS_BAD_ARGUMENTS);
76
77 StdioFile *f = new StdioFile();
78 if (f == NULL)
79 return set_error(STATUS_NO_MEM);
80 status_t res = f->wrap(fd, File::FM_WRITE, close);
81 if (res != STATUS_OK)
82 {
83 f->close();
84 delete f;
85 return set_error(res);
86 }
87
88 res = wrap(f, WRAP_DELETE);
89 if (res != STATUS_OK)
90 {
91 f->close();
92 delete f;
93 }
94 return set_error(res);
95 }
96
97 status_t OutFileStream::wrap_native(fhandle_t fd, bool close)
98 {
99 if (pFD != NULL)
100 return set_error(STATUS_BAD_STATE);
101
102 NativeFile *f = new NativeFile();
103 if (f == NULL)
104 return set_error(STATUS_NO_MEM);
105 status_t res = f->wrap(fd, File::FM_WRITE, close);
106 if (res != STATUS_OK)
107 {
108 f->close();
109 delete f;
110 return set_error(res);
111 }
112
113 res = wrap(f, WRAP_DELETE);
114 if (res != STATUS_OK)
115 {
116 f->close();
117 delete f;
118 }
119 return set_error(res);
120 }
121
122 status_t OutFileStream::wrap(File *fd, size_t flags)
123 {
124 if (pFD != NULL)
125 return set_error(STATUS_BAD_STATE);
126 else if (fd == NULL)
127 return set_error(STATUS_BAD_ARGUMENTS);
128
129 // Store pointers
130 pFD = fd;
131 nWrapFlags = flags;
132
133 return STATUS_OK;
134 }
135
136 status_t OutFileStream::open(const char *path, size_t mode)
137 {
138 if (pFD != NULL)
139 return set_error(STATUS_BAD_STATE);
140 else if (path == NULL)
141 return set_error(STATUS_BAD_ARGUMENTS);
142
143 LSPString tmp;
144 if (!tmp.set_utf8(path))
145 return set_error(STATUS_NO_MEM);
146 return open(&tmp, mode);
147 }
148
149 status_t OutFileStream::open(const LSPString *path, size_t mode)
150 {
151 if (pFD != NULL)
152 return set_error(STATUS_BAD_STATE);
153 else if (path == NULL)
154 return set_error(STATUS_BAD_ARGUMENTS);
155
156 NativeFile *f = new NativeFile();
157 if (f == NULL)
158 return set_error(STATUS_NO_MEM);
159
160 status_t res = f->open(path, mode | File::FM_WRITE);
161 if (res != STATUS_OK)
162 {
163 f->close();
164 delete f;
165 return set_error(res);
166 }
167
168 return wrap(f, WRAP_CLOSE | WRAP_DELETE);
169 }
170
171 status_t OutFileStream::open(const Path *path, size_t mode)
172 {
173 return open(path->as_string(), mode);
174 }
175
176 wssize_t OutFileStream::position()
177 {
178 if (pFD == NULL)
179 return set_error(STATUS_CLOSED);
180 wssize_t pos = pFD->position();
181 set_error((pos < 0) ? status_t(-pos) : STATUS_OK);
182 return pos;
183 }
184
185 ssize_t OutFileStream::write(const void *buf, size_t count)
186 {
187 if (pFD == NULL)
188 return set_error(STATUS_CLOSED);
189 ssize_t res = pFD->write(buf, count);
190 set_error((res < 0) ? status_t(-res) : STATUS_OK);
191 return res;
192 }
193
194 wssize_t OutFileStream::seek(wsize_t position)
195 {
196 if (pFD == NULL)
197 return set_error(STATUS_CLOSED);
198 status_t res = pFD->seek(position, File::FSK_SET);
199 if (res != STATUS_OK)
200 return -set_error(res);
201 wssize_t pos = pFD->position();
202 set_error((pos < 0) ? status_t(-pos) : STATUS_OK);
203 return pos;
204 }
205
206 status_t OutFileStream::open_temp(io::Path *path, const char *prefix)
207 {
208 if (pFD != NULL)
209 return set_error(STATUS_BAD_STATE);
210 else if (path == NULL)
211 return set_error(STATUS_BAD_ARGUMENTS);
212
213 NativeFile *f = new NativeFile();
214 if (f == NULL)
215 return set_error(STATUS_NO_MEM);
216
217 status_t res = f->open_temp(path, prefix);
218 if (res != STATUS_OK)
219 {
220 f->close();
221 delete f;
222 return set_error(res);
223 }
224
225 return wrap(f, WRAP_CLOSE | WRAP_DELETE);
226 }
227
228 status_t OutFileStream::open_temp(io::Path *path, const LSPString *prefix)
229 {
230 if (pFD != NULL)
231 return set_error(STATUS_BAD_STATE);
232 else if (path == NULL)
233 return set_error(STATUS_BAD_ARGUMENTS);
234
235 NativeFile *f = new NativeFile();
236 if (f == NULL)
237 return set_error(STATUS_NO_MEM);
238
239 status_t res = f->open_temp(path, prefix);
240 if (res != STATUS_OK)
241 {
242 f->close();
243 delete f;
244 return set_error(res);
245 }
246
247 return wrap(f, WRAP_CLOSE | WRAP_DELETE);
248 }
249
250 status_t OutFileStream::open_temp(LSPString *path, const char *prefix)
251 {
252 if (pFD != NULL)
253 return set_error(STATUS_BAD_STATE);
254 else if (path == NULL)
255 return set_error(STATUS_BAD_ARGUMENTS);
256
257 NativeFile *f = new NativeFile();
258 if (f == NULL)
259 return set_error(STATUS_NO_MEM);
260
261 status_t res = f->open_temp(path, prefix);
262 if (res != STATUS_OK)
263 {
264 f->close();
265 delete f;
266 return set_error(res);
267 }
268
269 return wrap(f, WRAP_CLOSE | WRAP_DELETE);
270 }
271
272 status_t OutFileStream::open_temp(LSPString *path, const LSPString *prefix)
273 {
274 if (pFD != NULL)
275 return set_error(STATUS_BAD_STATE);
276 else if (path == NULL)
277 return set_error(STATUS_BAD_ARGUMENTS);
278
279 NativeFile *f = new NativeFile();
280 if (f == NULL)
281 return set_error(STATUS_NO_MEM);
282
283 status_t res = f->open_temp(path, prefix);
284 if (res != STATUS_OK)
285 {
286 f->close();
287 delete f;
288 return set_error(res);
289 }
290
291 return wrap(f, WRAP_CLOSE | WRAP_DELETE);
292 }
293
294 status_t OutFileStream::flush()
295 {
296 if (pFD == NULL)
297 return set_error(STATUS_CLOSED);
298 return set_error(pFD->flush());
299 }
300
301 } /* namespace io */
302 } /* namespace lsp */