TpIntset

typedef struct _TpIntset TpIntset;

Opaque type representing a set of unsigned integers.

Before 0.11.16, this type was called TpIntSet, which is now a backwards compatibility typedef.

TP_TYPE_INTSET

#define TP_TYPE_INTSET (tp_intset_get_type ())

The boxed type of a TpIntset.

Since 0.11.3

TpIntFunc ()

void                (*TpIntFunc)                        (guint i,
                                                         gpointer userdata);

A callback function acting on unsigned integers.

tp_intset_sized_new ()

TpIntset *          tp_intset_sized_new                 (guint size);

Allocate a new integer set.

tp_intset_new ()

TpIntset *          tp_intset_new                       (void);

Allocate a new integer set.

tp_intset_new_containing ()

TpIntset *          tp_intset_new_containing            (guint element);

Allocate a new integer set containing the given integer.

Since 0.7.26

tp_intset_destroy ()

void                tp_intset_destroy                   (TpIntset *set);

Free all memory used by the set.

tp_intset_clear ()

void                tp_intset_clear                     (TpIntset *set);

Unset every integer in the set.

tp_intset_add ()

void                tp_intset_add                       (TpIntset *set,
                                                         guint element);

Add an integer into a TpIntset.

tp_intset_remove ()

gboolean            tp_intset_remove                    (TpIntset *set,
                                                         guint element);

Remove an integer from a TpIntset

tp_intset_is_member ()

gboolean            tp_intset_is_member                 (const TpIntset *set,
                                                         guint element);

Tests if element is a member of set

tp_intset_foreach ()

void                tp_intset_foreach                   (const TpIntset *set,
                                                         TpIntFunc func,
                                                         gpointer userdata);

Call func(element, userdata) for each element of set, in order.

tp_intset_to_array ()

GArray *            tp_intset_to_array                  (const TpIntset *set);

tp_intset_from_array ()

TpIntset *          tp_intset_from_array                (const GArray *array);

tp_intset_is_empty ()

gboolean            tp_intset_is_empty                  (const TpIntset *set);

Return the same thing as (tp_intset_size (set) == 0), but calculated more efficiently.

Since 0.11.6

tp_intset_size ()

guint               tp_intset_size                      (const TpIntset *set);

tp_intset_is_equal ()

gboolean            tp_intset_is_equal                  (const TpIntset *left,
                                                         const TpIntset *right);

tp_intset_copy ()

TpIntset *          tp_intset_copy                      (const TpIntset *orig);

tp_intset_intersection ()

TpIntset *          tp_intset_intersection              (const TpIntset *left,
                                                         const TpIntset *right);

tp_intset_union ()

TpIntset *          tp_intset_union                     (const TpIntset *left,
                                                         const TpIntset *right);

tp_intset_union_update ()

void                tp_intset_union_update              (TpIntset *self,
                                                         const TpIntset *other);

Add each integer in other to self, analogous to the bitwise operation self |= other.

Since 0.13.10

tp_intset_difference ()

TpIntset *          tp_intset_difference                (const TpIntset *left,
                                                         const TpIntset *right);

tp_intset_difference_update ()

void                tp_intset_difference_update         (TpIntset *self,
                                                         const TpIntset *other);

Remove each integer in other from self, analogous to the bitwise operation self &= (~other).

Since 0.13.10

tp_intset_symmetric_difference ()

TpIntset *          tp_intset_symmetric_difference      (const TpIntset *left,
                                                         const TpIntset *right);

tp_intset_dump ()

gchar *             tp_intset_dump                      (const TpIntset *set);

TpIntsetFastIter

typedef struct {
} TpIntsetFastIter;

An opaque structure representing iteration in undefined order over a set of integers. Must be initialized with tp_intset_fast_iter_init().

Before 0.11.16, this type was called TpIntSetFastIter, which is now a backwards compatibility typedef.

Usage is similar to GHashTableIter:

1
2
3
4
5
6
7
8
9

TpIntsetFastIter iter;
guint element;

tp_intset_fast_iter_init (&iter, intset);

while (tp_intset_fast_iter_next (&iter, &element))
{
  printf ("%u is in the intset\n", element);
}

Since 0.11.6

tp_intset_fast_iter_init ()

void                tp_intset_fast_iter_init            (TpIntsetFastIter *iter,
                                                         const TpIntset *set);

Initialize iter to iterate over set in arbitrary order. iter will become invalid if set is modified.

Since 0.11.6

tp_intset_fast_iter_next ()

gboolean            tp_intset_fast_iter_next            (TpIntsetFastIter *iter,
                                                         guint *output);

Advances iter and retrieves the integer it now points to. Iteration is not necessarily in numerical order.

Since 0.11.6

TP_INTSET_ITER_INIT()

#define TP_INTSET_ITER_INIT(set) { (set), (guint)(-1) }

A suitable static initializer for a TpIntsetIter, to be used as follows:

1
2
3
4
5
6

void
do_something (const TpIntset *intset)
{
  TpIntsetIter iter = TP_INTSET_ITER_INIT (intset);
  /* ... do something with iter ... */
}

TpIntsetIter

typedef struct {
    const TpIntset *set;
    guint element;
} TpIntsetIter;

A structure representing iteration over a set of integers. Must be initialized with either TP_INTSET_ITER_INIT() or tp_intset_iter_init().

Since 0.11.6, consider using TpIntsetFastIter if iteration in numerical order is not required.

Before 0.11.16, this type was called TpIntSetIter, which is now a backwards compatibility typedef.

tp_intset_iter_init ()

void                tp_intset_iter_init                 (TpIntsetIter *iter,
                                                         const TpIntset *set);

Reset the iterator iter to the beginning and make it iterate over set.

tp_intset_iter_next ()

gboolean            tp_intset_iter_next                 (TpIntsetIter *iter);

If there are integers in (iter->set) higher than (iter->element), set (iter->element) to the next one and return TRUE. Otherwise return FALSE.

Usage:

1
2
3
4
5

TpIntsetIter iter = TP_INTSET_INIT (intset);
while (tp_intset_iter_next (&iter))
{
  printf ("%u is in the intset\n", iter.element);
}

Since 0.11.6, consider using TpIntsetFastIter if iteration in numerical order is not required.

tp_intset_iter_reset ()

void                tp_intset_iter_reset                (TpIntsetIter *iter);

Reset the iterator iter to the beginning. It must already be associated with a set.