gee/gee-0.8.vapi

   1 /* gee-0.8.vapi generated by valac 0.18.0, do not modify. */
   2
   3 [CCode (gir_namespace = "Gee", gir_version = "0.8")]
   4 namespace Gee {
   5         namespace Functions {
   6                 [CCode (cheader_filename = "gee.h")]
   7                 public static GLib.CompareDataFunc get_compare_func_for (GLib.Type t);
   8                 [CCode (cheader_filename = "gee.h")]
   9                 public static Gee.EqualDataFunc get_equal_func_for (GLib.Type t);
  10                 [CCode (cheader_filename = "gee.h")]
  11                 public static Gee.HashDataFunc get_hash_func_for (GLib.Type t);
  12         }
  13         [CCode (cheader_filename = "gee.h")]
  14         public abstract class AbstractBidirList<G> : Gee.AbstractList<G>, Gee.BidirList<G> {
  15                 public AbstractBidirList ();
  16                 public abstract Gee.BidirListIterator<G> bidir_list_iterator ();
  17                 public virtual Gee.BidirList<G> read_only_view { owned get; }
  18         }
  19         [CCode (cheader_filename = "gee.h")]
  20         public abstract class AbstractBidirSortedMap<K,V> : Gee.AbstractSortedMap<K,V>, Gee.BidirSortedMap<K,V> {
  21                 public AbstractBidirSortedMap ();
  22                 public abstract Gee.BidirMapIterator<K,V> bidir_map_iterator ();
  23                 public virtual Gee.BidirSortedMap<K,V> read_only_view { owned get; }
  24         }
  25         [CCode (cheader_filename = "gee.h")]
  26         public abstract class AbstractBidirSortedSet<G> : Gee.AbstractSortedSet<G>, Gee.BidirSortedSet<G> {
  27                 public AbstractBidirSortedSet ();
  28                 public abstract Gee.BidirIterator<G> bidir_iterator ();
  29                 public virtual Gee.BidirSortedSet<G> read_only_view { owned get; }
  30         }
  31         [CCode (cheader_filename = "gee.h")]
  32         public abstract class AbstractCollection<G> : GLib.Object, Gee.Traversable<G>, Gee.Iterable<G>, Gee.Collection<G> {
  33                 public AbstractCollection ();
  34                 public abstract bool add (G item);
  35                 public abstract void clear ();
  36                 public abstract bool contains (G item);
  37                 public virtual bool @foreach (Gee.ForallFunc<G> f);
  38                 public abstract Gee.Iterator<G> iterator ();
  39                 public abstract bool remove (G item);
  40                 public abstract bool read_only { get; }
  41                 public virtual Gee.Collection<G> read_only_view { owned get; }
  42                 public abstract int size { get; }
  43         }
  44         [CCode (cheader_filename = "gee.h")]
  45         public abstract class AbstractList<G> : Gee.AbstractCollection<G>, Gee.List<G> {
  46                 public AbstractList ();
  47                 public abstract new G @get (int index);
  48                 public abstract int index_of (G item);
  49                 public abstract void insert (int index, G item);
  50                 public abstract Gee.ListIterator<G> list_iterator ();
  51                 public abstract G remove_at (int index);
  52                 public abstract new void @set (int index, G item);
  53                 public abstract Gee.List<G>? slice (int start, int stop);
  54                 public virtual Gee.List<G> read_only_view { owned get; }
  55         }
  56         [CCode (cheader_filename = "gee.h")]
  57         public abstract class AbstractMap<K,V> : GLib.Object, Gee.Traversable<Gee.Map.Entry<K,V>>, Gee.Iterable<Gee.Map.Entry<K,V>>, Gee.Map<K,V> {
  58                 public AbstractMap ();
  59                 public abstract void clear ();
  60                 public virtual bool @foreach (Gee.ForallFunc<Gee.Map.Entry<K,V>> f);
  61                 public abstract new V @get (K key);
  62                 public abstract bool has (K key, V value);
  63                 public abstract bool has_key (K key);
  64                 public abstract Gee.MapIterator<K,V> map_iterator ();
  65                 public abstract new void @set (K key, V value);
  66                 public virtual Gee.Iterator<A> stream<A> (owned Gee.StreamFunc<Gee.Map.Entry<K,V>,A> f);
  67                 public abstract bool unset (K key, out V value = null);
  68                 public abstract Gee.Set<Gee.Map.Entry<K,V>> entries { owned get; }
  69                 public abstract Gee.Set<K> keys { owned get; }
  70                 public abstract bool read_only { get; }
  71                 public virtual Gee.Map<K,V> read_only_view { owned get; }
  72                 public abstract int size { get; }
  73                 public abstract Gee.Collection<V> values { owned get; }
  74         }
  75         [CCode (cheader_filename = "gee.h")]
  76         public abstract class AbstractMultiMap<K,V> : GLib.Object, Gee.MultiMap<K,V> {
  77                 protected Gee.Map<K,Gee.Collection<V>> _storage_map;
  78                 public AbstractMultiMap (Gee.Map<K,Gee.Collection<V>> storage_map);
  79                 protected abstract Gee.MultiSet<K> create_multi_key_set ();
  80                 protected abstract Gee.Collection<V> create_value_storage ();
  81                 protected abstract Gee.EqualDataFunc<V> get_value_equal_func ();
  82                 public virtual Gee.MultiMap<K,V> read_only_view { owned get; }
  83         }
  84         [CCode (cheader_filename = "gee.h")]
  85         public abstract class AbstractMultiSet<G> : Gee.AbstractCollection<G>, Gee.MultiSet<G> {
  86                 protected Gee.Map<G,int> _storage_map;
  87                 public AbstractMultiSet (Gee.Map<G,int> storage_map);
  88                 public override bool add (G item);
  89                 public override void clear ();
  90                 public override bool contains (G item);
  91                 public override Gee.Iterator<G> iterator ();
  92                 public override bool remove (G item);
  93                 public override bool read_only { get; }
  94                 public virtual Gee.MultiSet<G> read_only_view { owned get; }
  95                 public override int size { get; }
  96         }
  97         [CCode (cheader_filename = "gee.h")]
  98         public abstract class AbstractQueue<G> : Gee.AbstractCollection<G>, Gee.Queue<G> {
  99                 public AbstractQueue ();
 100                 public abstract G peek ();
 101                 public abstract G poll ();
 102                 public abstract int capacity { get; }
 103                 public abstract bool is_full { get; }
 104                 public abstract int remaining_capacity { get; }
 105         }
 106         [CCode (cheader_filename = "gee.h")]
 107         public abstract class AbstractSet<G> : Gee.AbstractCollection<G>, Gee.Set<G> {
 108                 public AbstractSet ();
 109                 public virtual Gee.Set<G> read_only_view { owned get; }
 110         }
 111         [CCode (cheader_filename = "gee.h")]
 112         public abstract class AbstractSortedMap<K,V> : Gee.AbstractMap<K,V>, Gee.SortedMap<K,V> {
 113                 public AbstractSortedMap ();
 114                 public abstract Gee.SortedMap<K,V> head_map (K before);
 115                 public abstract Gee.SortedMap<K,V> sub_map (K before, K after);
 116                 public abstract Gee.SortedMap<K,V> tail_map (K after);
 117                 public abstract Gee.SortedSet<Gee.Map.Entry<K,V>> ascending_entries { owned get; }
 118                 public abstract Gee.SortedSet<K> ascending_keys { owned get; }
 119         }
 120         [CCode (cheader_filename = "gee.h")]
 121         public abstract class AbstractSortedSet<G> : Gee.AbstractSet<G>, Gee.SortedSet<G> {
 122                 public AbstractSortedSet ();
 123                 public abstract G ceil (G element);
 124                 public abstract G first ();
 125                 public abstract G floor (G element);
 126                 public abstract Gee.SortedSet<G> head_set (G before);
 127                 public abstract G higher (G element);
 128                 public abstract Gee.Iterator<G>? iterator_at (G element);
 129                 public abstract G last ();
 130                 public abstract G lower (G element);
 131                 public abstract Gee.SortedSet<G> sub_set (G from, G to);
 132                 public abstract Gee.SortedSet<G> tail_set (G after);
 133                 public virtual Gee.SortedSet<G> read_only_view { owned get; }
 134         }
 135         [CCode (cheader_filename = "gee.h")]
 136         public class ArrayList<G> : Gee.AbstractBidirList<G> {
 137                 public ArrayList (owned Gee.EqualDataFunc<G>? equal_func = null);
 138                 public override bool add (G item);
 139                 public bool add_all (Gee.Collection<G> collection);
 140                 public override Gee.BidirListIterator<G> bidir_list_iterator ();
 141                 public override void clear ();
 142                 public override bool contains (G item);
 143                 public override bool @foreach (Gee.ForallFunc<G> f);
 144                 public override G @get (int index);
 145                 public override int index_of (G item);
 146                 public override void insert (int index, G item);
 147                 public override Gee.Iterator<G> iterator ();
 148                 public override Gee.ListIterator<G> list_iterator ();
 149                 public override bool remove (G item);
 150                 public override G remove_at (int index);
 151                 public override void @set (int index, G item);
 152                 public override Gee.List<G>? slice (int start, int stop);
 153                 public ArrayList.wrap (owned G[] items, owned Gee.EqualDataFunc<G>? equal_func = null);
 154                 [CCode (notify = false)]
 155                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 156                 public override bool read_only { get; }
 157                 public override int size { get; }
 158         }
 159         [CCode (cheader_filename = "gee.h")]
 160         public class ArrayQueue<G> : Gee.AbstractQueue<G>, Gee.Deque<G> {
 161                 public ArrayQueue (owned Gee.EqualDataFunc<G>? equal_func = null);
 162                 public override bool add (G element);
 163                 public override void clear ();
 164                 public override bool contains (G item);
 165                 public override Gee.Iterator<G> iterator ();
 166                 public override G peek ();
 167                 public override G poll ();
 168                 public override bool remove (G item);
 169                 public override int capacity { get; }
 170                 [CCode (notify = false)]
 171                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 172                 public bool is_empty { get; }
 173                 public override bool is_full { get; }
 174                 public override bool read_only { get; }
 175                 public override int remaining_capacity { get; }
 176                 public override int size { get; }
 177         }
 178         [CCode (cheader_filename = "gee.h")]
 179         public class ConcurrentList<G> : Gee.AbstractList<G> {
 180                 public ConcurrentList (owned Gee.EqualDataFunc<G>? equal_func = null);
 181                 public override bool add (G item);
 182                 public override void clear ();
 183                 public override bool contains (G item);
 184                 public override G @get (int index);
 185                 public override int index_of (G item);
 186                 public override void insert (int index, G item);
 187                 public override Gee.Iterator<G> iterator ();
 188                 public override Gee.ListIterator<G> list_iterator ();
 189                 public override bool remove (G item);
 190                 public override G remove_at (int index);
 191                 public override void @set (int index, G item);
 192                 public override Gee.List<G>? slice (int start, int end);
 193                 [CCode (notify = false)]
 194                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 195                 public bool is_empty { get; }
 196                 public override bool read_only { get; }
 197                 public override int size { get; }
 198         }
 199         [CCode (cheader_filename = "gee.h")]
 200         public class ConcurrentSet<G> : Gee.AbstractSortedSet<G> {
 201                 public enum RangeType {
 202                         HEAD,
 203                         TAIL,
 204                         BOUNDED,
 205                         EMPTY
 206                 }
 207                 public ConcurrentSet (owned GLib.CompareDataFunc<G>? compare_func = null);
 208                 public override bool add (G key);
 209                 public override G ceil (G element);
 210                 public override void clear ();
 211                 public override bool contains (G key);
 212                 public override G first ();
 213                 public override G floor (G element);
 214                 public override Gee.SortedSet<G> head_set (G before);
 215                 public override G higher (G element);
 216                 public override Gee.Iterator<G> iterator ();
 217                 public override Gee.Iterator<G>? iterator_at (G element);
 218                 public override G last ();
 219                 public override G lower (G element);
 220                 public override bool remove (G item);
 221                 public override Gee.SortedSet<G> sub_set (G from, G to);
 222                 public override Gee.SortedSet<G> tail_set (G after);
 223                 public override bool read_only { get; }
 224                 public override int size { get; }
 225         }
 226         [CCode (cheader_filename = "gee.h")]
 227         public class HashMap<K,V> : Gee.AbstractMap<K,V> {
 228                 public HashMap (owned Gee.HashDataFunc<K>? key_hash_func = null, owned Gee.EqualDataFunc<K>? key_equal_func = null, owned Gee.EqualDataFunc<V>? value_equal_func = null);
 229                 public override void clear ();
 230                 public override V @get (K key);
 231                 public override bool has (K key, V value);
 232                 public override bool has_key (K key);
 233                 public override Gee.MapIterator<K,V> map_iterator ();
 234                 public override void @set (K key, V value);
 235                 public override bool unset (K key, out V value = null);
 236                 public override Gee.Set<Gee.Map.Entry<K,V>> entries { owned get; }
 237                 [CCode (notify = false)]
 238                 public Gee.EqualDataFunc<K> key_equal_func { get; private set; }
 239                 [CCode (notify = false)]
 240                 public Gee.HashDataFunc<K> key_hash_func { get; private set; }
 241                 public override Gee.Set<K> keys { owned get; }
 242                 public override bool read_only { get; }
 243                 public override int size { get; }
 244                 [CCode (notify = false)]
 245                 public Gee.EqualDataFunc<V> value_equal_func { get; private set; }
 246                 public override Gee.Collection<V> values { owned get; }
 247         }
 248         [CCode (cheader_filename = "gee.h")]
 249         public class HashMultiMap<K,V> : Gee.AbstractMultiMap<K,V> {
 250                 public HashMultiMap (owned Gee.HashDataFunc<K>? key_hash_func = null, owned Gee.EqualDataFunc<K>? key_equal_func = null, owned Gee.HashDataFunc<V>? value_hash_func = null, owned Gee.EqualDataFunc<V>? value_equal_func = null);
 251                 protected override Gee.MultiSet<K> create_multi_key_set ();
 252                 protected override Gee.Collection<V> create_value_storage ();
 253                 protected override Gee.EqualDataFunc get_value_equal_func ();
 254                 public Gee.EqualDataFunc<K> key_equal_func { get; }
 255                 public Gee.HashDataFunc<K> key_hash_func { get; }
 256                 [CCode (notify = false)]
 257                 public Gee.EqualDataFunc<V> value_equal_func { get; private set; }
 258                 [CCode (notify = false)]
 259                 public Gee.HashDataFunc<V> value_hash_func { get; private set; }
 260         }
 261         [CCode (cheader_filename = "gee.h")]
 262         public class HashMultiSet<G> : Gee.AbstractMultiSet<G> {
 263                 public HashMultiSet (Gee.HashDataFunc<G>? hash_func = null, Gee.EqualDataFunc<G>? equal_func = null);
 264                 public Gee.EqualDataFunc<G> equal_func { get; }
 265                 public Gee.HashDataFunc<G> hash_func { get; }
 266         }
 267         [CCode (cheader_filename = "gee.h")]
 268         public class HashSet<G> : Gee.AbstractSet<G> {
 269                 public HashSet (owned Gee.HashDataFunc<G>? hash_func = null, owned Gee.EqualDataFunc<G>? equal_func = null);
 270                 public override bool add (G key);
 271                 public override void clear ();
 272                 public override bool contains (G key);
 273                 public override Gee.Iterator<G> iterator ();
 274                 public override bool remove (G key);
 275                 [CCode (notify = false)]
 276                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 277                 [CCode (notify = false)]
 278                 public Gee.HashDataFunc<G> hash_func { get; private set; }
 279                 public override bool read_only { get; }
 280                 public override int size { get; }
 281         }
 282         [CCode (cheader_filename = "gee.h")]
 283         [Compact]
 284         public class HazardPointer<G> {
 285                 [Compact]
 286                 public class Context {
 287                         public Context (Gee.HazardPointer.Policy? policy = null);
 288                         public void free_all ();
 289                         public void release ();
 290                         public void try_free ();
 291                         public void try_release ();
 292                 }
 293                 public enum Policy {
 294                         DEFAULT,
 295                         THREAD_EXIT,
 296                         TRY_FREE,
 297                         FREE,
 298                         TRY_RELEASE,
 299                         RELEASE;
 300                         public bool is_concrete ();
 301                         public bool is_blocking ();
 302                         public bool is_safe ();
 303                         public Gee.HazardPointer.Policy to_concrete ();
 304                 }
 305                 public enum ReleasePolicy {
 306                         HELPER_THREAD,
 307                         MAIN_LOOP;
 308                 }
 309                 public delegate void DestroyNotify (void* ptr);
 310                 public HazardPointer (G* ptr);
 311                 public static bool compare_and_exchange_pointer<G> (G** aptr, G old_ptr, owned G _new_ptr, size_t mask = 0, size_t old_mask = 0, size_t new_mask = 0);
 312                 public static Gee.HazardPointer<G>? exchange_hazard_pointer<G> (G** aptr, owned G new_ptr, size_t mask = 0, size_t new_mask = 0, out size_t old_mask = null);
 313                 public static G exchange_pointer<G> (G** aptr, owned G new_ptr, size_t mask = 0, size_t new_mask = 0, out size_t old_mask = null);
 314                 public new unowned G @get (bool other_thread = false);
 315                 public static Gee.HazardPointer<G>? get_hazard_pointer<G> (G** aptr, size_t mask = 0, out size_t mask_out = null);
 316                 public static G get_pointer<G> (G** aptr, size_t mask = 0, out size_t mask_out = null);
 317                 public void release (owned Gee.HazardPointer.DestroyNotify notify);
 318                 public static void set_default_policy (Gee.HazardPointer.Policy policy);
 319                 public static void set_pointer<G> (G** aptr, owned G new_ptr, size_t mask = 0, size_t new_mask = 0);
 320                 public static bool set_release_policy (Gee.HazardPointer.ReleasePolicy policy);
 321                 public static void set_thread_exit_policy (Gee.HazardPointer.Policy policy);
 322         }
 323         [CCode (cheader_filename = "gee.h")]
 324         public class Lazy<G> {
 325                 public Lazy (owned Gee.LazyFunc<G> func);
 326                 public void eval ();
 327                 public Lazy.from_value (G item);
 328                 public new G @get ();
 329                 public G value { get; }
 330         }
 331         [CCode (cheader_filename = "gee.h")]
 332         public class LinkedList<G> : Gee.AbstractBidirList<G>, Gee.Queue<G>, Gee.Deque<G> {
 333                 public LinkedList (owned Gee.EqualDataFunc<G>? equal_func = null);
 334                 public override bool add (G item);
 335                 public override Gee.BidirListIterator<G> bidir_list_iterator ();
 336                 public override void clear ();
 337                 public override bool contains (G item);
 338                 public G first ();
 339                 public override bool @foreach (Gee.ForallFunc<G> f);
 340                 public override G @get (int index);
 341                 public override int index_of (G item);
 342                 public override void insert (int index, G item);
 343                 public override Gee.Iterator<G> iterator ();
 344                 public G last ();
 345                 public override Gee.ListIterator<G> list_iterator ();
 346                 public override bool remove (G item);
 347                 public override G remove_at (int index);
 348                 public override void @set (int index, G item);
 349                 public override Gee.List<G>? slice (int start, int stop);
 350                 [CCode (notify = false)]
 351                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 352                 public override bool read_only { get; }
 353                 public override int size { get; }
 354         }
 355         [CCode (cheader_filename = "gee.h")]
 356         public class PriorityQueue<G> : Gee.AbstractQueue<G> {
 357                 public PriorityQueue (owned GLib.CompareDataFunc<G>? compare_func = null);
 358                 public override bool add (G item);
 359                 public override void clear ();
 360                 public override bool contains (G item);
 361                 public int drain (Gee.Collection<G> recipient, int amount = -1);
 362                 public override Gee.Iterator<G> iterator ();
 363                 public bool offer (G element);
 364                 public override G peek ();
 365                 public override G poll ();
 366                 public override bool remove (G item);
 367                 public override int capacity { get; }
 368                 [CCode (notify = false)]
 369                 public GLib.CompareDataFunc<G> compare_func { get; private set; }
 370                 public override bool is_full { get; }
 371                 public override bool read_only { get; }
 372                 public override int remaining_capacity { get; }
 373                 public override int size { get; }
 374         }
 375         [CCode (cheader_filename = "gee.h")]
 376         public class TreeMap<K,V> : Gee.AbstractBidirSortedMap<K,V> {
 377                 public TreeMap (owned GLib.CompareDataFunc<K>? key_compare_func = null, owned Gee.EqualDataFunc<V>? value_equal_func = null);
 378                 public override Gee.BidirMapIterator<K,V> bidir_map_iterator ();
 379                 public override void clear ();
 380                 public override V @get (K key);
 381                 public override bool has (K key, V value);
 382                 public override bool has_key (K key);
 383                 public override Gee.SortedMap<K,V> head_map (K before);
 384                 public override Gee.MapIterator<K,V> map_iterator ();
 385                 public override void @set (K key, V value);
 386                 public override Gee.SortedMap<K,V> sub_map (K after, K before);
 387                 public override Gee.SortedMap<K,V> tail_map (K after);
 388                 public override bool unset (K key, out V value = null);
 389                 public override Gee.SortedSet<Gee.Map.Entry<K,V>> ascending_entries { owned get; }
 390                 public override Gee.SortedSet<K> ascending_keys { owned get; }
 391                 public override Gee.Set<Gee.Map.Entry<K,V>> entries { owned get; }
 392                 [CCode (notify = false)]
 393                 public GLib.CompareDataFunc<K> key_compare_func { get; private set; }
 394                 public override Gee.Set<K> keys { owned get; }
 395                 public override bool read_only { get; }
 396                 public override int size { get; }
 397                 [CCode (notify = false)]
 398                 public Gee.EqualDataFunc<V> value_equal_func { get; private set; }
 399                 public override Gee.Collection<V> values { owned get; }
 400         }
 401         [CCode (cheader_filename = "gee.h")]
 402         public class TreeMultiMap<K,V> : Gee.AbstractMultiMap<K,V> {
 403                 public TreeMultiMap (owned GLib.CompareDataFunc<K>? key_compare_func = null, owned GLib.CompareDataFunc<V>? value_compare_func = null);
 404                 protected override Gee.MultiSet<K> create_multi_key_set ();
 405                 protected override Gee.Collection<V> create_value_storage ();
 406                 protected override Gee.EqualDataFunc<V> get_value_equal_func ();
 407                 public GLib.CompareDataFunc<K> key_compare_func { get; }
 408                 [CCode (notify = false)]
 409                 public GLib.CompareDataFunc<V> value_compare_func { get; private set; }
 410         }
 411         [CCode (cheader_filename = "gee.h")]
 412         public class TreeMultiSet<G> : Gee.AbstractMultiSet<G> {
 413                 public TreeMultiSet (owned GLib.CompareDataFunc<G>? compare_func = null);
 414                 public GLib.CompareDataFunc<G> compare_func { get; }
 415         }
 416         [CCode (cheader_filename = "gee.h")]
 417         public class TreeSet<G> : Gee.AbstractBidirSortedSet<G> {
 418                 public TreeSet (owned GLib.CompareDataFunc<G>? compare_func = null);
 419                 public override bool add (G item);
 420                 public override Gee.BidirIterator<G> bidir_iterator ();
 421                 public override G ceil (G item);
 422                 public override void clear ();
 423                 public override bool contains (G item);
 424                 public override G first ();
 425                 public override G floor (G item);
 426                 public override Gee.SortedSet<G> head_set (G before);
 427                 public override G higher (G item);
 428                 public override Gee.Iterator<G> iterator ();
 429                 public override Gee.Iterator<G>? iterator_at (G item);
 430                 public override G last ();
 431                 public override G lower (G item);
 432                 public override bool remove (G item);
 433                 public override Gee.SortedSet<G> sub_set (G after, G before);
 434                 public override Gee.SortedSet<G> tail_set (G after);
 435                 [CCode (notify = false)]
 436                 public GLib.CompareDataFunc<G> compare_func { get; private set; }
 437                 public override bool read_only { get; }
 438                 public override int size { get; }
 439         }
 440         [CCode (cheader_filename = "gee.h")]
 441         [GenericAccessors]
 442         public interface BidirIterator<G> : Gee.Iterator<G> {
 443                 public abstract bool first ();
 444                 public abstract bool has_previous ();
 445                 public abstract bool last ();
 446                 public abstract bool previous ();
 447         }
 448         [CCode (cheader_filename = "gee.h")]
 449         [GenericAccessors]
 450         public interface BidirList<G> : Gee.List<G> {
 451                 public abstract new Gee.BidirListIterator<G> bidir_list_iterator ();
 452                 public abstract Gee.BidirList<G> read_only_view { owned get; }
 453         }
 454         [CCode (cheader_filename = "gee.h")]
 455         [GenericAccessors]
 456         public interface BidirListIterator<G> : Gee.BidirIterator<G>, Gee.ListIterator<G> {
 457                 public abstract void insert (G item);
 458         }
 459         [CCode (cheader_filename = "gee.h")]
 460         [GenericAccessors]
 461         public interface BidirMapIterator<K,V> : Gee.MapIterator<K,V> {
 462                 public abstract bool first ();
 463                 public abstract bool has_previous ();
 464                 public abstract bool last ();
 465                 public abstract bool previous ();
 466         }
 467         [CCode (cheader_filename = "gee.h")]
 468         [GenericAccessors]
 469         public interface BidirSortedMap<K,V> : Gee.SortedMap<K,V> {
 470                 public abstract Gee.BidirMapIterator<K,V> bidir_map_iterator ();
 471                 public static Gee.BidirSortedMap<K,V> empty<K,V> ();
 472                 public abstract Gee.BidirSortedMap<K,V> read_only_view { owned get; }
 473         }
 474         [CCode (cheader_filename = "gee.h")]
 475         [GenericAccessors]
 476         public interface BidirSortedSet<G> : Gee.SortedSet<G> {
 477                 public abstract Gee.BidirIterator<G> bidir_iterator ();
 478                 public static Gee.BidirSortedSet<G> empty<G> ();
 479                 public abstract Gee.BidirSortedSet<G> read_only_view { owned get; }
 480         }
 481         [CCode (cheader_filename = "gee.h")]
 482         [GenericAccessors]
 483         public interface Collection<G> : Gee.Iterable<G> {
 484                 public abstract bool add (G item);
 485                 public virtual bool add_all (Gee.Collection<G> collection);
 486                 public bool add_all_array (G[] array);
 487                 public abstract void clear ();
 488                 public abstract bool contains (G item);
 489                 public virtual bool contains_all (Gee.Collection<G> collection);
 490                 public bool contains_all_array (G[] array);
 491                 public static Gee.Collection<G> empty<G> ();
 492                 public abstract bool remove (G item);
 493                 public virtual bool remove_all (Gee.Collection<G> collection);
 494                 public bool remove_all_array (G[] array);
 495                 public virtual bool retain_all (Gee.Collection<G> collection);
 496                 public virtual G[] to_array ();
 497                 public virtual bool is_empty { get; }
 498                 public abstract bool read_only { get; }
 499                 public abstract Gee.Collection<G> read_only_view { owned get; }
 500                 public abstract int size { get; }
 501         }
 502         [CCode (cheader_filename = "gee.h")]
 503         public interface Comparable<G> : GLib.Object {
 504                 public abstract int compare_to (G object);
 505         }
 506         [CCode (cheader_filename = "gee.h")]
 507         [GenericAccessors]
 508         public interface Deque<G> : Gee.Queue<G> {
 509                 public abstract int drain_head (Gee.Collection<G> recipient, int amount = -1);
 510                 public abstract int drain_tail (Gee.Collection<G> recipient, int amount = -1);
 511                 public abstract bool offer_head (G element);
 512                 public abstract bool offer_tail (G element);
 513                 public abstract G peek_head ();
 514                 public abstract G peek_tail ();
 515                 public abstract G poll_head ();
 516                 public abstract G poll_tail ();
 517         }
 518         [CCode (cheader_filename = "gee.h")]
 519         public interface Hashable<G> : GLib.Object {
 520                 public abstract bool equal_to (G object);
 521                 public abstract uint hash ();
 522         }
 523         [CCode (cheader_filename = "gee.h")]
 524         [GenericAccessors]
 525         public interface Iterable<G> : GLib.Object, Gee.Traversable<G> {
 526                 public abstract Gee.Iterator<G> iterator ();
 527         }
 528         [CCode (cheader_filename = "gee.h")]
 529         public interface Iterator<G> : GLib.Object, Gee.Traversable<G> {
 530                 public static Gee.Iterator<G> concat<G> (Gee.Iterator<Gee.Iterator<G>> iters);
 531                 public abstract G @get ();
 532                 public abstract bool has_next ();
 533                 public abstract bool next ();
 534                 public abstract void remove ();
 535                 public static Gee.Iterator<A> unfold<A> (owned Gee.UnfoldFunc<A> f, owned Gee.Lazy<G>? current = null);
 536                 public abstract bool read_only { get; }
 537                 public abstract bool valid { get; }
 538         }
 539         [CCode (cheader_filename = "gee.h")]
 540         [GenericAccessors]
 541         public interface List<G> : Gee.Collection<G> {
 542                 public static Gee.List<G> empty<G> ();
 543                 public virtual G first ();
 544                 public abstract G @get (int index);
 545                 public abstract int index_of (G item);
 546                 public abstract void insert (int index, G item);
 547                 public virtual void insert_all (int index, Gee.Collection<G> collection);
 548                 public virtual G last ();
 549                 public abstract new Gee.ListIterator<G> list_iterator ();
 550                 public abstract G remove_at (int index);
 551                 public abstract void @set (int index, G item);
 552                 public abstract Gee.List<G>? slice (int start, int stop);
 553                 public virtual void sort (owned GLib.CompareDataFunc<G>? compare_func = null);
 554                 public abstract Gee.List<G> read_only_view { owned get; }
 555         }
 556         [CCode (cheader_filename = "gee.h")]
 557         public interface ListIterator<G> : Gee.Iterator<G> {
 558                 public abstract void add (G item);
 559                 public abstract int index ();
 560                 public abstract void @set (G item);
 561         }
 562         [CCode (cheader_filename = "gee.h")]
 563         [GenericAccessors]
 564         public interface Map<K,V> : GLib.Object, Gee.Iterable<Gee.Map.Entry<K,V>> {
 565                 public abstract class Entry<K,V> : GLib.Object {
 566                         public Entry ();
 567                         public abstract K key { get; }
 568                         public abstract bool read_only { get; }
 569                         public abstract V value { get; set; }
 570                 }
 571                 public abstract void clear ();
 572                 [Deprecated (replacement = "Map.has_key")]
 573                 public bool contains (K key);
 574                 [Deprecated (replacement = "Map.has_all")]
 575                 public bool contains_all (Gee.Map<K,V> map);
 576                 public static Gee.Map<K,V> empty<K,V> ();
 577                 public abstract V @get (K key);
 578                 public abstract bool has (K key, V value);
 579                 public virtual bool has_all (Gee.Map<K,V> map);
 580                 public abstract bool has_key (K key);
 581                 public abstract Gee.MapIterator<K,V> map_iterator ();
 582                 [Deprecated (replacement = "Map.unset")]
 583                 public bool remove (K key, out V value = null);
 584                 [Deprecated (replacement = "Map.unset_all")]
 585                 public bool remove_all (Gee.Map<K,V> map);
 586                 public abstract void @set (K key, V value);
 587                 public virtual void set_all (Gee.Map<K,V> map);
 588                 public abstract bool unset (K key, out V value = null);
 589                 public virtual bool unset_all (Gee.Map<K,V> map);
 590                 public abstract Gee.Set<Gee.Map.Entry<K,V>> entries { owned get; }
 591                 public virtual bool is_empty { get; }
 592                 public GLib.Type key_type { get; }
 593                 public abstract Gee.Set<K> keys { owned get; }
 594                 public abstract bool read_only { get; }
 595                 public abstract Gee.Map<K,V> read_only_view { owned get; }
 596                 public abstract int size { get; }
 597                 public GLib.Type value_type { get; }
 598                 public abstract Gee.Collection<V> values { owned get; }
 599         }
 600         [CCode (cheader_filename = "gee.h")]
 601         [GenericAccessors]
 602         public interface MapIterator<K,V> : GLib.Object {
 603                 public virtual A fold<A> (Gee.FoldMapFunc<A,K,V> f, owned A seed);
 604                 public virtual new bool @foreach (Gee.ForallMapFunc<K,V> f);
 605                 public abstract K get_key ();
 606                 public abstract V get_value ();
 607                 public abstract bool has_next ();
 608                 public abstract bool next ();
 609                 public abstract void set_value (V value);
 610                 public abstract void unset ();
 611                 public abstract bool mutable { get; }
 612                 public abstract bool read_only { get; }
 613                 public abstract bool valid { get; }
 614         }
 615         [CCode (cheader_filename = "gee.h")]
 616         [GenericAccessors]
 617         public interface MultiMap<K,V> : GLib.Object {
 618                 public abstract void clear ();
 619                 public abstract bool contains (K key);
 620                 public abstract Gee.Collection<V> @get (K key);
 621                 public abstract Gee.MultiSet<K> get_all_keys ();
 622                 public abstract Gee.Set<K> get_keys ();
 623                 public abstract Gee.Collection<V> get_values ();
 624                 public abstract Gee.MapIterator<K,V> map_iterator ();
 625                 public abstract bool remove (K key, V value);
 626                 public abstract bool remove_all (K key);
 627                 public abstract void @set (K key, V value);
 628                 public GLib.Type key_type { get; }
 629                 public abstract bool read_only { get; }
 630                 public virtual Gee.MultiMap<K,V> read_only_view { owned get; }
 631                 public abstract int size { get; }
 632                 public GLib.Type value_type { get; }
 633         }
 634         [CCode (cheader_filename = "gee.h")]
 635         [GenericAccessors]
 636         public interface MultiSet<G> : Gee.Collection<G> {
 637                 public abstract int count (G item);
 638                 public static Gee.Set<G> empty<G> ();
 639                 public virtual Gee.MultiSet<G> read_only_view { owned get; }
 640         }
 641         [CCode (cheader_filename = "gee.h")]
 642         [GenericAccessors]
 643         public interface Queue<G> : Gee.Collection<G> {
 644                 public const int UNBOUNDED_CAPACITY;
 645                 public virtual int drain (Gee.Collection<G> recipient, int amount = -1);
 646                 public virtual bool offer (G element);
 647                 public abstract G peek ();
 648                 public abstract G poll ();
 649                 public abstract int capacity { get; }
 650                 public abstract bool is_full { get; }
 651                 public abstract int remaining_capacity { get; }
 652         }
 653         [CCode (cheader_filename = "gee.h")]
 654         [GenericAccessors]
 655         public interface Set<G> : Gee.Collection<G> {
 656                 public static Gee.Set<G> empty<G> ();
 657                 public abstract Gee.Set<G> read_only_view { owned get; }
 658         }
 659         [CCode (cheader_filename = "gee.h")]
 660         public interface SortedMap<K,V> : Gee.Map<K,V> {
 661                 public static Gee.Map<K,V> empty<K,V> ();
 662                 public abstract Gee.SortedMap<K,V> head_map (K before);
 663                 public abstract Gee.SortedMap<K,V> sub_map (K before, K after);
 664                 public abstract Gee.SortedMap<K,V> tail_map (K after);
 665                 public abstract Gee.SortedSet<Gee.Map.Entry<K,V>> ascending_entries { owned get; }
 666                 public abstract Gee.SortedSet<K> ascending_keys { owned get; }
 667                 public abstract Gee.SortedMap<K,V> read_only_view { owned get; }
 668         }
 669         [CCode (cheader_filename = "gee.h")]
 670         [GenericAccessors]
 671         public interface SortedSet<G> : Gee.Set<G> {
 672                 public abstract G ceil (G element);
 673                 public static Gee.SortedSet<G> empty<G> ();
 674                 public abstract G first ();
 675                 public abstract G floor (G element);
 676                 public abstract Gee.SortedSet<G> head_set (G before);
 677                 public abstract G higher (G element);
 678                 public abstract Gee.Iterator<G>? iterator_at (G element);
 679                 public abstract G last ();
 680                 public abstract G lower (G element);
 681                 public abstract Gee.SortedSet<G> sub_set (G from, G to);
 682                 public abstract Gee.SortedSet<G> tail_set (G after);
 683                 public abstract Gee.SortedSet<G> read_only_view { owned get; }
 684         }
 685         [CCode (cheader_filename = "gee.h")]
 686         [GenericAccessors]
 687         public interface Traversable<G> : GLib.Object {
 688                 public enum Stream {
 689                         YIELD,
 690                         CONTINUE,
 691                         END
 692                 }
 693                 public virtual Gee.Iterator<G> chop (int offset, int length = -1);
 694                 public virtual Gee.Iterator<G> filter (owned Gee.Predicate<G> pred);
 695                 public virtual A fold<A> (Gee.FoldFunc<A,G> f, owned A seed);
 696                 public abstract new bool @foreach (Gee.ForallFunc<G> f);
 697                 public virtual Gee.Iterator<A> map<A> (Gee.MapFunc<A,G> f);
 698                 public virtual Gee.Iterator<A> scan<A> (Gee.FoldFunc<A,G> f, owned A seed);
 699                 public virtual Gee.Iterator<A> stream<A> (owned Gee.StreamFunc<G,A> f);
 700                 public virtual GLib.Type element_type { get; }
 701         }
 702         [CCode (cheader_filename = "gee.h")]
 703         public delegate bool EqualDataFunc<T> (T a, T b);
 704         [CCode (cheader_filename = "gee.h")]
 705         public delegate A FoldFunc<A,G> (owned G g, owned A a);
 706         [CCode (cheader_filename = "gee.h")]
 707         public delegate A FoldMapFunc<A,K,V> (K k, V v, owned A a);
 708         [CCode (cheader_filename = "gee.h")]
 709         public delegate bool ForallFunc<G> (owned G g);
 710         [CCode (cheader_filename = "gee.h")]
 711         public delegate bool ForallMapFunc<K,V> (K k, V v);
 712         [CCode (cheader_filename = "gee.h")]
 713         public delegate uint HashDataFunc<T> (T v);
 714         [CCode (cheader_filename = "gee.h")]
 715         public delegate G LazyFunc<G> ();
 716         [CCode (cheader_filename = "gee.h")]
 717         public delegate A MapFunc<A,G> (owned G g);
 718         [CCode (cheader_filename = "gee.h")]
 719         public delegate bool Predicate<G> (G g);
 720         [CCode (cheader_filename = "gee.h")]
 721         public delegate Gee.Traversable.Stream StreamFunc<G,A> (Gee.Traversable.Stream state, owned Gee.Lazy<G>? g, out Gee.Lazy<A>? lazy);
 722         [CCode (cheader_filename = "gee.h")]
 723         public delegate Gee.Lazy<A>? UnfoldFunc<A> ();
 724 }