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

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

Initial release

File size: 17.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 glib.ListSG;
22
23private import gi.glib;
24public  import gi.glibtypes;
25private import gobject.ObjectG;
26
27
28/**
29 * The #GSList struct is used for each element in the singly-linked
30 * list.
31 */
32public class ListSG
33{
34        /** the main Gtk struct */
35        protected GSList* gSList;
36        protected bool ownedRef;
37
38        /** Get the main Gtk struct */
39        public GSList* getListSGStruct()
40        {
41                return gSList;
42        }
43
44        /** the main Gtk struct as a void* */
45        protected void* getStruct()
46        {
47                return cast(void*)gSList;
48        }
49
50        /**
51         * Sets our main struct and passes it to the parent class.
52         */
53        public this (GSList* gSList, bool ownedRef = false)
54        {
55                this.gSList = gSList;
56                this.ownedRef = ownedRef;
57        }
58
59        /** */
60        @property void* data()
61        {
62                return gSList.data;
63        }
64       
65        /**
66         * get the next element
67         * Returns: the next element, or NULL if there are no more elements.
68         */
69        @property ListSG next()
70        {
71                if ( gSList.next is null )
72                {
73                        return null;
74                }
75               
76                return new ListSG(gSList.next);
77        }
78       
79        /**
80         * Turn the list into a D array of the desiered type.
81         * Type T wraps should match the type of the data.
82         */
83        public T[] toArray(T, TC = typeof(T.tupleof[0]))()
84        {
85                T[] arr = new T[length()];
86                ListSG list = this;
87                size_t count;
88               
89                while(list !is null && count < arr.length)
90                {
91                        arr[count] = ObjectG.getDObject!(T)(cast(TC)list.data);
92                        list = list.next();
93                        count++;
94                }
95               
96                return arr;
97        }
98       
99        unittest
100        {
101                import gobject.Value;
102               
103                auto list = new ListSG(null);
104                list = list.append(new Value(0).getValueStruct());
105                list = list.append(new Value(1).getValueStruct());
106                auto arr = list.toArray!Value();
107               
108                assert(arr[0].getInt() == 0);
109                assert(arr[1].getInt() == 1);
110        }
111
112        /**
113         */
114
115        /**
116         * Allocates space for one #GSList element. It is called by the
117         * g_slist_append(), g_slist_prepend(), g_slist_insert() and
118         * g_slist_insert_sorted() functions and so is rarely used on its own.
119         *
120         * Returns: a pointer to the newly-allocated #GSList element.
121         */
122        public static ListSG alloc()
123        {
124                auto p = g_slist_alloc();
125               
126                if(p is null)
127                {
128                        return null;
129                }
130               
131                return new ListSG(cast(GSList*) p);
132        }
133
134        /**
135         * Adds a new element on to the end of the list.
136         *
137         * The return value is the new start of the list, which may
138         * have changed, so make sure you store the new value.
139         *
140         * Note that g_slist_append() has to traverse the entire list
141         * to find the end, which is inefficient when adding multiple
142         * elements. A common idiom to avoid the inefficiency is to prepend
143         * the elements and reverse the list when all elements have been added.
144         *
145         * |[<!-- language="C" -->
146         * // Notice that these are initialized to the empty list.
147         * GSList *list = NULL, *number_list = NULL;
148         *
149         * // This is a list of strings.
150         * list = g_slist_append (list, "first");
151         * list = g_slist_append (list, "second");
152         *
153         * // This is a list of integers.
154         * number_list = g_slist_append (number_list, GINT_TO_POINTER (27));
155         * number_list = g_slist_append (number_list, GINT_TO_POINTER (14));
156         * ]|
157         *
158         * Params:
159         *     data = the data for the new element
160         *
161         * Returns: the new start of the #GSList
162         */
163        public ListSG append(void* data)
164        {
165                auto p = g_slist_append(gSList, data);
166               
167                if(p is null)
168                {
169                        return null;
170                }
171               
172                return new ListSG(cast(GSList*) p);
173        }
174
175        /**
176         * Adds the second #GSList onto the end of the first #GSList.
177         * Note that the elements of the second #GSList are not copied.
178         * They are used directly.
179         *
180         * Params:
181         *     list2 = the #GSList to add to the end of the first #GSList
182         *
183         * Returns: the start of the new #GSList
184         */
185        public ListSG concat(ListSG list2)
186        {
187                auto p = g_slist_concat(gSList, (list2 is null) ? null : list2.getListSGStruct());
188               
189                if(p is null)
190                {
191                        return null;
192                }
193               
194                return new ListSG(cast(GSList*) p);
195        }
196
197        /**
198         * Copies a #GSList.
199         *
200         * Note that this is a "shallow" copy. If the list elements
201         * consist of pointers to data, the pointers are copied but
202         * the actual data isn't. See g_slist_copy_deep() if you need
203         * to copy the data as well.
204         *
205         * Returns: a copy of @list
206         */
207        public ListSG copy()
208        {
209                auto p = g_slist_copy(gSList);
210               
211                if(p is null)
212                {
213                        return null;
214                }
215               
216                return new ListSG(cast(GSList*) p);
217        }
218
219        /**
220         * Makes a full (deep) copy of a #GSList.
221         *
222         * In contrast with g_slist_copy(), this function uses @func to make a copy of
223         * each list element, in addition to copying the list container itself.
224         *
225         * @func, as a #GCopyFunc, takes two arguments, the data to be copied and a user
226         * pointer. It's safe to pass #NULL as user_data, if the copy function takes only
227         * one argument.
228         *
229         * For instance, if @list holds a list of GObjects, you can do:
230         * |[<!-- language="C" -->
231         * another_list = g_slist_copy_deep (list, (GCopyFunc) g_object_ref, NULL);
232         * ]|
233         *
234         * And, to entirely free the new list, you could do:
235         * |[<!-- language="C" -->
236         * g_slist_free_full (another_list, g_object_unref);
237         * ]|
238         *
239         * Params:
240         *     func = a copy function used to copy every element in the list
241         *     userData = user data passed to the copy function @func, or #NULL
242         *
243         * Returns: a full copy of @list, use #g_slist_free_full to free it
244         *
245         * Since: 2.34
246         */
247        public ListSG copyDeep(GCopyFunc func, void* userData)
248        {
249                auto p = g_slist_copy_deep(gSList, func, userData);
250               
251                if(p is null)
252                {
253                        return null;
254                }
255               
256                return new ListSG(cast(GSList*) p);
257        }
258
259        /**
260         * Removes the node link_ from the list and frees it.
261         * Compare this to g_slist_remove_link() which removes the node
262         * without freeing it.
263         *
264         * Removing arbitrary nodes from a singly-linked list requires time
265         * that is proportional to the length of the list (ie. O(n)). If you
266         * find yourself using g_slist_delete_link() frequently, you should
267         * consider a different data structure, such as the doubly-linked
268         * #GList.
269         *
270         * Params:
271         *     link = node to delete
272         *
273         * Returns: the new head of @list
274         */
275        public ListSG deleteLink(ListSG link)
276        {
277                auto p = g_slist_delete_link(gSList, (link is null) ? null : link.getListSGStruct());
278               
279                if(p is null)
280                {
281                        return null;
282                }
283               
284                return new ListSG(cast(GSList*) p);
285        }
286
287        /**
288         * Finds the element in a #GSList which
289         * contains the given data.
290         *
291         * Params:
292         *     data = the element data to find
293         *
294         * Returns: the found #GSList element,
295         *     or %NULL if it is not found
296         */
297        public ListSG find(void* data)
298        {
299                auto p = g_slist_find(gSList, data);
300               
301                if(p is null)
302                {
303                        return null;
304                }
305               
306                return new ListSG(cast(GSList*) p);
307        }
308
309        /**
310         * Finds an element in a #GSList, using a supplied function to
311         * find the desired element. It iterates over the list, calling
312         * the given function which should return 0 when the desired
313         * element is found. The function takes two #gconstpointer arguments,
314         * the #GSList element's data as the first argument and the
315         * given user data.
316         *
317         * Params:
318         *     data = user data passed to the function
319         *     func = the function to call for each element.
320         *         It should return 0 when the desired element is found
321         *
322         * Returns: the found #GSList element, or %NULL if it is not found
323         */
324        public ListSG findCustom(void* data, GCompareFunc func)
325        {
326                auto p = g_slist_find_custom(gSList, data, func);
327               
328                if(p is null)
329                {
330                        return null;
331                }
332               
333                return new ListSG(cast(GSList*) p);
334        }
335
336        /**
337         * Calls a function for each element of a #GSList.
338         *
339         * Params:
340         *     func = the function to call with each element's data
341         *     userData = user data to pass to the function
342         */
343        public void foreac(GFunc func, void* userData)
344        {
345                g_slist_foreach(gSList, func, userData);
346        }
347
348        /**
349         * Frees all of the memory used by a #GSList.
350         * The freed elements are returned to the slice allocator.
351         *
352         * If list elements contain dynamically-allocated memory,
353         * you should either use g_slist_free_full() or free them manually
354         * first.
355         */
356        public void free()
357        {
358                g_slist_free(gSList);
359        }
360
361        /**
362         * Frees one #GSList element.
363         * It is usually used after g_slist_remove_link().
364         */
365        public void free1()
366        {
367                g_slist_free_1(gSList);
368        }
369
370        /**
371         * Convenience method, which frees all the memory used by a #GSList, and
372         * calls the specified destroy function on every element's data.
373         *
374         * Params:
375         *     freeFunc = the function to be called to free each element's data
376         *
377         * Since: 2.28
378         */
379        public void freeFull(GDestroyNotify freeFunc)
380        {
381                g_slist_free_full(gSList, freeFunc);
382        }
383
384        /**
385         * Gets the position of the element containing
386         * the given data (starting from 0).
387         *
388         * Params:
389         *     data = the data to find
390         *
391         * Returns: the index of the element containing the data,
392         *     or -1 if the data is not found
393         */
394        public int index(void* data)
395        {
396                return g_slist_index(gSList, data);
397        }
398
399        /**
400         * Inserts a new element into the list at the given position.
401         *
402         * Params:
403         *     data = the data for the new element
404         *     position = the position to insert the element.
405         *         If this is negative, or is larger than the number
406         *         of elements in the list, the new element is added on
407         *         to the end of the list.
408         *
409         * Returns: the new start of the #GSList
410         */
411        public ListSG insert(void* data, int position)
412        {
413                auto p = g_slist_insert(gSList, data, position);
414               
415                if(p is null)
416                {
417                        return null;
418                }
419               
420                return new ListSG(cast(GSList*) p);
421        }
422
423        /**
424         * Inserts a node before @sibling containing @data.
425         *
426         * Params:
427         *     sibling = node to insert @data before
428         *     data = data to put in the newly-inserted node
429         *
430         * Returns: the new head of the list.
431         */
432        public ListSG insertBefore(ListSG sibling, void* data)
433        {
434                auto p = g_slist_insert_before(gSList, (sibling is null) ? null : sibling.getListSGStruct(), data);
435               
436                if(p is null)
437                {
438                        return null;
439                }
440               
441                return new ListSG(cast(GSList*) p);
442        }
443
444        /**
445         * Inserts a new element into the list, using the given
446         * comparison function to determine its position.
447         *
448         * Params:
449         *     data = the data for the new element
450         *     func = the function to compare elements in the list.
451         *         It should return a number > 0 if the first parameter
452         *         comes after the second parameter in the sort order.
453         *
454         * Returns: the new start of the #GSList
455         */
456        public ListSG insertSorted(void* data, GCompareFunc func)
457        {
458                auto p = g_slist_insert_sorted(gSList, data, func);
459               
460                if(p is null)
461                {
462                        return null;
463                }
464               
465                return new ListSG(cast(GSList*) p);
466        }
467
468        /**
469         * Inserts a new element into the list, using the given
470         * comparison function to determine its position.
471         *
472         * Params:
473         *     data = the data for the new element
474         *     func = the function to compare elements in the list.
475         *         It should return a number > 0 if the first parameter
476         *         comes after the second parameter in the sort order.
477         *     userData = data to pass to comparison function
478         *
479         * Returns: the new start of the #GSList
480         *
481         * Since: 2.10
482         */
483        public ListSG insertSortedWithData(void* data, GCompareDataFunc func, void* userData)
484        {
485                auto p = g_slist_insert_sorted_with_data(gSList, data, func, userData);
486               
487                if(p is null)
488                {
489                        return null;
490                }
491               
492                return new ListSG(cast(GSList*) p);
493        }
494
495        /**
496         * Gets the last element in a #GSList.
497         *
498         * This function iterates over the whole list.
499         *
500         * Returns: the last element in the #GSList,
501         *     or %NULL if the #GSList has no elements
502         */
503        public ListSG last()
504        {
505                auto p = g_slist_last(gSList);
506               
507                if(p is null)
508                {
509                        return null;
510                }
511               
512                return new ListSG(cast(GSList*) p);
513        }
514
515        /**
516         * Gets the number of elements in a #GSList.
517         *
518         * This function iterates over the whole list to
519         * count its elements. To check whether the list is non-empty, it is faster to
520         * check @list against %NULL.
521         *
522         * Returns: the number of elements in the #GSList
523         */
524        public uint length()
525        {
526                return g_slist_length(gSList);
527        }
528
529        /**
530         * Gets the element at the given position in a #GSList.
531         *
532         * Params:
533         *     n = the position of the element, counting from 0
534         *
535         * Returns: the element, or %NULL if the position is off
536         *     the end of the #GSList
537         */
538        public ListSG nth(uint n)
539        {
540                auto p = g_slist_nth(gSList, n);
541               
542                if(p is null)
543                {
544                        return null;
545                }
546               
547                return new ListSG(cast(GSList*) p);
548        }
549
550        /**
551         * Gets the data of the element at the given position.
552         *
553         * Params:
554         *     n = the position of the element
555         *
556         * Returns: the element's data, or %NULL if the position
557         *     is off the end of the #GSList
558         */
559        public void* nthData(uint n)
560        {
561                return g_slist_nth_data(gSList, n);
562        }
563
564        /**
565         * Gets the position of the given element
566         * in the #GSList (starting from 0).
567         *
568         * Params:
569         *     llink = an element in the #GSList
570         *
571         * Returns: the position of the element in the #GSList,
572         *     or -1 if the element is not found
573         */
574        public int position(ListSG llink)
575        {
576                return g_slist_position(gSList, (llink is null) ? null : llink.getListSGStruct());
577        }
578
579        /**
580         * Adds a new element on to the start of the list.
581         *
582         * The return value is the new start of the list, which
583         * may have changed, so make sure you store the new value.
584         *
585         * |[<!-- language="C" -->
586         * // Notice that it is initialized to the empty list.
587         * GSList *list = NULL;
588         * list = g_slist_prepend (list, "last");
589         * list = g_slist_prepend (list, "first");
590         * ]|
591         *
592         * Params:
593         *     data = the data for the new element
594         *
595         * Returns: the new start of the #GSList
596         */
597        public ListSG prepend(void* data)
598        {
599                auto p = g_slist_prepend(gSList, data);
600               
601                if(p is null)
602                {
603                        return null;
604                }
605               
606                return new ListSG(cast(GSList*) p);
607        }
608
609        /**
610         * Removes an element from a #GSList.
611         * If two elements contain the same data, only the first is removed.
612         * If none of the elements contain the data, the #GSList is unchanged.
613         *
614         * Params:
615         *     data = the data of the element to remove
616         *
617         * Returns: the new start of the #GSList
618         */
619        public ListSG remove(void* data)
620        {
621                auto p = g_slist_remove(gSList, data);
622               
623                if(p is null)
624                {
625                        return null;
626                }
627               
628                return new ListSG(cast(GSList*) p);
629        }
630
631        /**
632         * Removes all list nodes with data equal to @data.
633         * Returns the new head of the list. Contrast with
634         * g_slist_remove() which removes only the first node
635         * matching the given data.
636         *
637         * Params:
638         *     data = data to remove
639         *
640         * Returns: new head of @list
641         */
642        public ListSG removeAll(void* data)
643        {
644                auto p = g_slist_remove_all(gSList, data);
645               
646                if(p is null)
647                {
648                        return null;
649                }
650               
651                return new ListSG(cast(GSList*) p);
652        }
653
654        /**
655         * Removes an element from a #GSList, without
656         * freeing the element. The removed element's next
657         * link is set to %NULL, so that it becomes a
658         * self-contained list with one element.
659         *
660         * Removing arbitrary nodes from a singly-linked list
661         * requires time that is proportional to the length of the list
662         * (ie. O(n)). If you find yourself using g_slist_remove_link()
663         * frequently, you should consider a different data structure,
664         * such as the doubly-linked #GList.
665         *
666         * Params:
667         *     link = an element in the #GSList
668         *
669         * Returns: the new start of the #GSList, without the element
670         */
671        public ListSG removeLink(ListSG link)
672        {
673                auto p = g_slist_remove_link(gSList, (link is null) ? null : link.getListSGStruct());
674               
675                if(p is null)
676                {
677                        return null;
678                }
679               
680                return new ListSG(cast(GSList*) p);
681        }
682
683        /**
684         * Reverses a #GSList.
685         *
686         * Returns: the start of the reversed #GSList
687         */
688        public ListSG reverse()
689        {
690                auto p = g_slist_reverse(gSList);
691               
692                if(p is null)
693                {
694                        return null;
695                }
696               
697                return new ListSG(cast(GSList*) p);
698        }
699
700        /**
701         * Sorts a #GSList using the given comparison function.
702         *
703         * Params:
704         *     compareFunc = the comparison function used to sort the #GSList.
705         *         This function is passed the data from 2 elements of the #GSList
706         *         and should return 0 if they are equal, a negative value if the
707         *         first element comes before the second, or a positive value if
708         *         the first element comes after the second.
709         *
710         * Returns: the start of the sorted #GSList
711         */
712        public ListSG sort(GCompareFunc compareFunc)
713        {
714                auto p = g_slist_sort(gSList, compareFunc);
715               
716                if(p is null)
717                {
718                        return null;
719                }
720               
721                return new ListSG(cast(GSList*) p);
722        }
723
724        /**
725         * Like g_slist_sort(), but the sort function accepts a user data argument.
726         *
727         * Params:
728         *     compareFunc = comparison function
729         *     userData = data to pass to comparison function
730         *
731         * Returns: new head of the list
732         */
733        public ListSG sortWithData(GCompareDataFunc compareFunc, void* userData)
734        {
735                auto p = g_slist_sort_with_data(gSList, compareFunc, userData);
736               
737                if(p is null)
738                {
739                        return null;
740                }
741               
742                return new ListSG(cast(GSList*) p);
743        }
744}
Note: See TracBrowser for help on using the repository browser.