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

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

Initial release

File size: 9.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 glib.ArrayG;
22
23private import gi.glib;
24public  import gi.glibtypes;
25private import glib.ConstructionException;
26private import glib.Str;
27
28
29/**
30 * Contains the public fields of a GArray.
31 */
32public class ArrayG
33{
34        /** the main Gtk struct */
35        protected GArray* gArray;
36        protected bool ownedRef;
37
38        /** Get the main Gtk struct */
39        public GArray* getArrayGStruct()
40        {
41                return gArray;
42        }
43
44        /** the main Gtk struct as a void* */
45        protected void* getStruct()
46        {
47                return cast(void*)gArray;
48        }
49
50        /**
51         * Sets our main struct and passes it to the parent class.
52         */
53        public this (GArray* gArray, bool ownedRef = false)
54        {
55                this.gArray = gArray;
56                this.ownedRef = ownedRef;
57        }
58
59
60        /**
61         * Adds @len elements onto the end of the array.
62         *
63         * Params:
64         *     data = a pointer to the elements to append to the end of the array
65         *     len = the number of elements to append
66         *
67         * Returns: the #GArray
68         */
69        public ArrayG appendVals(void* data, uint len)
70        {
71                auto p = g_array_append_vals(gArray, data, len);
72               
73                if(p is null)
74                {
75                        return null;
76                }
77               
78                return new ArrayG(cast(GArray*) p);
79        }
80
81        /**
82         * Frees the memory allocated for the #GArray. If @free_segment is
83         * %TRUE it frees the memory block holding the elements as well and
84         * also each element if @array has a @element_free_func set. Pass
85         * %FALSE if you want to free the #GArray wrapper but preserve the
86         * underlying array for use elsewhere. If the reference count of @array
87         * is greater than one, the #GArray wrapper is preserved but the size
88         * of @array will be set to zero.
89         *
90         * If array elements contain dynamically-allocated memory, they should
91         * be freed separately.
92         *
93         * Params:
94         *     freeSegment = if %TRUE the actual element data is freed as well
95         *
96         * Returns: the element data if @free_segment is %FALSE, otherwise
97         *     %NULL. The element data should be freed using g_free().
98         */
99        public string free(bool freeSegment)
100        {
101                auto retStr = g_array_free(gArray, freeSegment);
102               
103                scope(exit) Str.freeString(retStr);
104                return Str.toString(retStr);
105        }
106
107        /**
108         * Gets the size of the elements in @array.
109         *
110         * Returns: Size of each element, in bytes
111         *
112         * Since: 2.22
113         */
114        public uint getElementSize()
115        {
116                return g_array_get_element_size(gArray);
117        }
118
119        /**
120         * Inserts @len elements into a #GArray at the given index.
121         *
122         * Params:
123         *     index = the index to place the elements at
124         *     data = a pointer to the elements to insert
125         *     len = the number of elements to insert
126         *
127         * Returns: the #GArray
128         */
129        public ArrayG insertVals(uint index, void* data, uint len)
130        {
131                auto p = g_array_insert_vals(gArray, index, data, len);
132               
133                if(p is null)
134                {
135                        return null;
136                }
137               
138                return new ArrayG(cast(GArray*) p);
139        }
140
141        /**
142         * Creates a new #GArray with a reference count of 1.
143         *
144         * Params:
145         *     zeroTerminated = %TRUE if the array should have an extra element at
146         *         the end which is set to 0
147         *     clear = %TRUE if #GArray elements should be automatically cleared
148         *         to 0 when they are allocated
149         *     elementSize = the size of each element in bytes
150         *
151         * Returns: the new #GArray
152         *
153         * Throws: ConstructionException GTK+ fails to create the object.
154         */
155        public this(bool zeroTerminated, bool clear, uint elementSize)
156        {
157                auto p = g_array_new(zeroTerminated, clear, elementSize);
158               
159                if(p is null)
160                {
161                        throw new ConstructionException("null returned by new");
162                }
163               
164                this(cast(GArray*) p);
165        }
166
167        /**
168         * Adds @len elements onto the start of the array.
169         *
170         * This operation is slower than g_array_append_vals() since the
171         * existing elements in the array have to be moved to make space for
172         * the new elements.
173         *
174         * Params:
175         *     data = a pointer to the elements to prepend to the start of the array
176         *     len = the number of elements to prepend
177         *
178         * Returns: the #GArray
179         */
180        public ArrayG prependVals(void* data, uint len)
181        {
182                auto p = g_array_prepend_vals(gArray, data, len);
183               
184                if(p is null)
185                {
186                        return null;
187                }
188               
189                return new ArrayG(cast(GArray*) p);
190        }
191
192        /**
193         * Atomically increments the reference count of @array by one.
194         * This function is MT-safe and may be called from any thread.
195         *
196         * Returns: The passed in #GArray
197         *
198         * Since: 2.22
199         */
200        public ArrayG doref()
201        {
202                auto p = g_array_ref(gArray);
203               
204                if(p is null)
205                {
206                        return null;
207                }
208               
209                return new ArrayG(cast(GArray*) p);
210        }
211
212        /**
213         * Removes the element at the given index from a #GArray. The following
214         * elements are moved down one place.
215         *
216         * Params:
217         *     index = the index of the element to remove
218         *
219         * Returns: the #GArray
220         */
221        public ArrayG removeIndex(uint index)
222        {
223                auto p = g_array_remove_index(gArray, index);
224               
225                if(p is null)
226                {
227                        return null;
228                }
229               
230                return new ArrayG(cast(GArray*) p);
231        }
232
233        /**
234         * Removes the element at the given index from a #GArray. The last
235         * element in the array is used to fill in the space, so this function
236         * does not preserve the order of the #GArray. But it is faster than
237         * g_array_remove_index().
238         *
239         * Params:
240         *     index = the index of the element to remove
241         *
242         * Returns: the #GArray
243         */
244        public ArrayG removeIndexFast(uint index)
245        {
246                auto p = g_array_remove_index_fast(gArray, index);
247               
248                if(p is null)
249                {
250                        return null;
251                }
252               
253                return new ArrayG(cast(GArray*) p);
254        }
255
256        /**
257         * Removes the given number of elements starting at the given index
258         * from a #GArray.  The following elements are moved to close the gap.
259         *
260         * Params:
261         *     index = the index of the first element to remove
262         *     length = the number of elements to remove
263         *
264         * Returns: the #GArray
265         *
266         * Since: 2.4
267         */
268        public ArrayG removeRange(uint index, uint length)
269        {
270                auto p = g_array_remove_range(gArray, index, length);
271               
272                if(p is null)
273                {
274                        return null;
275                }
276               
277                return new ArrayG(cast(GArray*) p);
278        }
279
280        /**
281         * Sets a function to clear an element of @array.
282         *
283         * The @clear_func will be called when an element in the array
284         * data segment is removed and when the array is freed and data
285         * segment is deallocated as well.
286         *
287         * Note that in contrast with other uses of #GDestroyNotify
288         * functions, @clear_func is expected to clear the contents of
289         * the array element it is given, but not free the element itself.
290         *
291         * Params:
292         *     clearFunc = a function to clear an element of @array
293         *
294         * Since: 2.32
295         */
296        public void setClearFunc(GDestroyNotify clearFunc)
297        {
298                g_array_set_clear_func(gArray, clearFunc);
299        }
300
301        /**
302         * Sets the size of the array, expanding it if necessary. If the array
303         * was created with @clear_ set to %TRUE, the new elements are set to 0.
304         *
305         * Params:
306         *     length = the new size of the #GArray
307         *
308         * Returns: the #GArray
309         */
310        public ArrayG setSize(uint length)
311        {
312                auto p = g_array_set_size(gArray, length);
313               
314                if(p is null)
315                {
316                        return null;
317                }
318               
319                return new ArrayG(cast(GArray*) p);
320        }
321
322        /**
323         * Creates a new #GArray with @reserved_size elements preallocated and
324         * a reference count of 1. This avoids frequent reallocation, if you
325         * are going to add many elements to the array. Note however that the
326         * size of the array is still 0.
327         *
328         * Params:
329         *     zeroTerminated = %TRUE if the array should have an extra element at
330         *         the end with all bits cleared
331         *     clear = %TRUE if all bits in the array should be cleared to 0 on
332         *         allocation
333         *     elementSize = size of each element in the array
334         *     reservedSize = number of elements preallocated
335         *
336         * Returns: the new #GArray
337         */
338        public static ArrayG sizedNew(bool zeroTerminated, bool clear, uint elementSize, uint reservedSize)
339        {
340                auto p = g_array_sized_new(zeroTerminated, clear, elementSize, reservedSize);
341               
342                if(p is null)
343                {
344                        return null;
345                }
346               
347                return new ArrayG(cast(GArray*) p);
348        }
349
350        /**
351         * Sorts a #GArray using @compare_func which should be a qsort()-style
352         * comparison function (returns less than zero for first arg is less
353         * than second arg, zero for equal, greater zero if first arg is
354         * greater than second arg).
355         *
356         * This is guaranteed to be a stable sort since version 2.32.
357         *
358         * Params:
359         *     compareFunc = comparison function
360         */
361        public void sort(GCompareFunc compareFunc)
362        {
363                g_array_sort(gArray, compareFunc);
364        }
365
366        /**
367         * Like g_array_sort(), but the comparison function receives an extra
368         * user data argument.
369         *
370         * This is guaranteed to be a stable sort since version 2.32.
371         *
372         * There used to be a comment here about making the sort stable by
373         * using the addresses of the elements in the comparison function.
374         * This did not actually work, so any such code should be removed.
375         *
376         * Params:
377         *     compareFunc = comparison function
378         *     userData = data to pass to @compare_func
379         */
380        public void sortWithData(GCompareDataFunc compareFunc, void* userData)
381        {
382                g_array_sort_with_data(gArray, compareFunc, userData);
383        }
384
385        /**
386         * Atomically decrements the reference count of @array by one. If the
387         * reference count drops to 0, all memory allocated by the array is
388         * released. This function is MT-safe and may be called from any
389         * thread.
390         *
391         * Since: 2.22
392         */
393        public void unref()
394        {
395                g_array_unref(gArray);
396        }
397}
Note: See TracBrowser for help on using the repository browser.