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

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

Initial release

File size: 7.0 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 gobject.ValueArray;
22
23private import gi.gobject;
24public  import gi.gobjecttypes;
25private import glib.ConstructionException;
26private import gobject.ObjectG;
27private import gobject.Value;
28
29
30/**
31 * A #GValueArray contains an array of #GValue elements.
32 */
33public class ValueArray
34{
35        /** the main Gtk struct */
36        protected GValueArray* gValueArray;
37        protected bool ownedRef;
38
39        /** Get the main Gtk struct */
40        public GValueArray* getValueArrayStruct()
41        {
42                return gValueArray;
43        }
44
45        /** the main Gtk struct as a void* */
46        protected void* getStruct()
47        {
48                return cast(void*)gValueArray;
49        }
50
51        /**
52         * Sets our main struct and passes it to the parent class.
53         */
54        public this (GValueArray* gValueArray, bool ownedRef = false)
55        {
56                this.gValueArray = gValueArray;
57                this.ownedRef = ownedRef;
58        }
59
60
61        /** */
62        public static GType getType()
63        {
64                return g_value_array_get_type();
65        }
66
67        /**
68         * Allocate and initialize a new #GValueArray, optionally preserve space
69         * for @n_prealloced elements. New arrays always contain 0 elements,
70         * regardless of the value of @n_prealloced.
71         *
72         * Deprecated: Use #GArray and g_array_sized_new() instead.
73         *
74         * Params:
75         *     nPrealloced = number of values to preallocate space for
76         *
77         * Returns: a newly allocated #GValueArray with 0 values
78         *
79         * Throws: ConstructionException GTK+ fails to create the object.
80         */
81        public this(uint nPrealloced)
82        {
83                auto p = g_value_array_new(nPrealloced);
84               
85                if(p is null)
86                {
87                        throw new ConstructionException("null returned by new");
88                }
89               
90                this(cast(GValueArray*) p);
91        }
92
93        /**
94         * Insert a copy of @value as last element of @value_array. If @value is
95         * %NULL, an uninitialized value is appended.
96         *
97         * Deprecated: Use #GArray and g_array_append_val() instead.
98         *
99         * Params:
100         *     value = #GValue to copy into #GValueArray, or %NULL
101         *
102         * Returns: the #GValueArray passed in as @value_array
103         */
104        public ValueArray append(Value value)
105        {
106                auto p = g_value_array_append(gValueArray, (value is null) ? null : value.getValueStruct());
107               
108                if(p is null)
109                {
110                        return null;
111                }
112               
113                return ObjectG.getDObject!(ValueArray)(cast(GValueArray*) p);
114        }
115
116        /**
117         * Construct an exact copy of a #GValueArray by duplicating all its
118         * contents.
119         *
120         * Deprecated: Use #GArray and g_array_ref() instead.
121         *
122         * Returns: Newly allocated copy of #GValueArray
123         */
124        public ValueArray copy()
125        {
126                auto p = g_value_array_copy(gValueArray);
127               
128                if(p is null)
129                {
130                        return null;
131                }
132               
133                return ObjectG.getDObject!(ValueArray)(cast(GValueArray*) p, true);
134        }
135
136        /**
137         * Free a #GValueArray including its contents.
138         *
139         * Deprecated: Use #GArray and g_array_unref() instead.
140         */
141        public void free()
142        {
143                g_value_array_free(gValueArray);
144        }
145
146        /**
147         * Return a pointer to the value at @index_ containd in @value_array.
148         *
149         * Deprecated: Use g_array_index() instead.
150         *
151         * Params:
152         *     index = index of the value of interest
153         *
154         * Returns: pointer to a value at @index_ in @value_array
155         */
156        public Value getNth(uint index)
157        {
158                auto p = g_value_array_get_nth(gValueArray, index);
159               
160                if(p is null)
161                {
162                        return null;
163                }
164               
165                return ObjectG.getDObject!(Value)(cast(GValue*) p);
166        }
167
168        /**
169         * Insert a copy of @value at specified position into @value_array. If @value
170         * is %NULL, an uninitialized value is inserted.
171         *
172         * Deprecated: Use #GArray and g_array_insert_val() instead.
173         *
174         * Params:
175         *     index = insertion position, must be <= value_array-&gt;n_values
176         *     value = #GValue to copy into #GValueArray, or %NULL
177         *
178         * Returns: the #GValueArray passed in as @value_array
179         */
180        public ValueArray insert(uint index, Value value)
181        {
182                auto p = g_value_array_insert(gValueArray, index, (value is null) ? null : value.getValueStruct());
183               
184                if(p is null)
185                {
186                        return null;
187                }
188               
189                return ObjectG.getDObject!(ValueArray)(cast(GValueArray*) p);
190        }
191
192        /**
193         * Insert a copy of @value as first element of @value_array. If @value is
194         * %NULL, an uninitialized value is prepended.
195         *
196         * Deprecated: Use #GArray and g_array_prepend_val() instead.
197         *
198         * Params:
199         *     value = #GValue to copy into #GValueArray, or %NULL
200         *
201         * Returns: the #GValueArray passed in as @value_array
202         */
203        public ValueArray prepend(Value value)
204        {
205                auto p = g_value_array_prepend(gValueArray, (value is null) ? null : value.getValueStruct());
206               
207                if(p is null)
208                {
209                        return null;
210                }
211               
212                return ObjectG.getDObject!(ValueArray)(cast(GValueArray*) p);
213        }
214
215        /**
216         * Remove the value at position @index_ from @value_array.
217         *
218         * Deprecated: Use #GArray and g_array_remove_index() instead.
219         *
220         * Params:
221         *     index = position of value to remove, which must be less than
222         *         @value_array->n_values
223         *
224         * Returns: the #GValueArray passed in as @value_array
225         */
226        public ValueArray remove(uint index)
227        {
228                auto p = g_value_array_remove(gValueArray, index);
229               
230                if(p is null)
231                {
232                        return null;
233                }
234               
235                return ObjectG.getDObject!(ValueArray)(cast(GValueArray*) p);
236        }
237
238        /**
239         * Sort @value_array using @compare_func to compare the elements according to
240         * the semantics of #GCompareFunc.
241         *
242         * The current implementation uses the same sorting algorithm as standard
243         * C qsort() function.
244         *
245         * Deprecated: Use #GArray and g_array_sort().
246         *
247         * Params:
248         *     compareFunc = function to compare elements
249         *
250         * Returns: the #GValueArray passed in as @value_array
251         */
252        public ValueArray sort(GCompareFunc compareFunc)
253        {
254                auto p = g_value_array_sort(gValueArray, compareFunc);
255               
256                if(p is null)
257                {
258                        return null;
259                }
260               
261                return ObjectG.getDObject!(ValueArray)(cast(GValueArray*) p);
262        }
263
264        /**
265         * Sort @value_array using @compare_func to compare the elements according
266         * to the semantics of #GCompareDataFunc.
267         *
268         * The current implementation uses the same sorting algorithm as standard
269         * C qsort() function.
270         *
271         * Deprecated: Use #GArray and g_array_sort_with_data().
272         *
273         * Params:
274         *     compareFunc = function to compare elements
275         *     userData = extra data argument provided for @compare_func
276         *
277         * Returns: the #GValueArray passed in as @value_array
278         */
279        public ValueArray sortWithData(GCompareDataFunc compareFunc, void* userData)
280        {
281                auto p = g_value_array_sort_with_data(gValueArray, compareFunc, userData);
282               
283                if(p is null)
284                {
285                        return null;
286                }
287               
288                return ObjectG.getDObject!(ValueArray)(cast(GValueArray*) p);
289        }
290}
Note: See TracBrowser for help on using the repository browser.