LCOV - code coverage report
Current view: top level - src/bindings/glib - gelektra-keyset.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 71 77 92.2 %
Date: 2019-09-12 12:28:41 Functions: 24 27 88.9 %

          Line data    Source code
       1             : #include "gelektra-keyset.h"
       2             : #include <kdbprivate.h>
       3             : #include <string.h>
       4             : 
       5          23 : G_DEFINE_TYPE (GElektraKeySet, gelektra_keyset, G_TYPE_OBJECT)
       6             : static KeySet * gelektra_keyset_swap (GElektraKeySet * ks, KeySet * newks);
       7             : 
       8          10 : static void gelektra_keyset_init (GElektraKeySet * self)
       9             : {
      10             :         /* initialize the object */
      11          10 :         self->keyset = ksNew (0, KS_END);
      12          10 : }
      13             : 
      14           9 : static void gelektra_keyset_finalize (GObject * object)
      15             : {
      16           9 :         GElektraKeySet * self = GELEKTRA_KEYSET (object);
      17             : 
      18           9 :         ksDel (self->keyset);
      19             : 
      20             :         /* Always chain up to the parent class; as with dispose(), finalize()
      21             :          * is guaranteed to exist on the parent's class virtual function table
      22             :          */
      23           9 :         G_OBJECT_CLASS (gelektra_keyset_parent_class)->finalize (object);
      24           9 : }
      25             : 
      26             : static void gelektra_keyset_class_init (GElektraKeySetClass * klass)
      27             : {
      28           2 :         GObjectClass * gobject_class = G_OBJECT_CLASS (klass);
      29           2 :         gobject_class->finalize = gelektra_keyset_finalize;
      30             : }
      31             : 
      32             : /*
      33             :  * Methods
      34             :  */
      35             : 
      36             : /* constructor */
      37             : /**
      38             :  * gelektra_keyset_new: (skip)
      39             :  * @size initial allocation size of the keyset
      40             :  * @... optional parameters closed by GELEKTRA_KEYSET_END, see ksNew
      41             :  *
      42             :  * Returns: A new #GElektraKeySet
      43             :  * see ksNew
      44             :  */
      45          10 : GElektraKeySet * gelektra_keyset_new (gsize alloc, ...)
      46             : {
      47             :         va_list va;
      48             : 
      49          10 :         GElektraKeySet * ks = g_object_new (GELEKTRA_TYPE_KEYSET, NULL);
      50          10 :         if (alloc > 0)
      51             :         {
      52           4 :                 ksResize (ks->keyset, alloc);
      53             : 
      54           4 :                 va_start (va, alloc);
      55           4 :                 GElektraKey * key = (GElektraKey *) va_arg (va, GElektraKey *);
      56          15 :                 while (key)
      57             :                 {
      58           7 :                         gelektra_keyset_append (ks, key);
      59           7 :                         key = (GElektraKey *) va_arg (va, GElektraKey *);
      60             :                 }
      61           4 :                 va_end (va);
      62             :         }
      63          10 :         return ks;
      64             : }
      65             : 
      66             : /**
      67             :  * gelektra_keyset_make: (skip)
      68             :  * @ks: The underlying keyset
      69             :  *
      70             :  * Returns: (transfer full): A new #GElektraKeySet holding the ownership of @ks
      71             :  */
      72           4 : GElektraKeySet * gelektra_keyset_make (KeySet * ks)
      73             : {
      74           4 :         if (ks == NULL) return NULL;
      75           4 :         GElektraKeySet * ret = gelektra_keyset_new (0);
      76           4 :         KeySet * old = gelektra_keyset_swap (ret, ks);
      77           4 :         ksDel (old);
      78           4 :         return ret;
      79             : }
      80             : 
      81             : /* basic methods */
      82             : /**
      83             :  * gelektra_keyset_dup:
      84             :  * @ks: A #GElektraKeySet
      85             :  *
      86             :  * Returns: (transfer full): A duplicated #GElektraKeySet
      87             :  * see ksDup
      88             :  */
      89           1 : GElektraKeySet * gelektra_keyset_dup (const GElektraKeySet * ks)
      90             : {
      91           1 :         return gelektra_keyset_make (ksDup (ks->keyset));
      92             : }
      93             : 
      94             : /**
      95             :  * gelektra_keyset_copy: (skip)
      96             :  * see ksCopy
      97             :  */
      98           1 : gint gelektra_keyset_copy (const GElektraKeySet * ks, GElektraKeySet * dest)
      99             : {
     100           1 :         return ksCopy (dest->keyset, ks->keyset);
     101             : }
     102             : 
     103           4 : gint gelektra_keyset_clear (GElektraKeySet * ks)
     104             : {
     105           4 :         return ksClear (ks->keyset);
     106             : }
     107             : 
     108             : /**
     109             :  * gelektra_keyset_swap: (skip)
     110             :  * @ls: A #GElektraKeySet
     111             :  * @newks: The new underlying keyset
     112             :  *
     113             :  * Returns: The old underlying keyset
     114             :  */
     115             : static KeySet * gelektra_keyset_swap (GElektraKeySet * ks, KeySet * newks)
     116             : {
     117           4 :         KeySet * oldks = ks->keyset;
     118           4 :         ks->keyset = newks;
     119             :         return oldks;
     120             : }
     121             : 
     122             : /**
     123             :  * gelektra_keyset_append: (skip)
     124             :  * @ks: A #GElektraKeySet
     125             :  * @key: A #GElektraKey to append. On success reference will decremented
     126             :  *
     127             :  * Returns: The new len of the keyset
     128             :  * see ksAppendKey
     129             :  */
     130          10 : gssize gelektra_keyset_append (GElektraKeySet * ks, GElektraKey * key)
     131             : {
     132          10 :         gssize ret = ksAppendKey (ks->keyset, key->key);
     133          10 :         if (ret > 0) g_object_unref (key);
     134          10 :         return ret;
     135             : }
     136             : 
     137             : /**
     138             :  * gelektra_keyset_gi_append:
     139             :  * @ks: A #GElektraKeySet
     140             :  * @key: A #GElektraKey to append
     141             :  *
     142             :  * Returns: The new len of the keyset
     143             :  *
     144             :  * \note This is for GObject Introspection.
     145             :  * \note Do NOT use! Use gelektra_keyset_append instead
     146             :  */
     147           0 : gssize gelektra_keyset_gi_append (GElektraKeySet * ks, GElektraKey * key)
     148             : {
     149           0 :         return ksAppendKey (ks->keyset, key->key);
     150             : }
     151             : 
     152             : /**
     153             :  * gelektra_keyset_append_keyset: (skip)
     154             :  * @ks: A #GElektraKeySet
     155             :  * @append: A #GElektraKeySet to append. On success reference will decremented
     156             :  *
     157             :  * Returns: The new len of the keyset
     158             :  * see ksAppend
     159             :  */
     160           1 : gssize gelektra_keyset_append_keyset (GElektraKeySet * ks, GElektraKeySet * append)
     161             : {
     162           1 :         gssize ret = ksAppend (ks->keyset, append->keyset);
     163           1 :         if (ret > 0) g_object_unref (append);
     164           1 :         return ret;
     165             : }
     166             : 
     167             : /**
     168             :  * gelektra_keyset_gi_append_keyset:
     169             :  * @ks: A #GElektraKeySet
     170             :  * @append: A #GElektraKeySet to append
     171             :  *
     172             :  * Returns: The new len of the keyset
     173             :  *
     174             :  * \note This is for GObject Introspection.
     175             :  * \note Do NOT use! Use gelektra_keyset_append instead
     176             :  */
     177           0 : gssize gelektra_keyset_gi_append_keyset (GElektraKeySet * ks, GElektraKeySet * append)
     178             : {
     179           0 :         return ksAppend (ks->keyset, append->keyset);
     180             : }
     181             : 
     182             : /**
     183             :  * gelektra_keyset_pop:
     184             :  * @ks: A #GElektraKeySet
     185             :  *
     186             :  * Returns: (transfer full): The last #GElektraKey of @ks
     187             :  * see ksPop
     188             :  */
     189           1 : GElektraKey * gelektra_keyset_pop (GElektraKeySet * ks)
     190             : {
     191           1 :         return gelektra_key_make (ksPop (ks->keyset));
     192             : }
     193             : 
     194             : /**
     195             :  * gelektra_keyset_cut:
     196             :  * @ks: A #GElektraKeySet
     197             :  *
     198             :  * Returns: (transfer full): Cut #GElektraKeySet
     199             :  * see ksCut
     200             :  */
     201           2 : GElektraKeySet * gelektra_keyset_cut (GElektraKeySet * ks, const GElektraKey * point)
     202             : {
     203           2 :         return gelektra_keyset_make (ksCut (ks->keyset, point->key));
     204             : }
     205             : 
     206           0 : gint gelektra_keyset_resize (GElektraKeySet * ks, gsize alloc)
     207             : {
     208           0 :         return ksResize (ks->keyset, alloc);
     209             : }
     210             : 
     211           8 : gssize gelektra_keyset_len (const GElektraKeySet * ks)
     212             : {
     213           8 :         return ksGetSize (ks->keyset);
     214             : }
     215             : 
     216             : /* searching */
     217             : /**
     218             :  * gelektra_keyset_lookup:
     219             :  * @ks: A #GElektraKeySet
     220             :  * @key: The key to search for
     221             :  * @options: Search options
     222             :  *
     223             :  * Returns: (transfer full): Found #GElektraKey in @ks or NULL
     224             :  * see ksLookup
     225             :  */
     226           1 : GElektraKey * gelektra_keyset_lookup (GElektraKeySet * ks, GElektraKey * key, GElektraKdbOptions options)
     227             : {
     228           1 :         return gelektra_key_make (ksLookup (ks->keyset, key->key, options));
     229             : }
     230             : 
     231             : /**
     232             :  * gelektra_keyset_lookup_byname:
     233             :  * @ks: A #GElektraKeySet
     234             :  * @name: The name to search for
     235             :  * @options: Search options
     236             :  *
     237             :  * Returns: (transfer full): Found #GElektraKey in @ks or NULL
     238             :  * see ksLookupByName
     239             :  */
     240           3 : GElektraKey * gelektra_keyset_lookup_byname (GElektraKeySet * ks, const char * name, GElektraKdbOptions options)
     241             : {
     242           3 :         return gelektra_key_make (ksLookupByName (ks->keyset, name, options));
     243             : }
     244             : 
     245             : /* iterating */
     246           1 : gint gelektra_keyset_rewind (GElektraKeySet * ks)
     247             : {
     248           1 :         return ksRewind (ks->keyset);
     249             : }
     250             : 
     251             : /**
     252             :  * gelektra_keyset_next:
     253             :  * @ks: A #GElektraKeySet
     254             :  *
     255             :  * Returns: (transfer full): Next #GElektraKey in @ks
     256             :  * see ksNext
     257             :  */
     258           4 : GElektraKey * gelektra_keyset_next (GElektraKeySet * ks)
     259             : {
     260           4 :         return gelektra_key_make (ksNext (ks->keyset));
     261             : }
     262             : 
     263             : /**
     264             :  * gelektra_keyset_current:
     265             :  * @ks: A #GElektraKeySet
     266             :  *
     267             :  * Returns: (transfer full): Current #GElektraKey in @ks
     268             :  * see ksCurrent
     269             :  */
     270           3 : GElektraKey * gelektra_keyset_current (const GElektraKeySet * ks)
     271             : {
     272           3 :         return gelektra_key_make (ksCurrent (ks->keyset));
     273             : }
     274             : 
     275             : /**
     276             :  * gelektra_keyset_head:
     277             :  * @ks: A #GElektraKeySet
     278             :  *
     279             :  * Returns: (transfer full): First #GElektraKey in @ks
     280             :  * see ksHead
     281             :  */
     282           1 : GElektraKey * gelektra_keyset_head (const GElektraKeySet * ks)
     283             : {
     284           1 :         return gelektra_key_make (ksHead (ks->keyset));
     285             : }
     286             : 
     287             : /**
     288             :  * gelektra_keyset_tail:
     289             :  * @ks: A #GElektraKeySet
     290             :  *
     291             :  * Returns: (transfer full): Last #GElektraKey in @ks
     292             :  * see ksTail
     293             :  */
     294           1 : GElektraKey * gelektra_keyset_tail (const GElektraKeySet * ks)
     295             : {
     296           1 :         return gelektra_key_make (ksTail (ks->keyset));
     297             : }
     298             : 
     299             : /**
     300             :  * gelektra_keyset_getcursor:
     301             :  * @ks: A #GElektraKeySet
     302             :  *
     303             :  * Returns: Current cursor position
     304             :  * see ksGetCursor
     305             :  */
     306           4 : gssize gelektra_keyset_getcursor (const GElektraKeySet * ks)
     307             : {
     308           4 :         return ksGetCursor (ks->keyset);
     309             : }
     310             : 
     311             : /**
     312             :  * gelektra_keyset_setcursor:
     313             :  * @ks: A #GElektraKeySet
     314             :  * @pos: The new cursor position
     315             :  *
     316             :  * see ksSetCursor
     317             :  */
     318           1 : gint gelektra_keyset_setcursor (GElektraKeySet * ks, gssize pos)
     319             : {
     320           1 :         return ksSetCursor (ks->keyset, pos);
     321             : }
     322             : 
     323             : /**
     324             :  * gelektra_keyset_atcursor:
     325             :  * @ks: A #GElektraKeySet
     326             :  * @pos: The cursor position
     327             :  *
     328             :  * Returns: (transfer full): #GElektraKey in @ks at @pos
     329             :  * see ksAtCursor
     330             :  */
     331           1 : GElektraKey * gelektra_keyset_atcursor (GElektraKeySet * ks, gssize pos)
     332             : {
     333           1 :         if (pos < 0) pos += gelektra_keyset_len (ks);
     334           1 :         return gelektra_key_make (ksAtCursor (ks->keyset, pos));
     335             : }

Generated by: LCOV version 1.13