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

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

Initial release

File size: 8.6 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.ByteArray;
22
23private import gi.glib;
24public  import gi.glibtypes;
25private import glib.Bytes;
26private import glib.ConstructionException;
27
28
29/**
30 * Contains the public fields of a GByteArray.
31 */
32public class ByteArray
33{
34        /** the main Gtk struct */
35        protected GByteArray* gByteArray;
36        protected bool ownedRef;
37
38        /** Get the main Gtk struct */
39        public GByteArray* getByteArrayStruct()
40        {
41                return gByteArray;
42        }
43
44        /** the main Gtk struct as a void* */
45        protected void* getStruct()
46        {
47                return cast(void*)gByteArray;
48        }
49
50        /**
51         * Sets our main struct and passes it to the parent class.
52         */
53        public this (GByteArray* gByteArray, bool ownedRef = false)
54        {
55                this.gByteArray = gByteArray;
56                this.ownedRef = ownedRef;
57        }
58
59
60        /**
61         * Adds the given bytes to the end of the #GByteArray.
62         * The array will grow in size automatically if necessary.
63         *
64         * Params:
65         *     data = the byte data to be added
66         *     len = the number of bytes to add
67         *
68         * Returns: the #GByteArray
69         */
70        public ByteArray append(ubyte* data, uint len)
71        {
72                auto p = g_byte_array_append(gByteArray, data, len);
73               
74                if(p is null)
75                {
76                        return null;
77                }
78               
79                return new ByteArray(cast(GByteArray*) p);
80        }
81
82        /**
83         * Frees the memory allocated by the #GByteArray. If @free_segment is
84         * %TRUE it frees the actual byte data. If the reference count of
85         * @array is greater than one, the #GByteArray wrapper is preserved but
86         * the size of @array will be set to zero.
87         *
88         * Params:
89         *     freeSegment = if %TRUE the actual byte data is freed as well
90         *
91         * Returns: the element data if @free_segment is %FALSE, otherwise
92         *     %NULL.  The element data should be freed using g_free().
93         */
94        public ubyte* free(bool freeSegment)
95        {
96                return g_byte_array_free(gByteArray, freeSegment);
97        }
98
99        /**
100         * Transfers the data from the #GByteArray into a new immutable #GBytes.
101         *
102         * The #GByteArray is freed unless the reference count of @array is greater
103         * than one, the #GByteArray wrapper is preserved but the size of @array
104         * will be set to zero.
105         *
106         * This is identical to using g_bytes_new_take() and g_byte_array_free()
107         * together.
108         *
109         * Returns: a new immutable #GBytes representing same
110         *     byte data that was in the array
111         *
112         * Since: 2.32
113         */
114        public Bytes freeToBytes()
115        {
116                auto p = g_byte_array_free_to_bytes(gByteArray);
117               
118                if(p is null)
119                {
120                        return null;
121                }
122               
123                return new Bytes(cast(GBytes*) p, true);
124        }
125
126        /**
127         * Creates a new #GByteArray with a reference count of 1.
128         *
129         * Returns: the new #GByteArray
130         *
131         * Throws: ConstructionException GTK+ fails to create the object.
132         */
133        public this()
134        {
135                auto p = g_byte_array_new();
136               
137                if(p is null)
138                {
139                        throw new ConstructionException("null returned by new");
140                }
141               
142                this(cast(GByteArray*) p);
143        }
144
145        /**
146         * Create byte array containing the data. The data will be owned by the array
147         * and will be freed with g_free(), i.e. it could be allocated using g_strdup().
148         *
149         * Params:
150         *     data = byte data for the array
151         *     len = length of @data
152         *
153         * Returns: a new #GByteArray
154         *
155         * Since: 2.32
156         *
157         * Throws: ConstructionException GTK+ fails to create the object.
158         */
159        public this(ubyte[] data)
160        {
161                auto p = g_byte_array_new_take(data.ptr, cast(size_t)data.length);
162               
163                if(p is null)
164                {
165                        throw new ConstructionException("null returned by new_take");
166                }
167               
168                this(cast(GByteArray*) p);
169        }
170
171        /**
172         * Adds the given data to the start of the #GByteArray.
173         * The array will grow in size automatically if necessary.
174         *
175         * Params:
176         *     data = the byte data to be added
177         *     len = the number of bytes to add
178         *
179         * Returns: the #GByteArray
180         */
181        public ByteArray prepend(ubyte* data, uint len)
182        {
183                auto p = g_byte_array_prepend(gByteArray, data, len);
184               
185                if(p is null)
186                {
187                        return null;
188                }
189               
190                return new ByteArray(cast(GByteArray*) p);
191        }
192
193        /**
194         * Atomically increments the reference count of @array by one.
195         * This function is thread-safe and may be called from any thread.
196         *
197         * Returns: The passed in #GByteArray
198         *
199         * Since: 2.22
200         */
201        public ByteArray doref()
202        {
203                auto p = g_byte_array_ref(gByteArray);
204               
205                if(p is null)
206                {
207                        return null;
208                }
209               
210                return new ByteArray(cast(GByteArray*) p);
211        }
212
213        /**
214         * Removes the byte at the given index from a #GByteArray.
215         * The following bytes are moved down one place.
216         *
217         * Params:
218         *     index = the index of the byte to remove
219         *
220         * Returns: the #GByteArray
221         */
222        public ByteArray removeIndex(uint index)
223        {
224                auto p = g_byte_array_remove_index(gByteArray, index);
225               
226                if(p is null)
227                {
228                        return null;
229                }
230               
231                return new ByteArray(cast(GByteArray*) p);
232        }
233
234        /**
235         * Removes the byte at the given index from a #GByteArray. The last
236         * element in the array is used to fill in the space, so this function
237         * does not preserve the order of the #GByteArray. But it is faster
238         * than g_byte_array_remove_index().
239         *
240         * Params:
241         *     index = the index of the byte to remove
242         *
243         * Returns: the #GByteArray
244         */
245        public ByteArray removeIndexFast(uint index)
246        {
247                auto p = g_byte_array_remove_index_fast(gByteArray, index);
248               
249                if(p is null)
250                {
251                        return null;
252                }
253               
254                return new ByteArray(cast(GByteArray*) p);
255        }
256
257        /**
258         * Removes the given number of bytes starting at the given index from a
259         * #GByteArray.  The following elements are moved to close the gap.
260         *
261         * Params:
262         *     index = the index of the first byte to remove
263         *     length = the number of bytes to remove
264         *
265         * Returns: the #GByteArray
266         *
267         * Since: 2.4
268         */
269        public ByteArray removeRange(uint index, uint length)
270        {
271                auto p = g_byte_array_remove_range(gByteArray, index, length);
272               
273                if(p is null)
274                {
275                        return null;
276                }
277               
278                return new ByteArray(cast(GByteArray*) p);
279        }
280
281        /**
282         * Sets the size of the #GByteArray, expanding it if necessary.
283         *
284         * Params:
285         *     length = the new size of the #GByteArray
286         *
287         * Returns: the #GByteArray
288         */
289        public ByteArray setSize(uint length)
290        {
291                auto p = g_byte_array_set_size(gByteArray, length);
292               
293                if(p is null)
294                {
295                        return null;
296                }
297               
298                return new ByteArray(cast(GByteArray*) p);
299        }
300
301        /**
302         * Creates a new #GByteArray with @reserved_size bytes preallocated.
303         * This avoids frequent reallocation, if you are going to add many
304         * bytes to the array. Note however that the size of the array is still
305         * 0.
306         *
307         * Params:
308         *     reservedSize = number of bytes preallocated
309         *
310         * Returns: the new #GByteArray
311         */
312        public static ByteArray sizedNew(uint reservedSize)
313        {
314                auto p = g_byte_array_sized_new(reservedSize);
315               
316                if(p is null)
317                {
318                        return null;
319                }
320               
321                return new ByteArray(cast(GByteArray*) p);
322        }
323
324        /**
325         * Sorts a byte array, using @compare_func which should be a
326         * qsort()-style comparison function (returns less than zero for first
327         * arg is less than second arg, zero for equal, greater than zero if
328         * first arg is greater than second arg).
329         *
330         * If two array elements compare equal, their order in the sorted array
331         * is undefined. If you want equal elements to keep their order (i.e.
332         * you want a stable sort) you can write a comparison function that,
333         * if two elements would otherwise compare equal, compares them by
334         * their addresses.
335         *
336         * Params:
337         *     compareFunc = comparison function
338         */
339        public void sort(GCompareFunc compareFunc)
340        {
341                g_byte_array_sort(gByteArray, compareFunc);
342        }
343
344        /**
345         * Like g_byte_array_sort(), but the comparison function takes an extra
346         * user data argument.
347         *
348         * Params:
349         *     compareFunc = comparison function
350         *     userData = data to pass to @compare_func
351         */
352        public void sortWithData(GCompareDataFunc compareFunc, void* userData)
353        {
354                g_byte_array_sort_with_data(gByteArray, compareFunc, userData);
355        }
356
357        /**
358         * Atomically decrements the reference count of @array by one. If the
359         * reference count drops to 0, all memory allocated by the array is
360         * released. This function is thread-safe and may be called from any
361         * thread.
362         *
363         * Since: 2.22
364         */
365        public void unref()
366        {
367                g_byte_array_unref(gByteArray);
368        }
369}
Note: See TracBrowser for help on using the repository browser.