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

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

Initial release

File size: 10.7 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.Metadata;
22
23private import appstream.Component;
24private import gi.appstream;
25public  import gi.appstreamtypes;
26private import gio.FileIF;
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 Metadata : ObjectG
37{
38        /** the main Gtk struct */
39        protected AsMetadata* asMetadata;
40
41        /** Get the main Gtk struct */
42        public AsMetadata* getMetadataStruct()
43        {
44                return asMetadata;
45        }
46
47        /** the main Gtk struct as a void* */
48        protected override void* getStruct()
49        {
50                return cast(void*)asMetadata;
51        }
52
53        protected override void setStruct(GObject* obj)
54        {
55                asMetadata = cast(AsMetadata*)obj;
56                super.setStruct(obj);
57        }
58
59        /**
60         * Sets our main struct and passes it to the parent class.
61         */
62        public this (AsMetadata* asMetadata, bool ownedRef = false)
63        {
64                this.asMetadata = asMetadata;
65                super(cast(GObject*)asMetadata, ownedRef);
66        }
67
68
69        /** */
70        public static GType getType()
71        {
72                return as_metadata_get_type();
73        }
74
75        /**
76         * Creates a new #AsMetadata.
77         *
78         * Returns: a #AsMetadata
79         *
80         * Throws: ConstructionException GTK+ fails to create the object.
81         */
82        public this()
83        {
84                auto p = as_metadata_new();
85               
86                if(p is null)
87                {
88                        throw new ConstructionException("null returned by new");
89                }
90               
91                this(cast(AsMetadata*) p, true);
92        }
93
94        /**
95         * Returns: An error quark.
96         */
97        public static GQuark errorQuark()
98        {
99                return as_metadata_error_quark();
100        }
101
102        /**
103         * Add an #AsComponent to the list of components.
104         * This can be used to add multiple components in order to
105         * produce a distro-XML AppStream metadata file.
106         */
107        public void addComponent(Component cpt)
108        {
109                as_metadata_add_component(asMetadata, (cpt is null) ? null : cpt.getComponentStruct());
110        }
111
112        /** */
113        public void clearComponents()
114        {
115                as_metadata_clear_components(asMetadata);
116        }
117
118        /**
119         * Convert an #AsComponent to metainfo data.
120         * This will always be XML, YAML is no valid format for metainfo files.
121         *
122         * The amount of localization included in the metadata depends on how the #AsComponent
123         * was initially loaded and whether it contains data for all locale.
124         *
125         * The first #AsComponent added to the internal list will be transformed.
126         * In case no component is present, %NULL is returned.
127         *
128         * Params:
129         *     format = The format to use (XML or YAML)
130         *
131         * Returns: A string containing the XML metadata. Free with g_free()
132         *
133         * Throws: GException on failure.
134         */
135        public string componentToMetainfo(AsFormatKind format)
136        {
137                GError* err = null;
138               
139                auto retStr = as_metadata_component_to_metainfo(asMetadata, format, &err);
140               
141                if (err !is null)
142                {
143                        throw new GException( new ErrorG(err) );
144                }
145               
146                scope(exit) Str.freeString(retStr);
147                return Str.toString(retStr);
148        }
149
150        /**
151         * Serialize all #AsComponent instances into AppStream
152         * collection metadata.
153         * %NULL is returned if there is nothing to serialize.
154         *
155         * Params:
156         *     format = The format to serialize the data to (XML or YAML).
157         *
158         * Returns: A string containing the YAML or XML data. Free with g_free()
159         *
160         * Throws: GException on failure.
161         */
162        public string componentsToCollection(AsFormatKind format)
163        {
164                GError* err = null;
165               
166                auto retStr = as_metadata_components_to_collection(asMetadata, format, &err);
167               
168                if (err !is null)
169                {
170                        throw new GException( new ErrorG(err) );
171                }
172               
173                scope(exit) Str.freeString(retStr);
174                return Str.toString(retStr);
175        }
176
177        /**
178         * Returns: The architecture of AppStream distro metadata
179         */
180        public string getArchitecture()
181        {
182                return Str.toString(as_metadata_get_architecture(asMetadata));
183        }
184
185        /**
186         * Gets the #AsComponent which has been parsed from the XML.
187         * If the AppStream XML contained multiple components, return the first
188         * component that has been parsed.
189         *
190         * Returns: An #AsComponent or %NULL
191         */
192        public Component getComponent()
193        {
194                auto p = as_metadata_get_component(asMetadata);
195               
196                if(p is null)
197                {
198                        return null;
199                }
200               
201                return ObjectG.getDObject!(Component)(cast(AsComponent*) p);
202        }
203
204        /**
205         * Returns: A #GPtrArray of all parsed components
206         */
207        public PtrArray getComponents()
208        {
209                auto p = as_metadata_get_components(asMetadata);
210               
211                if(p is null)
212                {
213                        return null;
214                }
215               
216                return new PtrArray(cast(GPtrArray*) p);
217        }
218
219        /**
220         * Get the metadata parsing mode.
221         */
222        public AsFormatStyle getFormatStyle()
223        {
224                return as_metadata_get_format_style(asMetadata);
225        }
226
227        /**
228         * Returns: The AppStream metadata format version.
229         */
230        public AsFormatVersion getFormatVersion()
231        {
232                return as_metadata_get_format_version(asMetadata);
233        }
234
235        /**
236         * Gets the current active locale for parsing metadata,
237         * or "ALL" if all locales are read.
238         *
239         * Returns: Locale used for metadata parsing.
240         */
241        public string getLocale()
242        {
243                return Str.toString(as_metadata_get_locale(asMetadata));
244        }
245
246        /**
247         * Returns: The origin of AppStream distro metadata
248         */
249        public string getOrigin()
250        {
251                return Str.toString(as_metadata_get_origin(asMetadata));
252        }
253
254        /**
255         * Returns: Whether existing components should be updates with the parsed data,
256         *     instead of creating new ones.
257         */
258        public bool getUpdateExisting()
259        {
260                return as_metadata_get_update_existing(asMetadata) != 0;
261        }
262
263        /**
264         * Returns: Whether we will write a header/root node in collection metadata.
265         */
266        public bool getWriteHeader()
267        {
268                return as_metadata_get_write_header(asMetadata) != 0;
269        }
270
271        /**
272         * Parses AppStream metadata.
273         *
274         * Params:
275         *     data = Metadata describing one or more software components.
276         *     format = The format of the data (XML or YAML).
277         *
278         * Throws: GException on failure.
279         */
280        public void parse(string data, AsFormatKind format)
281        {
282                GError* err = null;
283               
284                as_metadata_parse(asMetadata, Str.toStringz(data), format, &err);
285               
286                if (err !is null)
287                {
288                        throw new GException( new ErrorG(err) );
289                }
290        }
291
292        /**
293         * Parses XDG Desktop Entry metadata and adds it to the pool.
294         *
295         * Params:
296         *     data = Metadata describing one or more software components.
297         *     cid = The component-id the new #AsComponent should have.
298         *
299         * Throws: GException on failure.
300         */
301        public void parseDesktopData(string data, string cid)
302        {
303                GError* err = null;
304               
305                as_metadata_parse_desktop_data(asMetadata, Str.toStringz(data), Str.toStringz(cid), &err);
306               
307                if (err !is null)
308                {
309                        throw new GException( new ErrorG(err) );
310                }
311        }
312
313        /**
314         * Parses an AppStream upstream metadata file.
315         *
316         * Params:
317         *     file = #GFile for the upstream metadata
318         *     format = The format the data is in, or %AS_FORMAT_KIND_UNKNOWN if not known.
319         *
320         * Throws: GException on failure.
321         */
322        public void parseFile(FileIF file, AsFormatKind format)
323        {
324                GError* err = null;
325               
326                as_metadata_parse_file(asMetadata, (file is null) ? null : file.getFileStruct(), format, &err);
327               
328                if (err !is null)
329                {
330                        throw new GException( new ErrorG(err) );
331                }
332        }
333
334        /** */
335        public void saveCollection(string fname, AsFormatKind format)
336        {
337                GError* err = null;
338               
339                as_metadata_save_collection(asMetadata, Str.toStringz(fname), format, &err);
340               
341                if (err !is null)
342                {
343                        throw new GException( new ErrorG(err) );
344                }
345        }
346
347        /**
348         * Serialize #AsComponent instance to XML and save it to file.
349         * An existing file at the same location will be overridden.
350         *
351         * Params:
352         *     fname = The filename for the new metadata file.
353         *     format = The format to save this file in. Only XML is supported at time.
354         *
355         * Throws: GException on failure.
356         */
357        public void saveMetainfo(string fname, AsFormatKind format)
358        {
359                GError* err = null;
360               
361                as_metadata_save_metainfo(asMetadata, Str.toStringz(fname), format, &err);
362               
363                if (err !is null)
364                {
365                        throw new GException( new ErrorG(err) );
366                }
367        }
368
369        /**
370         * Set the architecture the components in this metadata belong to.
371         *
372         * Params:
373         *     arch = an architecture string.
374         */
375        public void setArchitecture(string arch)
376        {
377                as_metadata_set_architecture(asMetadata, Str.toStringz(arch));
378        }
379
380        /**
381         * Sets the current metadata parsing mode.
382         *
383         * Params:
384         *     mode = the #AsFormatStyle.
385         */
386        public void setFormatStyle(AsFormatStyle mode)
387        {
388                as_metadata_set_format_style(asMetadata, mode);
389        }
390
391        /**
392         * Set the current AppStream format version that we should generate data for
393         * or be able to read.
394         *
395         * Params:
396         *     versio = the AppStream metadata format version as #AsFormatVersion.
397         */
398        public void setFormatVersion(AsFormatVersion versio)
399        {
400                as_metadata_set_format_version(asMetadata, versio);
401        }
402
403        /**
404         * Sets the locale which should be read when processing metadata.
405         * All other locales are ignored, which increases parsing speed and
406         * reduces memory usage.
407         * If you set the locale to "ALL", all locales will be read.
408         *
409         * Params:
410         *     locale = the locale.
411         */
412        public void setLocale(string locale)
413        {
414                as_metadata_set_locale(asMetadata, Str.toStringz(locale));
415        }
416
417        /**
418         * Set the origin of AppStream distro metadata
419         *
420         * Params:
421         *     origin = the origin of AppStream distro metadata.
422         */
423        public void setOrigin(string origin)
424        {
425                as_metadata_set_origin(asMetadata, Str.toStringz(origin));
426        }
427
428        /**
429         * If set to %TRUE, the parser will not create new components but
430         * instead update existing components in the pool with new metadata.
431         *
432         * NOTE: Right now, this feature is only implemented for metainfo XML parsing!
433         *
434         * Params:
435         *     update = A boolean value.
436         */
437        public void setUpdateExisting(bool update)
438        {
439                as_metadata_set_update_existing(asMetadata, update);
440        }
441
442        /**
443         * If set to %TRUE, tehe metadata writer will omit writing a DEP-11
444         * header document when in YAML mode, and will not write a root components node
445         * when writing XML data.
446         * Please keep in mind that this will create an invalid DEP-11 YAML AppStream
447         * collection metadata file, and an invalid XML file.
448         * This parameter should only be changed e.g. by the appstream-generator tool.
449         *
450         * NOTE: Right now, this feature is only implemented for YAML!
451         *
452         * Params:
453         *     wheader = A boolean value.
454         */
455        public void setWriteHeader(bool wheader)
456        {
457                as_metadata_set_write_header(asMetadata, wheader);
458        }
459}
Note: See TracBrowser for help on using the repository browser.