Debian Codegraph @

modules/lsp-runtime-lib/src/main/resource/PrefixLoader.cpp

raw
1 /*
2 * Copyright (C) 2023 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2023 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 8 июн. 2021 г.
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/common/debug.h>
23 #include <lsp-plug.in/resource/PrefixLoader.h>
24
25 namespace lsp
26 {
27 namespace resource
28 {
29 PrefixLoader::PrefixLoader(ILoader *dfl)
30 {
31 pDefault = dfl;
32 }
33
34 PrefixLoader::~PrefixLoader()
35 {
36 pDefault = NULL;
37
38 for (size_t i=0, n=vLoaders.size(); i<n; ++i)
39 {
40 prefix_t *p = vLoaders.uget(i);
41 if (p == NULL)
42 continue;
43
44 if ((p->bFree) && (p->pLoader != NULL))
45 {
46 delete p->pLoader;
47 p->pLoader = NULL;
48 }
49 delete p;
50 }
51
52 vLoaders.flush();
53 }
54
55 bool PrefixLoader::match_prefix(const LSPString *str, const LSPString *prefix)
56 {
57 if (str->length() < prefix->length())
58 return false;
59
60 // We need to match prefix respective to the possible mix of '/' and '\' characters
61 for (size_t i=0, n=prefix->length(); i<n; ++i)
62 {
63 lsp_wchar_t ch = prefix->char_at(i);
64 lsp_wchar_t sc = str->char_at(i);
65 if (sc != ch)
66 {
67 if ((ch != '/') && (ch != '\\'))
68 return false;
69 if ((sc != '/') && (sc != '\\'))
70 return false;
71 }
72 }
73
74 return true;
75 }
76
77 ILoader *PrefixLoader::lookup_prefix(LSPString *dst, const LSPString *path)
78 {
79 // Check path
80 if (path == NULL)
81 {
82 set_error(STATUS_BAD_ARGUMENTS);
83 return NULL;
84 }
85
86 // Clear the error first
87 set_error(STATUS_OK);
88
89 // Find the matching prefix
90 for (size_t i=0, n=vLoaders.size(); i<n; ++i)
91 {
92 prefix_t *p = vLoaders.uget(i);
93 if (p == NULL)
94 continue;
95
96 // Match found?
97 if (match_prefix(path, &p->sPrefix))
98 {
99 if (!dst->set(path, p->sPrefix.length()))
100 {
101 set_error(STATUS_NO_MEM);
102 return NULL;
103 }
104
105 // lsp_trace("Matched prefix '%s', delegating path '%s' to loader %p",
106 // p->sPrefix.get_utf8(), dst->get_utf8(), p->pLoader);
107
108 return p->pLoader;
109 }
110 }
111
112 // Prefix has not been found
113 return pDefault;
114 }
115
116 ILoader *PrefixLoader::lookup_prefix(LSPString *dst, const char *path)
117 {
118 if (path == NULL)
119 {
120 set_error(STATUS_BAD_ARGUMENTS);
121 return NULL;
122 }
123
124 LSPString tmp;
125 if (!tmp.set_utf8(path))
126 {
127 set_error(STATUS_NO_MEM);
128 return NULL;
129 }
130
131 return lookup_prefix(dst, &tmp);
132 }
133
134 ILoader *PrefixLoader::lookup_prefix(LSPString *dst, const io::Path *path)
135 {
136 if (path == NULL)
137 {
138 set_error(STATUS_BAD_ARGUMENTS);
139 return NULL;
140 }
141
142 return lookup_prefix(dst, path->as_string());
143 }
144
145 status_t PrefixLoader::add_prefix(const char *prefix, ILoader *loader, bool free)
146 {
147 if (prefix == NULL)
148 return set_error(STATUS_BAD_ARGUMENTS);
149
150 prefix_t *pref = new prefix_t;
151 if (pref == NULL)
152 return set_error(STATUS_NO_MEM);
153 if (!pref->sPrefix.set_utf8(prefix))
154 {
155 delete pref;
156 return set_error(STATUS_NO_MEM);
157 }
158 pref->pLoader = loader;
159 pref->bFree = free;
160
161 if (!vLoaders.add(pref))
162 {
163 delete pref;
164 return set_error(STATUS_NO_MEM);
165 }
166
167 return set_error(STATUS_OK);
168 }
169
170 status_t PrefixLoader::add_prefix(const LSPString *prefix, ILoader *loader, bool free)
171 {
172 if (prefix == NULL)
173 return set_error(STATUS_BAD_ARGUMENTS);
174
175 prefix_t *pref = new prefix_t;
176 if (pref == NULL)
177 return set_error(STATUS_NO_MEM);
178 if (!pref->sPrefix.set(prefix))
179 {
180 delete pref;
181 return set_error(STATUS_NO_MEM);
182 }
183 pref->pLoader = loader;
184 pref->bFree = free;
185
186 if (!vLoaders.add(pref))
187 {
188 delete pref;
189 return set_error(STATUS_NO_MEM);
190 }
191
192 return set_error(STATUS_OK);
193 }
194
195 status_t PrefixLoader::add_prefix(const io::Path *prefix, ILoader *loader, bool free)
196 {
197 if (prefix == NULL)
198 return set_error(STATUS_BAD_ARGUMENTS);
199
200 prefix_t *pref = new prefix_t;
201 if (pref == NULL)
202 return set_error(STATUS_NO_MEM);
203 if (!pref->sPrefix.set(prefix->as_string()))
204 {
205 delete pref;
206 return set_error(STATUS_NO_MEM);
207 }
208 pref->pLoader = loader;
209 pref->bFree = free;
210
211 if (!vLoaders.add(pref))
212 {
213 delete pref;
214 return set_error(STATUS_NO_MEM);
215 }
216
217 return set_error(STATUS_OK);
218 }
219
220 io::IInStream *PrefixLoader::read_stream(const char *name)
221 {
222 LSPString tmp;
223 ILoader *ldr = lookup_prefix(&tmp, name);
224 if (ldr != NULL)
225 {
226 io::IInStream *ret = ldr->read_stream(&tmp);
227 set_error(ldr->last_error());
228 return ret;
229 }
230
231 return (last_error() == STATUS_OK) ? ILoader::read_stream(name) : NULL;
232 }
233
234 io::IInStream *PrefixLoader::read_stream(const LSPString *name)
235 {
236 LSPString tmp;
237 ILoader *ldr = lookup_prefix(&tmp, name);
238 if (ldr != NULL)
239 {
240 io::IInStream *ret = ldr->read_stream(&tmp);
241 set_error(ldr->last_error());
242 return ret;
243 }
244
245 return (last_error() == STATUS_OK) ? ILoader::read_stream(name) : NULL;
246 }
247
248 io::IInStream *PrefixLoader::read_stream(const io::Path *name)
249 {
250 LSPString tmp;
251 ILoader *ldr = lookup_prefix(&tmp, name);
252 if (ldr != NULL)
253 {
254 io::IInStream *ret = ldr->read_stream(&tmp);
255 set_error(ldr->last_error());
256 return ret;
257 }
258
259 return (last_error() == STATUS_OK) ? ILoader::read_stream(name) : NULL;
260 }
261
262 io::IInSequence *PrefixLoader::read_sequence(const char *name, const char *charset)
263 {
264 LSPString tmp;
265 ILoader *ldr = lookup_prefix(&tmp, name);
266 if (ldr != NULL)
267 {
268 io::IInSequence *ret = ldr->read_sequence(&tmp, charset);
269 set_error(ldr->last_error());
270 return ret;
271 }
272
273 return (last_error() == STATUS_OK) ? ILoader::read_sequence(name, charset) : NULL;
274 }
275
276 io::IInSequence *PrefixLoader::read_sequence(const LSPString *name, const char *charset)
277 {
278 LSPString tmp;
279 ILoader *ldr = lookup_prefix(&tmp, name);
280 if (ldr != NULL)
281 {
282 io::IInSequence *ret = ldr->read_sequence(&tmp, charset);
283 set_error(ldr->last_error());
284 return ret;
285 }
286
287 return (last_error() == STATUS_OK) ? ILoader::read_sequence(name, charset) : NULL;
288 }
289
290 io::IInSequence *PrefixLoader::read_sequence(const io::Path *name, const char *charset)
291 {
292 LSPString tmp;
293 ILoader *ldr = lookup_prefix(&tmp, name);
294 if (ldr != NULL)
295 {
296 io::IInSequence *ret = ldr->read_sequence(&tmp, charset);
297 set_error(ldr->last_error());
298 return ret;
299 }
300
301 return (last_error() == STATUS_OK) ? ILoader::read_sequence(name, charset) : NULL;
302 }
303
304 ssize_t PrefixLoader::enumerate(const char *path, resource::resource_t **list)
305 {
306 lsp_trace("path = %s", path);
307 LSPString tmp;
308 ILoader *ldr = lookup_prefix(&tmp, path);
309 if (ldr != NULL)
310 {
311 ssize_t ret = ldr->enumerate(&tmp, list);
312 set_error(ldr->last_error());
313 return ret;
314 }
315
316 return (last_error() == STATUS_OK) ? ILoader::enumerate(path, list) : -last_error();
317 }
318
319 ssize_t PrefixLoader::enumerate(const LSPString *path, resource::resource_t **list)
320 {
321 lsp_trace("path = %s", path->get_utf8());
322 LSPString tmp;
323 ILoader *ldr = lookup_prefix(&tmp, path);
324 if (ldr != NULL)
325 {
326 ssize_t ret = ldr->enumerate(&tmp, list);
327 set_error(ldr->last_error());
328 return ret;
329 }
330
331 return (last_error() == STATUS_OK) ? ILoader::enumerate(path, list) : -last_error();
332 }
333
334 ssize_t PrefixLoader::enumerate(const io::Path *path, resource::resource_t **list)
335 {
336 LSPString tmp;
337 ILoader *ldr = lookup_prefix(&tmp, path);
338 if (ldr != NULL)
339 {
340 ssize_t ret = ldr->enumerate(&tmp, list);
341 set_error(ldr->last_error());
342 return ret;
343 }
344
345 return (last_error() == STATUS_OK) ? ILoader::enumerate(path, list) : -last_error();
346 }
347
348 } /* namespace resource */
349 } /* namespace lsp */
350
351