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

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

Initial release

File size: 16.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.StringG;
22
23private import gi.glib;
24public  import gi.glibtypes;
25private import glib.Bytes;
26private import glib.Str;
27
28
29/**
30 * The GString struct contains the public fields of a GString.
31 */
32public class StringG
33{
34        /** the main Gtk struct */
35        protected GString* gString;
36        protected bool ownedRef;
37
38        /** Get the main Gtk struct */
39        public GString* getStringGStruct()
40        {
41                return gString;
42        }
43
44        /** the main Gtk struct as a void* */
45        protected void* getStruct()
46        {
47                return cast(void*)gString;
48        }
49
50        /**
51         * Sets our main struct and passes it to the parent class.
52         */
53        public this (GString* gString, bool ownedRef = false)
54        {
55                this.gString = gString;
56                this.ownedRef = ownedRef;
57        }
58
59
60        /**
61         * Adds a string onto the end of a #GString, expanding
62         * it if necessary.
63         *
64         * Params:
65         *     val = the string to append onto the end of @string
66         *
67         * Returns: @string
68         */
69        public StringG append(string val)
70        {
71                auto p = g_string_append(gString, Str.toStringz(val));
72               
73                if(p is null)
74                {
75                        return null;
76                }
77               
78                return new StringG(cast(GString*) p, true);
79        }
80
81        /**
82         * Adds a byte onto the end of a #GString, expanding
83         * it if necessary.
84         *
85         * Params:
86         *     c = the byte to append onto the end of @string
87         *
88         * Returns: @string
89         */
90        public StringG appendC(char c)
91        {
92                auto p = g_string_append_c(gString, c);
93               
94                if(p is null)
95                {
96                        return null;
97                }
98               
99                return new StringG(cast(GString*) p, true);
100        }
101
102        /**
103         * Appends @len bytes of @val to @string. Because @len is
104         * provided, @val may contain embedded nuls and need not
105         * be nul-terminated.
106         *
107         * Since this function does not stop at nul bytes, it is
108         * the caller's responsibility to ensure that @val has at
109         * least @len addressable bytes.
110         *
111         * Params:
112         *     val = bytes to append
113         *     len = number of bytes of @val to use
114         *
115         * Returns: @string
116         */
117        public StringG appendLen(string val, ptrdiff_t len)
118        {
119                auto p = g_string_append_len(gString, Str.toStringz(val), len);
120               
121                if(p is null)
122                {
123                        return null;
124                }
125               
126                return new StringG(cast(GString*) p, true);
127        }
128
129        /**
130         * Converts a Unicode character into UTF-8, and appends it
131         * to the string.
132         *
133         * Params:
134         *     wc = a Unicode character
135         *
136         * Returns: @string
137         */
138        public StringG appendUnichar(dchar wc)
139        {
140                auto p = g_string_append_unichar(gString, wc);
141               
142                if(p is null)
143                {
144                        return null;
145                }
146               
147                return new StringG(cast(GString*) p, true);
148        }
149
150        /**
151         * Appends @unescaped to @string, escaped any characters that
152         * are reserved in URIs using URI-style escape sequences.
153         *
154         * Params:
155         *     unescaped = a string
156         *     reservedCharsAllowed = a string of reserved characters allowed
157         *         to be used, or %NULL
158         *     allowUtf8 = set %TRUE if the escaped string may include UTF8 characters
159         *
160         * Returns: @string
161         *
162         * Since: 2.16
163         */
164        public StringG appendUriEscaped(string unescaped, string reservedCharsAllowed, bool allowUtf8)
165        {
166                auto p = g_string_append_uri_escaped(gString, Str.toStringz(unescaped), Str.toStringz(reservedCharsAllowed), allowUtf8);
167               
168                if(p is null)
169                {
170                        return null;
171                }
172               
173                return new StringG(cast(GString*) p, true);
174        }
175
176        /**
177         * Appends a formatted string onto the end of a #GString.
178         * This function is similar to g_string_append_printf()
179         * except that the arguments to the format string are passed
180         * as a va_list.
181         *
182         * Params:
183         *     format = the string format. See the printf() documentation
184         *     args = the list of arguments to insert in the output
185         *
186         * Since: 2.14
187         */
188        public void appendVprintf(string format, void* args)
189        {
190                g_string_append_vprintf(gString, Str.toStringz(format), args);
191        }
192
193        /**
194         * Converts all uppercase ASCII letters to lowercase ASCII letters.
195         *
196         * Returns: passed-in @string pointer, with all the
197         *     uppercase characters converted to lowercase in place,
198         *     with semantics that exactly match g_ascii_tolower().
199         */
200        public StringG asciiDown()
201        {
202                auto p = g_string_ascii_down(gString);
203               
204                if(p is null)
205                {
206                        return null;
207                }
208               
209                return new StringG(cast(GString*) p, true);
210        }
211
212        /**
213         * Converts all lowercase ASCII letters to uppercase ASCII letters.
214         *
215         * Returns: passed-in @string pointer, with all the
216         *     lowercase characters converted to uppercase in place,
217         *     with semantics that exactly match g_ascii_toupper().
218         */
219        public StringG asciiUp()
220        {
221                auto p = g_string_ascii_up(gString);
222               
223                if(p is null)
224                {
225                        return null;
226                }
227               
228                return new StringG(cast(GString*) p, true);
229        }
230
231        /**
232         * Copies the bytes from a string into a #GString,
233         * destroying any previous contents. It is rather like
234         * the standard strcpy() function, except that you do not
235         * have to worry about having enough space to copy the string.
236         *
237         * Params:
238         *     rval = the string to copy into @string
239         *
240         * Returns: @string
241         */
242        public StringG assign(string rval)
243        {
244                auto p = g_string_assign(gString, Str.toStringz(rval));
245               
246                if(p is null)
247                {
248                        return null;
249                }
250               
251                return new StringG(cast(GString*) p, true);
252        }
253
254        /**
255         * Converts a #GString to lowercase.
256         *
257         * Deprecated: This function uses the locale-specific
258         * tolower() function, which is almost never the right thing.
259         * Use g_string_ascii_down() or g_utf8_strdown() instead.
260         *
261         * Returns: the #GString
262         */
263        public StringG down()
264        {
265                auto p = g_string_down(gString);
266               
267                if(p is null)
268                {
269                        return null;
270                }
271               
272                return new StringG(cast(GString*) p, true);
273        }
274
275        /**
276         * Compares two strings for equality, returning %TRUE if they are equal.
277         * For use with #GHashTable.
278         *
279         * Params:
280         *     v2 = another #GString
281         *
282         * Returns: %TRUE if the strings are the same length and contain the
283         *     same bytes
284         */
285        public bool equal(StringG v2)
286        {
287                return g_string_equal(gString, (v2 is null) ? null : v2.getStringGStruct()) != 0;
288        }
289
290        /**
291         * Removes @len bytes from a #GString, starting at position @pos.
292         * The rest of the #GString is shifted down to fill the gap.
293         *
294         * Params:
295         *     pos = the position of the content to remove
296         *     len = the number of bytes to remove, or -1 to remove all
297         *         following bytes
298         *
299         * Returns: @string
300         */
301        public StringG erase(ptrdiff_t pos, ptrdiff_t len)
302        {
303                auto p = g_string_erase(gString, pos, len);
304               
305                if(p is null)
306                {
307                        return null;
308                }
309               
310                return new StringG(cast(GString*) p, true);
311        }
312
313        /**
314         * Frees the memory allocated for the #GString.
315         * If @free_segment is %TRUE it also frees the character data.  If
316         * it's %FALSE, the caller gains ownership of the buffer and must
317         * free it after use with g_free().
318         *
319         * Params:
320         *     freeSegment = if %TRUE, the actual character data is freed as well
321         *
322         * Returns: the character data of @string
323         *     (i.e. %NULL if @free_segment is %TRUE)
324         */
325        public string free(bool freeSegment)
326        {
327                auto retStr = g_string_free(gString, freeSegment);
328               
329                scope(exit) Str.freeString(retStr);
330                return Str.toString(retStr);
331        }
332
333        /**
334         * Transfers ownership of the contents of @string to a newly allocated
335         * #GBytes.  The #GString structure itself is deallocated, and it is
336         * therefore invalid to use @string after invoking this function.
337         *
338         * Note that while #GString ensures that its buffer always has a
339         * trailing nul character (not reflected in its "len"), the returned
340         * #GBytes does not include this extra nul; i.e. it has length exactly
341         * equal to the "len" member.
342         *
343         * Returns: A newly allocated #GBytes containing contents of @string; @string itself is freed
344         *
345         * Since: 2.34
346         */
347        public Bytes freeToBytes()
348        {
349                auto p = g_string_free_to_bytes(gString);
350               
351                if(p is null)
352                {
353                        return null;
354                }
355               
356                return new Bytes(cast(GBytes*) p, true);
357        }
358
359        /**
360         * Creates a hash code for @str; for use with #GHashTable.
361         *
362         * Returns: hash code for @str
363         */
364        public uint hash()
365        {
366                return g_string_hash(gString);
367        }
368
369        /**
370         * Inserts a copy of a string into a #GString,
371         * expanding it if necessary.
372         *
373         * Params:
374         *     pos = the position to insert the copy of the string
375         *     val = the string to insert
376         *
377         * Returns: @string
378         */
379        public StringG insert(ptrdiff_t pos, string val)
380        {
381                auto p = g_string_insert(gString, pos, Str.toStringz(val));
382               
383                if(p is null)
384                {
385                        return null;
386                }
387               
388                return new StringG(cast(GString*) p, true);
389        }
390
391        /**
392         * Inserts a byte into a #GString, expanding it if necessary.
393         *
394         * Params:
395         *     pos = the position to insert the byte
396         *     c = the byte to insert
397         *
398         * Returns: @string
399         */
400        public StringG insertC(ptrdiff_t pos, char c)
401        {
402                auto p = g_string_insert_c(gString, pos, c);
403               
404                if(p is null)
405                {
406                        return null;
407                }
408               
409                return new StringG(cast(GString*) p, true);
410        }
411
412        /**
413         * Inserts @len bytes of @val into @string at @pos.
414         * Because @len is provided, @val may contain embedded
415         * nuls and need not be nul-terminated. If @pos is -1,
416         * bytes are inserted at the end of the string.
417         *
418         * Since this function does not stop at nul bytes, it is
419         * the caller's responsibility to ensure that @val has at
420         * least @len addressable bytes.
421         *
422         * Params:
423         *     pos = position in @string where insertion should
424         *         happen, or -1 for at the end
425         *     val = bytes to insert
426         *     len = number of bytes of @val to insert
427         *
428         * Returns: @string
429         */
430        public StringG insertLen(ptrdiff_t pos, string val, ptrdiff_t len)
431        {
432                auto p = g_string_insert_len(gString, pos, Str.toStringz(val), len);
433               
434                if(p is null)
435                {
436                        return null;
437                }
438               
439                return new StringG(cast(GString*) p, true);
440        }
441
442        /**
443         * Converts a Unicode character into UTF-8, and insert it
444         * into the string at the given position.
445         *
446         * Params:
447         *     pos = the position at which to insert character, or -1
448         *         to append at the end of the string
449         *     wc = a Unicode character
450         *
451         * Returns: @string
452         */
453        public StringG insertUnichar(ptrdiff_t pos, dchar wc)
454        {
455                auto p = g_string_insert_unichar(gString, pos, wc);
456               
457                if(p is null)
458                {
459                        return null;
460                }
461               
462                return new StringG(cast(GString*) p, true);
463        }
464
465        /**
466         * Overwrites part of a string, lengthening it if necessary.
467         *
468         * Params:
469         *     pos = the position at which to start overwriting
470         *     val = the string that will overwrite the @string starting at @pos
471         *
472         * Returns: @string
473         *
474         * Since: 2.14
475         */
476        public StringG overwrite(size_t pos, string val)
477        {
478                auto p = g_string_overwrite(gString, pos, Str.toStringz(val));
479               
480                if(p is null)
481                {
482                        return null;
483                }
484               
485                return new StringG(cast(GString*) p, true);
486        }
487
488        /**
489         * Overwrites part of a string, lengthening it if necessary.
490         * This function will work with embedded nuls.
491         *
492         * Params:
493         *     pos = the position at which to start overwriting
494         *     val = the string that will overwrite the @string starting at @pos
495         *     len = the number of bytes to write from @val
496         *
497         * Returns: @string
498         *
499         * Since: 2.14
500         */
501        public StringG overwriteLen(size_t pos, string val, ptrdiff_t len)
502        {
503                auto p = g_string_overwrite_len(gString, pos, Str.toStringz(val), len);
504               
505                if(p is null)
506                {
507                        return null;
508                }
509               
510                return new StringG(cast(GString*) p, true);
511        }
512
513        /**
514         * Adds a string on to the start of a #GString,
515         * expanding it if necessary.
516         *
517         * Params:
518         *     val = the string to prepend on the start of @string
519         *
520         * Returns: @string
521         */
522        public StringG prepend(string val)
523        {
524                auto p = g_string_prepend(gString, Str.toStringz(val));
525               
526                if(p is null)
527                {
528                        return null;
529                }
530               
531                return new StringG(cast(GString*) p, true);
532        }
533
534        /**
535         * Adds a byte onto the start of a #GString,
536         * expanding it if necessary.
537         *
538         * Params:
539         *     c = the byte to prepend on the start of the #GString
540         *
541         * Returns: @string
542         */
543        public StringG prependC(char c)
544        {
545                auto p = g_string_prepend_c(gString, c);
546               
547                if(p is null)
548                {
549                        return null;
550                }
551               
552                return new StringG(cast(GString*) p, true);
553        }
554
555        /**
556         * Prepends @len bytes of @val to @string.
557         * Because @len is provided, @val may contain
558         * embedded nuls and need not be nul-terminated.
559         *
560         * Since this function does not stop at nul bytes,
561         * it is the caller's responsibility to ensure that
562         * @val has at least @len addressable bytes.
563         *
564         * Params:
565         *     val = bytes to prepend
566         *     len = number of bytes in @val to prepend
567         *
568         * Returns: @string
569         */
570        public StringG prependLen(string val, ptrdiff_t len)
571        {
572                auto p = g_string_prepend_len(gString, Str.toStringz(val), len);
573               
574                if(p is null)
575                {
576                        return null;
577                }
578               
579                return new StringG(cast(GString*) p, true);
580        }
581
582        /**
583         * Converts a Unicode character into UTF-8, and prepends it
584         * to the string.
585         *
586         * Params:
587         *     wc = a Unicode character
588         *
589         * Returns: @string
590         */
591        public StringG prependUnichar(dchar wc)
592        {
593                auto p = g_string_prepend_unichar(gString, wc);
594               
595                if(p is null)
596                {
597                        return null;
598                }
599               
600                return new StringG(cast(GString*) p, true);
601        }
602
603        /**
604         * Sets the length of a #GString. If the length is less than
605         * the current length, the string will be truncated. If the
606         * length is greater than the current length, the contents
607         * of the newly added area are undefined. (However, as
608         * always, string->str[string->len] will be a nul byte.)
609         *
610         * Params:
611         *     len = the new length
612         *
613         * Returns: @string
614         */
615        public StringG setSize(size_t len)
616        {
617                auto p = g_string_set_size(gString, len);
618               
619                if(p is null)
620                {
621                        return null;
622                }
623               
624                return new StringG(cast(GString*) p, true);
625        }
626
627        /**
628         * Cuts off the end of the GString, leaving the first @len bytes.
629         *
630         * Params:
631         *     len = the new size of @string
632         *
633         * Returns: @string
634         */
635        public StringG truncate(size_t len)
636        {
637                auto p = g_string_truncate(gString, len);
638               
639                if(p is null)
640                {
641                        return null;
642                }
643               
644                return new StringG(cast(GString*) p, true);
645        }
646
647        /**
648         * Converts a #GString to uppercase.
649         *
650         * Deprecated: This function uses the locale-specific
651         * toupper() function, which is almost never the right thing.
652         * Use g_string_ascii_up() or g_utf8_strup() instead.
653         *
654         * Returns: @string
655         */
656        public StringG up()
657        {
658                auto p = g_string_up(gString);
659               
660                if(p is null)
661                {
662                        return null;
663                }
664               
665                return new StringG(cast(GString*) p, true);
666        }
667
668        /**
669         * Writes a formatted string into a #GString.
670         * This function is similar to g_string_printf() except that
671         * the arguments to the format string are passed as a va_list.
672         *
673         * Params:
674         *     format = the string format. See the printf() documentation
675         *     args = the parameters to insert into the format string
676         *
677         * Since: 2.14
678         */
679        public void vprintf(string format, void* args)
680        {
681                g_string_vprintf(gString, Str.toStringz(format), args);
682        }
683
684        /**
685         * Creates a new #GString, initialized with the given string.
686         *
687         * Params:
688         *     init = the initial text to copy into the string, or %NULL to
689         *         start with an empty string.
690         *
691         * Returns: the new #GString
692         */
693        public static StringG stringNew(string init)
694        {
695                auto p = g_string_new(Str.toStringz(init));
696               
697                if(p is null)
698                {
699                        return null;
700                }
701               
702                return new StringG(cast(GString*) p, true);
703        }
704
705        /**
706         * Creates a new #GString with @len bytes of the @init buffer.
707         * Because a length is provided, @init need not be nul-terminated,
708         * and can contain embedded nul bytes.
709         *
710         * Since this function does not stop at nul bytes, it is the caller's
711         * responsibility to ensure that @init has at least @len addressable
712         * bytes.
713         *
714         * Params:
715         *     init = initial contents of the string
716         *     len = length of @init to use
717         *
718         * Returns: a new #GString
719         */
720        public static StringG stringNewLen(string init, ptrdiff_t len)
721        {
722                auto p = g_string_new_len(Str.toStringz(init), len);
723               
724                if(p is null)
725                {
726                        return null;
727                }
728               
729                return new StringG(cast(GString*) p, true);
730        }
731
732        /**
733         * Creates a new #GString, with enough space for @dfl_size
734         * bytes. This is useful if you are going to add a lot of
735         * text to the string and don't want it to be reallocated
736         * too often.
737         *
738         * Params:
739         *     dflSize = the default size of the space allocated to
740         *         hold the string
741         *
742         * Returns: the new #GString
743         */
744        public static StringG stringSizedNew(size_t dflSize)
745        {
746                auto p = g_string_sized_new(dflSize);
747               
748                if(p is null)
749                {
750                        return null;
751                }
752               
753                return new StringG(cast(GString*) p, true);
754        }
755}
Note: See TracBrowser for help on using the repository browser.