source: appstream-generator/build/girepo/appstream/Pool.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 9.1 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module appstream.Pool;
22
23private import appstream.Component;
24private import gi.appstream;
25public  import gi.appstreamtypes;
26private import gio.Cancellable;
27private import glib.ConstructionException;
28private import glib.ErrorG;
29private import glib.GException;
30private import glib.PtrArray;
31private import glib.Str;
32private import gobject.ObjectG;
33
34
35/** */
36public class Pool : ObjectG
37{
38        /** the main Gtk struct */
39        protected AsPool* asPool;
40
41        /** Get the main Gtk struct */
42        public AsPool* getPoolStruct()
43        {
44                return asPool;
45        }
46
47        /** the main Gtk struct as a void* */
48        protected override void* getStruct()
49        {
50                return cast(void*)asPool;
51        }
52
53        protected override void setStruct(GObject* obj)
54        {
55                asPool = cast(AsPool*)obj;
56                super.setStruct(obj);
57        }
58
59        /**
60         * Sets our main struct and passes it to the parent class.
61         */
62        public this (AsPool* asPool, bool ownedRef = false)
63        {
64                this.asPool = asPool;
65                super(cast(GObject*)asPool, ownedRef);
66        }
67
68
69        /** */
70        public static GType getType()
71        {
72                return as_pool_get_type();
73        }
74
75        /**
76         * Creates a new #AsPool.
77         *
78         * Returns: a #AsPool
79         *
80         * Throws: ConstructionException GTK+ fails to create the object.
81         */
82        public this()
83        {
84                auto p = as_pool_new();
85               
86                if(p is null)
87                {
88                        throw new ConstructionException("null returned by new");
89                }
90               
91                this(cast(AsPool*) p, true);
92        }
93
94        /**
95         * Returns: An error quark.
96         */
97        public static GQuark errorQuark()
98        {
99                return as_pool_error_quark();
100        }
101
102        /**
103         * Register a new component in the AppStream metadata pool.
104         *
105         * Params:
106         *     cpt = The #AsComponent to add to the pool.
107         *
108         * Returns: %TRUE if the new component was successfully added to the pool.
109         *
110         * Throws: GException on failure.
111         */
112        public bool addComponent(Component cpt)
113        {
114                GError* err = null;
115               
116                auto p = as_pool_add_component(asPool, (cpt is null) ? null : cpt.getComponentStruct(), &err) != 0;
117               
118                if (err !is null)
119                {
120                        throw new GException( new ErrorG(err) );
121                }
122               
123                return p;
124        }
125
126        /**
127         * Add a location for the data pool to read data from.
128         * If @directory contains a "xml", "xmls", "yaml" or "icons" subdirectory (or all of them),
129         * those paths will be added to the search paths instead.
130         *
131         * Params:
132         *     directory = An existing filesystem location.
133         */
134        public void addMetadataLocation(string directory)
135        {
136                as_pool_add_metadata_location(asPool, Str.toStringz(directory));
137        }
138
139        /**
140         * Remove all metadat from the pool.
141         */
142        public void clear()
143        {
144                as_pool_clear(asPool);
145        }
146
147        /**
148         * Remove all metadata locations from the list of watched locations.
149         */
150        public void clearMetadataLocations()
151        {
152                as_pool_clear_metadata_locations(asPool);
153        }
154
155        /**
156         * Get the #AsCacheFlags for this data pool.
157         */
158        public AsCacheFlags getCacheFlags()
159        {
160                return as_pool_get_cache_flags(asPool);
161        }
162
163        /**
164         * Get a list of found components.
165         *
166         * Returns: an array of #AsComponent instances.
167         */
168        public PtrArray getComponents()
169        {
170                auto p = as_pool_get_components(asPool);
171               
172                if(p is null)
173                {
174                        return null;
175                }
176               
177                return new PtrArray(cast(GPtrArray*) p);
178        }
179
180        /**
181         * Return a list of components which are in one of the categories.
182         *
183         * Params:
184         *     categories = An array of XDG categories to include.
185         *
186         * Returns: an array of #AsComponent objects which have been found.
187         */
188        public PtrArray getComponentsByCategories(string[] categories)
189        {
190                auto p = as_pool_get_components_by_categories(asPool, Str.toStringzArray(categories));
191               
192                if(p is null)
193                {
194                        return null;
195                }
196               
197                return new PtrArray(cast(GPtrArray*) p);
198        }
199
200        /**
201         * Get a specific component by its ID.
202         * This function may contain multiple results if we have
203         * data describing this component from multiple scopes/origin types.
204         *
205         * Params:
206         *     cid = The AppStream-ID to look for.
207         *
208         * Returns: An #AsComponent
209         */
210        public PtrArray getComponentsById(string cid)
211        {
212                auto p = as_pool_get_components_by_id(asPool, Str.toStringz(cid));
213               
214                if(p is null)
215                {
216                        return null;
217                }
218               
219                return new PtrArray(cast(GPtrArray*) p);
220        }
221
222        /**
223         * Return a list of all components in the pool which are of a certain kind.
224         *
225         * Params:
226         *     kind = An #AsComponentKind.
227         *
228         * Returns: an array of #AsComponent objects which have been found.
229         */
230        public PtrArray getComponentsByKind(AsComponentKind kind)
231        {
232                auto p = as_pool_get_components_by_kind(asPool, kind);
233               
234                if(p is null)
235                {
236                        return null;
237                }
238               
239                return new PtrArray(cast(GPtrArray*) p);
240        }
241
242        /**
243         * Find components in the AppStream data pool whcih provide a certain item.
244         *
245         * Params:
246         *     kind = An #AsProvidesKind
247         *     item = The value of the provided item.
248         *
249         * Returns: an array of #AsComponent objects which have been found.
250         */
251        public PtrArray getComponentsByProvidedItem(AsProvidedKind kind, string item)
252        {
253                auto p = as_pool_get_components_by_provided_item(asPool, kind, Str.toStringz(item));
254               
255                if(p is null)
256                {
257                        return null;
258                }
259               
260                return new PtrArray(cast(GPtrArray*) p);
261        }
262
263        /**
264         * Get the #AsPoolFlags for this data pool.
265         */
266        public AsPoolFlags getFlags()
267        {
268                return as_pool_get_flags(asPool);
269        }
270
271        /**
272         * Gets the currently used locale.
273         *
274         * Returns: Locale used for metadata parsing.
275         */
276        public string getLocale()
277        {
278                return Str.toString(as_pool_get_locale(asPool));
279        }
280
281        /**
282         * Builds an index of all found components in the watched locations.
283         * The function will try to get as much data into the pool as possible, so even if
284         * the update completes with %FALSE, it might still have added components to the pool.
285         *
286         * The function will load from all possible data sources, preferring caches if they
287         * are up to date.
288         *
289         * Returns: %TRUE if update completed without error.
290         *
291         * Throws: GException on failure.
292         */
293        public bool load(Cancellable cancellable)
294        {
295                GError* err = null;
296               
297                auto p = as_pool_load(asPool, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err) != 0;
298               
299                if (err !is null)
300                {
301                        throw new GException( new ErrorG(err) );
302                }
303               
304                return p;
305        }
306
307        /**
308         * Load AppStream metadata from a cache file.
309         *
310         * Params:
311         *     fname = Filename of the cache file to load into the pool.
312         *
313         * Throws: GException on failure.
314         */
315        public bool loadCacheFile(string fname)
316        {
317                GError* err = null;
318               
319                auto p = as_pool_load_cache_file(asPool, Str.toStringz(fname), &err) != 0;
320               
321                if (err !is null)
322                {
323                        throw new GException( new ErrorG(err) );
324                }
325               
326                return p;
327        }
328
329        /**
330         * Update the AppStream cache. There is normally no need to call this function manually, because cache updates are handled
331         * transparently in the background.
332         *
333         * Params:
334         *     force = Enforce refresh, even if source data has not changed.
335         *
336         * Returns: %TRUE if the cache was updated, %FALSE on error or if the cache update was not necessary and has been skipped.
337         *
338         * Throws: GException on failure.
339         */
340        public bool refreshCache(bool force)
341        {
342                GError* err = null;
343               
344                auto p = as_pool_refresh_cache(asPool, force, &err) != 0;
345               
346                if (err !is null)
347                {
348                        throw new GException( new ErrorG(err) );
349                }
350               
351                return p;
352        }
353
354        /**
355         * Serialize AppStream metadata to a cache file.
356         *
357         * Params:
358         *     fname = Filename of the cache file the pool contents should be dumped to.
359         *
360         * Throws: GException on failure.
361         */
362        public bool saveCacheFile(string fname)
363        {
364                GError* err = null;
365               
366                auto p = as_pool_save_cache_file(asPool, Str.toStringz(fname), &err) != 0;
367               
368                if (err !is null)
369                {
370                        throw new GException( new ErrorG(err) );
371                }
372               
373                return p;
374        }
375
376        /**
377         * Search for a list of components matching the search terms.
378         * The list will be ordered by match score.
379         *
380         * Params:
381         *     search = A search string
382         *
383         * Returns: an array of the found #AsComponent objects.
384         *
385         * Since: 0.9.7
386         */
387        public PtrArray search(string search)
388        {
389                auto p = as_pool_search(asPool, Str.toStringz(search));
390               
391                if(p is null)
392                {
393                        return null;
394                }
395               
396                return new PtrArray(cast(GPtrArray*) p);
397        }
398
399        /**
400         * Set the #AsCacheFlags for this data pool.
401         *
402         * Params:
403         *     flags = The new #AsCacheFlags.
404         */
405        public void setCacheFlags(AsCacheFlags flags)
406        {
407                as_pool_set_cache_flags(asPool, flags);
408        }
409
410        /**
411         * Set the #AsPoolFlags for this data pool.
412         *
413         * Params:
414         *     flags = The new #AsPoolFlags.
415         */
416        public void setFlags(AsPoolFlags flags)
417        {
418                as_pool_set_flags(asPool, flags);
419        }
420
421        /**
422         * Sets the current locale which should be used when parsing metadata.
423         *
424         * Params:
425         *     locale = the locale.
426         */
427        public void setLocale(string locale)
428        {
429                as_pool_set_locale(asPool, Str.toStringz(locale));
430        }
431}
Note: See TracBrowser for help on using the repository browser.