gee/gee-internals-0.8.vapi

   1 /* gee-internals-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-internals.h")]
   7                 public static Gee.EqualDataFunc get_equal_func_for (GLib.Type t);
   8                 [CCode (cheader_filename = "gee-internals.h")]
   9                 public static Gee.HashDataFunc get_hash_func_for (GLib.Type t);
  10                 [CCode (cheader_filename = "gee-internals.h")]
  11                 public static GLib.CompareDataFunc get_compare_func_for (GLib.Type t);
  12         }
  13         [CCode (cheader_filename = "gee-internals.h")]
  14         public abstract class AbstractBidirList<G> : Gee.AbstractList<G>, Gee.BidirList<G> {
  15                 public abstract Gee.BidirListIterator<G> bidir_list_iterator ();
  16                 internal virtual new void reserved0 ();
  17                 internal virtual new void reserved1 ();
  18                 internal virtual new void reserved2 ();
  19                 internal virtual new void reserved3 ();
  20                 internal virtual new void reserved4 ();
  21                 internal virtual new void reserved5 ();
  22                 internal virtual new void reserved6 ();
  23                 internal virtual new void reserved7 ();
  24                 internal virtual new void reserved8 ();
  25                 internal virtual new void reserved9 ();
  26                 public AbstractBidirList ();
  27                 public virtual Gee.BidirList<G> read_only_view { owned get; }
  28         }
  29         [CCode (cheader_filename = "gee-internals.h")]
  30         public abstract class AbstractBidirSortedSet<G> : Gee.AbstractSortedSet<G>, Gee.BidirSortedSet<G> {
  31                 public abstract Gee.BidirIterator<G> bidir_iterator ();
  32                 internal virtual new void reserved0 ();
  33                 internal virtual new void reserved1 ();
  34                 internal virtual new void reserved2 ();
  35                 internal virtual new void reserved3 ();
  36                 internal virtual new void reserved4 ();
  37                 internal virtual new void reserved5 ();
  38                 internal virtual new void reserved6 ();
  39                 internal virtual new void reserved7 ();
  40                 internal virtual new void reserved8 ();
  41                 internal virtual new void reserved9 ();
  42                 public AbstractBidirSortedSet ();
  43                 public virtual Gee.BidirSortedSet<G> read_only_view { owned get; }
  44         }
  45         [CCode (cheader_filename = "gee-internals.h")]
  46         public abstract class AbstractBidirSortedMap<K,V> : Gee.AbstractSortedMap<K,V>, Gee.BidirSortedMap<K,V> {
  47                 public abstract Gee.BidirMapIterator<K,V> bidir_map_iterator ();
  48                 internal virtual new void reserved0 ();
  49                 internal virtual new void reserved1 ();
  50                 internal virtual new void reserved2 ();
  51                 internal virtual new void reserved3 ();
  52                 internal virtual new void reserved4 ();
  53                 internal virtual new void reserved5 ();
  54                 internal virtual new void reserved6 ();
  55                 internal virtual new void reserved7 ();
  56                 internal virtual new void reserved8 ();
  57                 internal virtual new void reserved9 ();
  58                 public AbstractBidirSortedMap ();
  59                 public virtual Gee.BidirSortedMap<K,V> read_only_view { owned get; }
  60         }
  61         [CCode (cheader_filename = "gee-internals.h")]
  62         public abstract class AbstractCollection<G> : GLib.Object, Gee.Traversable<G>, Gee.Iterable<G>, Gee.Collection<G> {
  63                 public abstract bool contains (G item);
  64                 public abstract bool add (G item);
  65                 public abstract bool remove (G item);
  66                 public abstract void clear ();
  67                 public abstract Gee.Iterator<G> iterator ();
  68                 public virtual bool @foreach (Gee.ForallFunc<G> f);
  69                 internal virtual void reserved0 ();
  70                 internal virtual void reserved1 ();
  71                 internal virtual void reserved2 ();
  72                 internal virtual void reserved3 ();
  73                 internal virtual void reserved4 ();
  74                 internal virtual void reserved5 ();
  75                 internal virtual void reserved6 ();
  76                 internal virtual void reserved7 ();
  77                 internal virtual void reserved8 ();
  78                 internal virtual void reserved9 ();
  79                 public AbstractCollection ();
  80                 public abstract int size { get; }
  81                 public abstract bool read_only { get; }
  82                 public virtual Gee.Collection<G> read_only_view { owned get; }
  83         }
  84         [CCode (cheader_filename = "gee-internals.h")]
  85         public abstract class AbstractList<G> : Gee.AbstractCollection<G>, Gee.List<G> {
  86                 public abstract Gee.ListIterator<G> list_iterator ();
  87                 public abstract new G @get (int index);
  88                 public abstract new void @set (int index, G item);
  89                 public abstract int index_of (G item);
  90                 public abstract void insert (int index, G item);
  91                 public abstract G remove_at (int index);
  92                 public abstract Gee.List<G>? slice (int start, int stop);
  93                 internal virtual new void reserved0 ();
  94                 internal virtual new void reserved1 ();
  95                 internal virtual new void reserved2 ();
  96                 internal virtual new void reserved3 ();
  97                 internal virtual new void reserved4 ();
  98                 internal virtual new void reserved5 ();
  99                 internal virtual new void reserved6 ();
 100                 internal virtual new void reserved7 ();
 101                 internal virtual new void reserved8 ();
 102                 internal virtual new void reserved9 ();
 103                 public AbstractList ();
 104                 public virtual Gee.List<G> read_only_view { owned get; }
 105         }
 106         [CCode (cheader_filename = "gee-internals.h")]
 107         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> {
 108                 public abstract bool has_key (K key);
 109                 public abstract bool has (K key, V value);
 110                 public abstract new V @get (K key);
 111                 public abstract new void @set (K key, V value);
 112                 public abstract bool unset (K key, out V value = null);
 113                 public abstract Gee.MapIterator<K,V> map_iterator ();
 114                 public abstract void clear ();
 115                 public virtual bool @foreach (Gee.ForallFunc<Gee.Map.Entry<K,V>> f);
 116                 public virtual Gee.Iterator<A> stream<A> (owned Gee.StreamFunc<Gee.Map.Entry<K,V>,A> f);
 117                 internal virtual new void reserved0 ();
 118                 internal virtual new void reserved1 ();
 119                 internal virtual new void reserved2 ();
 120                 internal virtual new void reserved3 ();
 121                 internal virtual new void reserved4 ();
 122                 internal virtual new void reserved5 ();
 123                 internal virtual new void reserved6 ();
 124                 internal virtual new void reserved7 ();
 125                 internal virtual new void reserved8 ();
 126                 internal virtual new void reserved9 ();
 127                 public AbstractMap ();
 128                 public abstract int size { get; }
 129                 public abstract bool read_only { get; }
 130                 public abstract Gee.Set<K> keys { owned get; }
 131                 public abstract Gee.Collection<V> values { owned get; }
 132                 public abstract Gee.Set<Gee.Map.Entry<K,V>> entries { owned get; }
 133                 public virtual Gee.Map<K,V> read_only_view { owned get; }
 134         }
 135         [CCode (cheader_filename = "gee-internals.h")]
 136         public abstract class AbstractMultiMap<K,V> : GLib.Object, Gee.MultiMap<K,V> {
 137                 protected Gee.Map<K,Gee.Collection<V>> _storage_map;
 138                 public AbstractMultiMap (Gee.Map<K,Gee.Collection<V>> storage_map);
 139                 protected abstract Gee.Collection<V> create_value_storage ();
 140                 protected abstract Gee.MultiSet<K> create_multi_key_set ();
 141                 protected abstract Gee.EqualDataFunc<V> get_value_equal_func ();
 142                 internal virtual new void reserved0 ();
 143                 internal virtual new void reserved1 ();
 144                 internal virtual new void reserved2 ();
 145                 internal virtual new void reserved3 ();
 146                 internal virtual new void reserved4 ();
 147                 internal virtual new void reserved5 ();
 148                 internal virtual new void reserved6 ();
 149                 internal virtual new void reserved7 ();
 150                 internal virtual new void reserved8 ();
 151                 public virtual Gee.MultiMap<K,V> read_only_view { owned get; }
 152         }
 153         [CCode (cheader_filename = "gee-internals.h")]
 154         public abstract class AbstractMultiSet<G> : Gee.AbstractCollection<G>, Gee.MultiSet<G> {
 155                 protected Gee.Map<G,int> _storage_map;
 156                 public AbstractMultiSet (Gee.Map<G,int> storage_map);
 157                 public override bool contains (G item);
 158                 public override Gee.Iterator<G> iterator ();
 159                 public override bool add (G item);
 160                 public override bool remove (G item);
 161                 public override void clear ();
 162                 internal virtual new void reserved0 ();
 163                 internal virtual new void reserved1 ();
 164                 internal virtual new void reserved2 ();
 165                 internal virtual new void reserved3 ();
 166                 internal virtual new void reserved4 ();
 167                 internal virtual new void reserved5 ();
 168                 internal virtual new void reserved6 ();
 169                 internal virtual new void reserved7 ();
 170                 internal virtual new void reserved8 ();
 171                 public override int size { get; }
 172                 public override bool read_only { get; }
 173                 public virtual Gee.MultiSet<G> read_only_view { owned get; }
 174         }
 175         [CCode (cheader_filename = "gee-internals.h")]
 176         public abstract class AbstractQueue<G> : Gee.AbstractCollection<G>, Gee.Queue<G> {
 177                 public abstract G peek ();
 178                 public abstract G poll ();
 179                 internal virtual new void reserved0 ();
 180                 internal virtual new void reserved1 ();
 181                 internal virtual new void reserved2 ();
 182                 internal virtual new void reserved3 ();
 183                 internal virtual new void reserved4 ();
 184                 internal virtual new void reserved5 ();
 185                 internal virtual new void reserved6 ();
 186                 internal virtual new void reserved7 ();
 187                 internal virtual new void reserved8 ();
 188                 internal virtual new void reserved9 ();
 189                 public AbstractQueue ();
 190                 public abstract int capacity { get; }
 191                 public abstract int remaining_capacity { get; }
 192                 public abstract bool is_full { get; }
 193         }
 194         [CCode (cheader_filename = "gee-internals.h")]
 195         public abstract class AbstractSet<G> : Gee.AbstractCollection<G>, Gee.Set<G> {
 196                 internal virtual new void reserved0 ();
 197                 internal virtual new void reserved1 ();
 198                 internal virtual new void reserved2 ();
 199                 internal virtual new void reserved3 ();
 200                 internal virtual new void reserved4 ();
 201                 internal virtual new void reserved5 ();
 202                 internal virtual new void reserved6 ();
 203                 internal virtual new void reserved7 ();
 204                 internal virtual new void reserved8 ();
 205                 internal virtual new void reserved9 ();
 206                 public AbstractSet ();
 207                 public virtual Gee.Set<G> read_only_view { owned get; }
 208         }
 209         [CCode (cheader_filename = "gee-internals.h")]
 210         public abstract class AbstractSortedMap<K,V> : Gee.AbstractMap<K,V>, Gee.SortedMap<K,V> {
 211                 public abstract Gee.SortedMap<K,V> head_map (K before);
 212                 public abstract Gee.SortedMap<K,V> tail_map (K after);
 213                 public abstract Gee.SortedMap<K,V> sub_map (K before, K after);
 214                 internal virtual new void reserved0 ();
 215                 internal virtual new void reserved1 ();
 216                 internal virtual new void reserved2 ();
 217                 internal virtual new void reserved3 ();
 218                 internal virtual new void reserved4 ();
 219                 internal virtual new void reserved5 ();
 220                 internal virtual new void reserved6 ();
 221                 internal virtual new void reserved7 ();
 222                 internal virtual new void reserved8 ();
 223                 internal virtual new void reserved9 ();
 224                 public AbstractSortedMap ();
 225                 public abstract Gee.SortedSet<K> ascending_keys { owned get; }
 226                 public abstract Gee.SortedSet<Gee.Map.Entry<K,V>> ascending_entries { owned get; }
 227         }
 228         [CCode (cheader_filename = "gee-internals.h")]
 229         public abstract class AbstractSortedSet<G> : Gee.AbstractSet<G>, Gee.SortedSet<G> {
 230                 public abstract G first ();
 231                 public abstract G last ();
 232                 public abstract Gee.Iterator<G>? iterator_at (G element);
 233                 public abstract G lower (G element);
 234                 public abstract G higher (G element);
 235                 public abstract G floor (G element);
 236                 public abstract G ceil (G element);
 237                 public abstract Gee.SortedSet<G> head_set (G before);
 238                 public abstract Gee.SortedSet<G> tail_set (G after);
 239                 public abstract Gee.SortedSet<G> sub_set (G from, G to);
 240                 internal virtual new void reserved0 ();
 241                 internal virtual new void reserved1 ();
 242                 internal virtual new void reserved2 ();
 243                 internal virtual new void reserved3 ();
 244                 internal virtual new void reserved4 ();
 245                 internal virtual new void reserved5 ();
 246                 internal virtual new void reserved6 ();
 247                 internal virtual new void reserved7 ();
 248                 internal virtual new void reserved8 ();
 249                 internal virtual new void reserved9 ();
 250                 public AbstractSortedSet ();
 251                 public virtual Gee.SortedSet<G> read_only_view { owned get; }
 252         }
 253         [CCode (cheader_filename = "gee-internals.h")]
 254         public class ArrayList<G> : Gee.AbstractBidirList<G> {
 255                 internal G[] _items;
 256                 internal int _size;
 257                 public ArrayList (owned Gee.EqualDataFunc<G>? equal_func = null);
 258                 public ArrayList.wrap (owned G[] items, owned Gee.EqualDataFunc<G>? equal_func = null);
 259                 public override bool @foreach (Gee.ForallFunc<G> f);
 260                 public override Gee.Iterator<G> iterator ();
 261                 public override Gee.ListIterator<G> list_iterator ();
 262                 public override Gee.BidirListIterator<G> bidir_list_iterator ();
 263                 public override bool contains (G item);
 264                 public override int index_of (G item);
 265                 public override G @get (int index);
 266                 public override void @set (int index, G item);
 267                 public override bool add (G item);
 268                 public override void insert (int index, G item);
 269                 public override bool remove (G item);
 270                 public override G remove_at (int index);
 271                 public override void clear ();
 272                 public override Gee.List<G>? slice (int start, int stop);
 273                 public bool add_all (Gee.Collection<G> collection);
 274                 public override int size { get; }
 275                 public override bool read_only { get; }
 276                 [CCode (notify = false)]
 277                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 278         }
 279         [CCode (cheader_filename = "gee-internals.h")]
 280         public class ArrayQueue<G> : Gee.AbstractQueue<G>, Gee.Deque<G> {
 281                 public ArrayQueue (owned Gee.EqualDataFunc<G>? equal_func = null);
 282                 public override Gee.Iterator<G> iterator ();
 283                 public override bool add (G element);
 284                 public override bool contains (G item);
 285                 public override bool remove (G item);
 286                 public override void clear ();
 287                 public override G peek ();
 288                 public override G poll ();
 289                 [CCode (notify = false)]
 290                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 291                 public override int size { get; }
 292                 public bool is_empty { get; }
 293                 public override bool read_only { get; }
 294                 public override int capacity { get; }
 295                 public override int remaining_capacity { get; }
 296                 public override bool is_full { get; }
 297         }
 298         [CCode (cheader_filename = "gee-internals.h")]
 299         public class ConcurrentList<G> : Gee.AbstractList<G> {
 300                 public ConcurrentList (owned Gee.EqualDataFunc<G>? equal_func = null);
 301                 public override bool contains (G item);
 302                 public override bool add (G item);
 303                 public override bool remove (G item);
 304                 public override void clear ();
 305                 public override Gee.Iterator<G> iterator ();
 306                 public override Gee.ListIterator<G> list_iterator ();
 307                 public override G @get (int index);
 308                 public override void @set (int index, G item);
 309                 public override int index_of (G item);
 310                 public override void insert (int index, G item);
 311                 public override G remove_at (int index);
 312                 public override Gee.List<G>? slice (int start, int end);
 313                 [CCode (notify = false)]
 314                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 315                 public override bool read_only { get; }
 316                 public override int size { get; }
 317                 public bool is_empty { get; }
 318         }
 319         [CCode (cheader_filename = "gee-internals.h")]
 320         public class ConcurrentSet<G> : Gee.AbstractSortedSet<G> {
 321                 public enum RangeType {
 322                         HEAD,
 323                         TAIL,
 324                         BOUNDED,
 325                         EMPTY
 326                 }
 327                 public ConcurrentSet (owned GLib.CompareDataFunc<G>? compare_func = null);
 328                 public override Gee.Iterator<G> iterator ();
 329                 public override bool contains (G key);
 330                 public override bool add (G key);
 331                 public override bool remove (G item);
 332                 public override void clear ();
 333                 public override G first ();
 334                 public override G last ();
 335                 public override Gee.Iterator<G>? iterator_at (G element);
 336                 public override G lower (G element);
 337                 public override G higher (G element);
 338                 public override G floor (G element);
 339                 public override G ceil (G element);
 340                 public override Gee.SortedSet<G> head_set (G before);
 341                 public override Gee.SortedSet<G> tail_set (G after);
 342                 public override Gee.SortedSet<G> sub_set (G from, G to);
 343                 public override int size { get; }
 344                 public override bool read_only { get; }
 345         }
 346         [CCode (cheader_filename = "gee-internals.h")]
 347         public class HashMap<K,V> : Gee.AbstractMap<K,V> {
 348                 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);
 349                 public override bool has_key (K key);
 350                 public override bool has (K key, V value);
 351                 public override V @get (K key);
 352                 public override void @set (K key, V value);
 353                 public override bool unset (K key, out V value = null);
 354                 public override void clear ();
 355                 public override Gee.MapIterator<K,V> map_iterator ();
 356                 public override int size { get; }
 357                 public override bool read_only { get; }
 358                 public override Gee.Set<K> keys { owned get; }
 359                 public override Gee.Collection<V> values { owned get; }
 360                 public override Gee.Set<Gee.Map.Entry<K,V>> entries { owned get; }
 361                 [CCode (notify = false)]
 362                 public Gee.HashDataFunc<K> key_hash_func { get; private set; }
 363                 [CCode (notify = false)]
 364                 public Gee.EqualDataFunc<K> key_equal_func { get; private set; }
 365                 [CCode (notify = false)]
 366                 public Gee.EqualDataFunc<V> value_equal_func { get; private set; }
 367         }
 368         [CCode (cheader_filename = "gee-internals.h")]
 369         public class HashMultiMap<K,V> : Gee.AbstractMultiMap<K,V> {
 370                 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);
 371                 protected override Gee.Collection<V> create_value_storage ();
 372                 protected override Gee.MultiSet<K> create_multi_key_set ();
 373                 protected override Gee.EqualDataFunc get_value_equal_func ();
 374                 public Gee.HashDataFunc<K> key_hash_func { get; }
 375                 public Gee.EqualDataFunc<K> key_equal_func { get; }
 376                 [CCode (notify = false)]
 377                 public Gee.HashDataFunc<V> value_hash_func { get; private set; }
 378                 [CCode (notify = false)]
 379                 public Gee.EqualDataFunc<V> value_equal_func { get; private set; }
 380         }
 381         [CCode (cheader_filename = "gee-internals.h")]
 382         public class HashMultiSet<G> : Gee.AbstractMultiSet<G> {
 383                 public HashMultiSet (Gee.HashDataFunc<G>? hash_func = null, Gee.EqualDataFunc<G>? equal_func = null);
 384                 public Gee.HashDataFunc<G> hash_func { get; }
 385                 public Gee.EqualDataFunc<G> equal_func { get; }
 386         }
 387         [CCode (cheader_filename = "gee-internals.h")]
 388         public class HashSet<G> : Gee.AbstractSet<G> {
 389                 public HashSet (owned Gee.HashDataFunc<G>? hash_func = null, owned Gee.EqualDataFunc<G>? equal_func = null);
 390                 public override bool contains (G key);
 391                 public override Gee.Iterator<G> iterator ();
 392                 public override bool add (G key);
 393                 public override bool remove (G key);
 394                 public override void clear ();
 395                 public override int size { get; }
 396                 public override bool read_only { get; }
 397                 [CCode (notify = false)]
 398                 public Gee.HashDataFunc<G> hash_func { get; private set; }
 399                 [CCode (notify = false)]
 400                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 401         }
 402         [CCode (cheader_filename = "gee-internals.h")]
 403         [Compact]
 404         public class HazardPointer<G> {
 405                 [Compact]
 406                 public class Context {
 407                         internal Gee.HazardPointer.Context* _parent;
 408                         internal Gee.ArrayList<weak Gee.HazardPointer.FreeNode*> _to_free;
 409                         internal Gee.HazardPointer.Policy? _policy;
 410                         internal static GLib.StaticPrivate _current_context;
 411                         internal static GLib.StaticPrivate _root_context;
 412                         public Context (Gee.HazardPointer.Policy? policy = null);
 413                         public void try_free ();
 414                         public void free_all ();
 415                         public void try_release ();
 416                         public void release ();
 417                         internal void release_ptr (void* ptr, owned Gee.HazardPointer.DestroyNotify notify);
 418                         internal static Gee.HazardPointer.Context* get_current_context ();
 419                 }
 420                 [Compact]
 421                 internal class FreeNode {
 422                         public void* pointer;
 423                         public Gee.HazardPointer.DestroyNotify destroy_notify;
 424                         public FreeNode ();
 425                 }
 426                 [Compact]
 427                 internal class Node {
 428                         public Gee.HazardPointer.Node* _next;
 429                         public int _active;
 430                         public void* _hazard;
 431                         public Node ();
 432                         public void release ();
 433                         public bool is_active ();
 434                         public bool activate ();
 435                         public void @set (void* ptr);
 436                         public void* @get (bool safe = true);
 437                         public unowned Gee.HazardPointer.Node? get_next ();
 438                         public void set_next (Gee.HazardPointer.Node* next);
 439                 }
 440                 public enum Policy {
 441                         DEFAULT,
 442                         THREAD_EXIT,
 443                         TRY_FREE,
 444                         FREE,
 445                         TRY_RELEASE,
 446                         RELEASE;
 447                         public bool is_concrete ();
 448                         public bool is_blocking ();
 449                         public bool is_safe ();
 450                         public Gee.HazardPointer.Policy to_concrete ();
 451                         internal Gee.ArrayList<weak Gee.HazardPointer.FreeNode*>? perform (owned Gee.ArrayList<weak Gee.HazardPointer.FreeNode*> to_free);
 452                 }
 453                 public enum ReleasePolicy {
 454                         HELPER_THREAD,
 455                         MAIN_LOOP;
 456                         internal static void ensure_start ();
 457                 }
 458                 public delegate void DestroyNotify (void* ptr);
 459                 internal weak Gee.HazardPointer.Node _node;
 460                 internal static Gee.HazardPointer.Node* _head;
 461                 internal static int _default_policy;
 462                 internal static int _thread_exit_policy;
 463                 internal static int release_policy;
 464                 internal static Gee.Queue<Gee.ArrayList<weak Gee.HazardPointer.FreeNode*>> _queue;
 465                 internal static GLib.StaticMutex _queue_mutex;
 466                 internal static Gee.ArrayList<weak Gee.HazardPointer.FreeNode*> _global_to_free;
 467                 public HazardPointer (G* ptr);
 468                 internal HazardPointer.from_node (Gee.HazardPointer.Node node);
 469                 public static Gee.HazardPointer<G>? get_hazard_pointer<G> (G** aptr, size_t mask = 0, out size_t mask_out = null);
 470                 public static G get_pointer<G> (G** aptr, size_t mask = 0, out size_t mask_out = null);
 471                 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);
 472                 public static void set_pointer<G> (G** aptr, owned G new_ptr, size_t mask = 0, size_t new_mask = 0);
 473                 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);
 474                 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);
 475                 public new unowned G @get (bool other_thread = false);
 476                 public void release (owned Gee.HazardPointer.DestroyNotify notify);
 477                 public static void set_default_policy (Gee.HazardPointer.Policy policy);
 478                 public static void set_thread_exit_policy (Gee.HazardPointer.Policy policy);
 479                 public static bool set_release_policy (Gee.HazardPointer.ReleasePolicy policy);
 480                 internal static unowned Gee.HazardPointer.Node acquire ();
 481                 internal static bool try_free (Gee.ArrayList<weak Gee.HazardPointer.FreeNode*> to_free);
 482                 internal static unowned Gee.HazardPointer.Node? get_head ();
 483                 internal static Gee.HazardPointer.DestroyNotify get_destroy_notify<G> ();
 484         }
 485         [CCode (cheader_filename = "gee-internals.h")]
 486         public class Lazy<G> {
 487                 public Lazy (owned Gee.LazyFunc<G> func);
 488                 public Lazy.from_value (G item);
 489                 public void eval ();
 490                 public new G @get ();
 491                 public G value { get; }
 492         }
 493         [CCode (cheader_filename = "gee-internals.h")]
 494         public class LinkedList<G> : Gee.AbstractBidirList<G>, Gee.Queue<G>, Gee.Deque<G> {
 495                 public LinkedList (owned Gee.EqualDataFunc<G>? equal_func = null);
 496                 public override bool @foreach (Gee.ForallFunc<G> f);
 497                 public override Gee.Iterator<G> iterator ();
 498                 public override Gee.ListIterator<G> list_iterator ();
 499                 public override Gee.BidirListIterator<G> bidir_list_iterator ();
 500                 public override bool contains (G item);
 501                 public override bool add (G item);
 502                 public override bool remove (G item);
 503                 public override void clear ();
 504                 public override G @get (int index);
 505                 public override void @set (int index, G item);
 506                 public override int index_of (G item);
 507                 public override void insert (int index, G item);
 508                 public override G remove_at (int index);
 509                 public override Gee.List<G>? slice (int start, int stop);
 510                 public G first ();
 511                 public G last ();
 512                 [CCode (notify = false)]
 513                 public Gee.EqualDataFunc<G> equal_func { get; private set; }
 514                 public override int size { get; }
 515                 public override bool read_only { get; }
 516         }
 517         [CCode (cheader_filename = "gee-internals.h")]
 518         public class PriorityQueue<G> : Gee.AbstractQueue<G> {
 519                 public PriorityQueue (owned GLib.CompareDataFunc<G>? compare_func = null);
 520                 public bool offer (G element);
 521                 public override G peek ();
 522                 public override G poll ();
 523                 public int drain (Gee.Collection<G> recipient, int amount = -1);
 524                 public override bool contains (G item);
 525                 public override bool add (G item);
 526                 public override bool remove (G item);
 527                 public override void clear ();
 528                 public override Gee.Iterator<G> iterator ();
 529                 [CCode (notify = false)]
 530                 public GLib.CompareDataFunc<G> compare_func { get; private set; }
 531                 public override int capacity { get; }
 532                 public override int remaining_capacity { get; }
 533                 public override bool is_full { get; }
 534                 public override bool read_only { get; }
 535                 public override int size { get; }
 536         }
 537         [CCode (cheader_filename = "gee-internals.h")]
 538         internal class ReadOnlyBidirList<G> : Gee.ReadOnlyList<G>, Gee.BidirList<G> {
 539                 public ReadOnlyBidirList (Gee.BidirList<G> list);
 540                 public virtual Gee.BidirList<G> read_only_view { owned get; }
 541         }
 542         [CCode (cheader_filename = "gee-internals.h")]
 543         internal class ReadOnlyBidirSortedSet<G> : Gee.ReadOnlySortedSet<G>, Gee.BidirSortedSet<G> {
 544                 protected class BidirIterator<G> : Gee.ReadOnlyCollection.Iterator<G>, Gee.BidirIterator<G> {
 545                         public BidirIterator (Gee.BidirIterator<G> iterator);
 546                 }
 547                 public ReadOnlyBidirSortedSet (Gee.BidirSortedSet<G> @set);
 548         }
 549         [CCode (cheader_filename = "gee-internals.h")]
 550         internal class ReadOnlyBidirSortedMap<K,V> : Gee.ReadOnlySortedMap<K,V>, Gee.BidirSortedMap<K,V> {
 551                 protected class BidirMapIterator<K,V> : Gee.ReadOnlyMap.MapIterator<K,V>, Gee.BidirMapIterator<K,V> {
 552                         public BidirMapIterator (Gee.BidirMapIterator<K,V> iterator);
 553                 }
 554                 public ReadOnlyBidirSortedMap (Gee.BidirSortedMap<K,V> map);
 555         }
 556         [CCode (cheader_filename = "gee-internals.h")]
 557         internal class ReadOnlyCollection<G> : GLib.Object, Gee.Traversable<G>, Gee.Iterable<G>, Gee.Collection<G> {
 558                 protected class Iterator<G> : GLib.Object, Gee.Traversable<G>, Gee.Iterator<G> {
 559                         protected Gee.Iterator<G> _iter;
 560                         public Iterator (Gee.Iterator<G> iterator);
 561                 }
 562                 protected Gee.Collection<G> _collection;
 563                 public ReadOnlyCollection (Gee.Collection<G> collection);
 564                 public virtual Gee.Collection<G> read_only_view { owned get; }
 565         }
 566         [CCode (cheader_filename = "gee-internals.h")]
 567         internal class ReadOnlyList<G> : Gee.ReadOnlyCollection<G>, Gee.List<G> {
 568                 protected class Iterator<G> : Gee.ReadOnlyCollection.Iterator<G>, Gee.ListIterator<G> {
 569                         public Iterator (Gee.ListIterator<G> iterator);
 570                 }
 571                 public ReadOnlyList (Gee.List<G> list);
 572                 public virtual Gee.List<G> read_only_view { owned get; }
 573         }
 574         [CCode (cheader_filename = "gee-internals.h")]
 575         internal class ReadOnlyMap<K,V> : GLib.Object, Gee.Traversable<Gee.Map.Entry<K,V>>, Gee.Iterable<Gee.Map.Entry<K,V>>, Gee.Map<K,V> {
 576                 internal class MapIterator<K,V> : GLib.Object, Gee.MapIterator<K,V> {
 577                         protected Gee.MapIterator<K,V> _iter;
 578                         public MapIterator (Gee.MapIterator<K,V> iterator);
 579                 }
 580                 protected Gee.Map<K,V> _map;
 581                 public ReadOnlyMap (Gee.Map<K,V> map);
 582                 public bool contains (K key);
 583                 public bool remove (K key, out V value = null);
 584                 public bool remove_all (Gee.Map<K,V> map);
 585                 public bool contains_all (Gee.Map<K,V> map);
 586                 public virtual Gee.Map<K,V> read_only_view { owned get; }
 587                 public GLib.Type key_type { get; }
 588                 public GLib.Type value_type { get; }
 589         }
 590         [CCode (cheader_filename = "gee-internals.h")]
 591         internal class ReadOnlyMultiMap<K,V> : GLib.Object, Gee.MultiMap<K,V> {
 592                 public ReadOnlyMultiMap (Gee.MultiMap<K,V> multimap);
 593                 public virtual Gee.MultiMap<K,V> read_only_view { owned get; }
 594         }
 595         [CCode (cheader_filename = "gee-internals.h")]
 596         internal class ReadOnlyMultiSet<G> : Gee.ReadOnlyCollection<G>, Gee.MultiSet<G> {
 597                 public ReadOnlyMultiSet (Gee.MultiSet<G> multiset);
 598                 public virtual Gee.MultiSet<G> read_only_view { owned get; }
 599         }
 600         [CCode (cheader_filename = "gee-internals.h")]
 601         internal class ReadOnlySet<G> : Gee.ReadOnlyCollection<G>, Gee.Set<G> {
 602                 public ReadOnlySet (Gee.Set<G> @set);
 603                 public virtual Gee.Set<G> read_only_view { owned get; }
 604         }
 605         [CCode (cheader_filename = "gee-internals.h")]
 606         internal class ReadOnlySortedMap<K,V> : Gee.ReadOnlyMap<K,V>, Gee.SortedMap<K,V> {
 607                 public ReadOnlySortedMap (Gee.Map<K,V> map);
 608         }
 609         [CCode (cheader_filename = "gee-internals.h")]
 610         internal class ReadOnlySortedSet<G> : Gee.ReadOnlySet<G>, Gee.SortedSet<G> {
 611                 public ReadOnlySortedSet (Gee.SortedSet<G> @set);
 612         }
 613         [CCode (cheader_filename = "gee-internals.h")]
 614         internal class TimSort<G> : GLib.Object {
 615                 public static void sort<G> (Gee.List<G> list, GLib.CompareDataFunc<G> compare);
 616                 public TimSort ();
 617         }
 618         [CCode (cheader_filename = "gee-internals.h")]
 619         public class TreeMap<K,V> : Gee.AbstractBidirSortedMap<K,V> {
 620                 public TreeMap (owned GLib.CompareDataFunc<K>? key_compare_func = null, owned Gee.EqualDataFunc<V>? value_equal_func = null);
 621                 public override bool has_key (K key);
 622                 public override bool has (K key, V value);
 623                 public override V @get (K key);
 624                 public override void @set (K key, V value);
 625                 public override bool unset (K key, out V value = null);
 626                 public override void clear ();
 627                 public override Gee.SortedMap<K,V> head_map (K before);
 628                 public override Gee.SortedMap<K,V> tail_map (K after);
 629                 public override Gee.SortedMap<K,V> sub_map (K after, K before);
 630                 public override Gee.MapIterator<K,V> map_iterator ();
 631                 public override Gee.BidirMapIterator<K,V> bidir_map_iterator ();
 632                 public override int size { get; }
 633                 public override bool read_only { get; }
 634                 public override Gee.Set<K> keys { owned get; }
 635                 public override Gee.Collection<V> values { owned get; }
 636                 public override Gee.Set<Gee.Map.Entry<K,V>> entries { owned get; }
 637                 [CCode (notify = false)]
 638                 public GLib.CompareDataFunc<K> key_compare_func { get; private set; }
 639                 [CCode (notify = false)]
 640                 public Gee.EqualDataFunc<V> value_equal_func { get; private set; }
 641                 public override Gee.SortedSet<K> ascending_keys { owned get; }
 642                 public override Gee.SortedSet<Gee.Map.Entry<K,V>> ascending_entries { owned get; }
 643         }
 644         [CCode (cheader_filename = "gee-internals.h")]
 645         public class TreeMultiMap<K,V> : Gee.AbstractMultiMap<K,V> {
 646                 public TreeMultiMap (owned GLib.CompareDataFunc<K>? key_compare_func = null, owned GLib.CompareDataFunc<V>? value_compare_func = null);
 647                 protected override Gee.Collection<V> create_value_storage ();
 648                 protected override Gee.MultiSet<K> create_multi_key_set ();
 649                 protected override Gee.EqualDataFunc<V> get_value_equal_func ();
 650                 public GLib.CompareDataFunc<K> key_compare_func { get; }
 651                 [CCode (notify = false)]
 652                 public GLib.CompareDataFunc<V> value_compare_func { get; private set; }
 653         }
 654         [CCode (cheader_filename = "gee-internals.h")]
 655         public class TreeMultiSet<G> : Gee.AbstractMultiSet<G> {
 656                 public TreeMultiSet (owned GLib.CompareDataFunc<G>? compare_func = null);
 657                 public GLib.CompareDataFunc<G> compare_func { get; }
 658         }
 659         [CCode (cheader_filename = "gee-internals.h")]
 660         public class TreeSet<G> : Gee.AbstractBidirSortedSet<G> {
 661                 public TreeSet (owned GLib.CompareDataFunc<G>? compare_func = null);
 662                 public override bool contains (G item);
 663                 public override bool add (G item);
 664                 public override bool remove (G item);
 665                 public override void clear ();
 666                 public override Gee.Iterator<G> iterator ();
 667                 public override Gee.BidirIterator<G> bidir_iterator ();
 668                 public override G first ();
 669                 public override G last ();
 670                 public override Gee.SortedSet<G> head_set (G before);
 671                 public override Gee.SortedSet<G> tail_set (G after);
 672                 public override Gee.SortedSet<G> sub_set (G after, G before);
 673                 public override Gee.Iterator<G>? iterator_at (G item);
 674                 public override G lower (G item);
 675                 public override G higher (G item);
 676                 public override G floor (G item);
 677                 public override G ceil (G item);
 678                 public override int size { get; }
 679                 public override bool read_only { get; }
 680                 [CCode (notify = false)]
 681                 public GLib.CompareDataFunc<G> compare_func { get; private set; }
 682         }
 683         [CCode (cheader_filename = "gee-internals.h")]
 684         internal class UnfoldIterator<G> : GLib.Object, Gee.Traversable<G>, Gee.Iterator<G> {
 685                 public UnfoldIterator (owned Gee.UnfoldFunc<G> func, owned Gee.Lazy<G>? current = null);
 686         }
 687         [CCode (cheader_filename = "gee-internals.h")]
 688         [GenericAccessors]
 689         public interface BidirIterator<G> : Gee.Iterator<G> {
 690                 public abstract bool previous ();
 691                 public abstract bool has_previous ();
 692                 public abstract bool first ();
 693                 public abstract bool last ();
 694         }
 695         [CCode (cheader_filename = "gee-internals.h")]
 696         [GenericAccessors]
 697         public interface BidirList<G> : Gee.List<G> {
 698                 public abstract new Gee.BidirListIterator<G> bidir_list_iterator ();
 699                 public abstract Gee.BidirList<G> read_only_view { owned get; }
 700         }
 701         [CCode (cheader_filename = "gee-internals.h")]
 702         [GenericAccessors]
 703         public interface BidirListIterator<G> : Gee.BidirIterator<G>, Gee.ListIterator<G> {
 704                 public abstract void insert (G item);
 705         }
 706         [CCode (cheader_filename = "gee-internals.h")]
 707         [GenericAccessors]
 708         public interface BidirMapIterator<K,V> : Gee.MapIterator<K,V> {
 709                 public abstract bool previous ();
 710                 public abstract bool has_previous ();
 711                 public abstract bool first ();
 712                 public abstract bool last ();
 713         }
 714         [CCode (cheader_filename = "gee-internals.h")]
 715         [GenericAccessors]
 716         public interface BidirSortedSet<G> : Gee.SortedSet<G> {
 717                 public abstract Gee.BidirIterator<G> bidir_iterator ();
 718                 public static Gee.BidirSortedSet<G> empty<G> ();
 719                 public abstract Gee.BidirSortedSet<G> read_only_view { owned get; }
 720         }
 721         [CCode (cheader_filename = "gee-internals.h")]
 722         [GenericAccessors]
 723         public interface BidirSortedMap<K,V> : Gee.SortedMap<K,V> {
 724                 public abstract Gee.BidirMapIterator<K,V> bidir_map_iterator ();
 725                 public static Gee.BidirSortedMap<K,V> empty<K,V> ();
 726                 public abstract Gee.BidirSortedMap<K,V> read_only_view { owned get; }
 727         }
 728         [CCode (cheader_filename = "gee-internals.h")]
 729         [GenericAccessors]
 730         public interface Collection<G> : Gee.Iterable<G> {
 731                 public abstract bool contains (G item);
 732                 public abstract bool add (G item);
 733                 public abstract bool remove (G item);
 734                 public abstract void clear ();
 735                 public virtual bool add_all (Gee.Collection<G> collection);
 736                 public virtual bool contains_all (Gee.Collection<G> collection);
 737                 public virtual bool remove_all (Gee.Collection<G> collection);
 738                 public virtual bool retain_all (Gee.Collection<G> collection);
 739                 public virtual G[] to_array ();
 740                 public bool add_all_array (G[] array);
 741                 public bool contains_all_array (G[] array);
 742                 public bool remove_all_array (G[] array);
 743                 public static Gee.Collection<G> empty<G> ();
 744                 public abstract int size { get; }
 745                 public virtual bool is_empty { get; }
 746                 public abstract bool read_only { get; }
 747                 public abstract Gee.Collection<G> read_only_view { owned get; }
 748         }
 749         [CCode (cheader_filename = "gee-internals.h")]
 750         public interface Comparable<G> : GLib.Object {
 751                 public abstract int compare_to (G object);
 752         }
 753         [CCode (cheader_filename = "gee-internals.h")]
 754         [GenericAccessors]
 755         public interface Deque<G> : Gee.Queue<G> {
 756                 public abstract bool offer_head (G element);
 757                 public abstract G peek_head ();
 758                 public abstract G poll_head ();
 759                 public abstract int drain_head (Gee.Collection<G> recipient, int amount = -1);
 760                 public abstract bool offer_tail (G element);
 761                 public abstract G peek_tail ();
 762                 public abstract G poll_tail ();
 763                 public abstract int drain_tail (Gee.Collection<G> recipient, int amount = -1);
 764         }
 765         [CCode (cheader_filename = "gee-internals.h")]
 766         public interface Hashable<G> : GLib.Object {
 767                 public abstract uint hash ();
 768                 public abstract bool equal_to (G object);
 769         }
 770         [CCode (cheader_filename = "gee-internals.h")]
 771         [GenericAccessors]
 772         public interface Iterable<G> : GLib.Object, Gee.Traversable<G> {
 773                 public abstract Gee.Iterator<G> iterator ();
 774         }
 775         [CCode (cheader_filename = "gee-internals.h")]
 776         public interface Iterator<G> : GLib.Object, Gee.Traversable<G> {
 777                 public abstract bool next ();
 778                 public abstract bool has_next ();
 779                 public abstract G @get ();
 780                 public abstract void remove ();
 781                 public static Gee.Iterator<A> unfold<A> (owned Gee.UnfoldFunc<A> f, owned Gee.Lazy<G>? current = null);
 782                 public static Gee.Iterator<G> concat<G> (Gee.Iterator<Gee.Iterator<G>> iters);
 783                 public abstract bool valid { get; }
 784                 public abstract bool read_only { get; }
 785         }
 786         [CCode (cheader_filename = "gee-internals.h")]
 787         [GenericAccessors]
 788         public interface List<G> : Gee.Collection<G> {
 789                 public abstract new Gee.ListIterator<G> list_iterator ();
 790                 public abstract G @get (int index);
 791                 public abstract void @set (int index, G item);
 792                 public abstract int index_of (G item);
 793                 public abstract void insert (int index, G item);
 794                 public abstract G remove_at (int index);
 795                 public abstract Gee.List<G>? slice (int start, int stop);
 796                 public virtual G first ();
 797                 public virtual G last ();
 798                 public virtual void insert_all (int index, Gee.Collection<G> collection);
 799                 public virtual void sort (owned GLib.CompareDataFunc<G>? compare_func = null);
 800                 public static Gee.List<G> empty<G> ();
 801                 public abstract Gee.List<G> read_only_view { owned get; }
 802         }
 803         [CCode (cheader_filename = "gee-internals.h")]
 804         public interface ListIterator<G> : Gee.Iterator<G> {
 805                 public abstract void @set (G item);
 806                 public abstract void add (G item);
 807                 public abstract int index ();
 808         }
 809         [CCode (cheader_filename = "gee-internals.h")]
 810         [GenericAccessors]
 811         public interface Map<K,V> : GLib.Object, Gee.Iterable<Gee.Map.Entry<K,V>> {
 812                 public abstract class Entry<K,V> : GLib.Object {
 813                         public Entry ();
 814                         public abstract K key { get; }
 815                         public abstract V value { get; set; }
 816                         public abstract bool read_only { get; }
 817                 }
 818                 public abstract bool has_key (K key);
 819                 [Deprecated (replacement = "Map.has_key")]
 820                 public bool contains (K key);
 821                 public abstract bool has (K key, V value);
 822                 public abstract V @get (K key);
 823                 public abstract void @set (K key, V value);
 824                 public abstract bool unset (K key, out V value = null);
 825                 [Deprecated (replacement = "Map.unset")]
 826                 public bool remove (K key, out V value = null);
 827                 public abstract void clear ();
 828                 public abstract Gee.MapIterator<K,V> map_iterator ();
 829                 public virtual void set_all (Gee.Map<K,V> map);
 830                 public virtual bool unset_all (Gee.Map<K,V> map);
 831                 [Deprecated (replacement = "Map.unset_all")]
 832                 public bool remove_all (Gee.Map<K,V> map);
 833                 public virtual bool has_all (Gee.Map<K,V> map);
 834                 [Deprecated (replacement = "Map.has_all")]
 835                 public bool contains_all (Gee.Map<K,V> map);
 836                 public static Gee.Map<K,V> empty<K,V> ();
 837                 public abstract int size { get; }
 838                 public virtual bool is_empty { get; }
 839                 public abstract bool read_only { get; }
 840                 public abstract Gee.Set<K> keys { owned get; }
 841                 public abstract Gee.Collection<V> values { owned get; }
 842                 public abstract Gee.Set<Gee.Map.Entry<K,V>> entries { owned get; }
 843                 public abstract Gee.Map<K,V> read_only_view { owned get; }
 844                 public GLib.Type key_type { get; }
 845                 public GLib.Type value_type { get; }
 846         }
 847         [CCode (cheader_filename = "gee-internals.h")]
 848         [GenericAccessors]
 849         public interface MapIterator<K,V> : GLib.Object {
 850                 public abstract bool next ();
 851                 public abstract bool has_next ();
 852                 public abstract K get_key ();
 853                 public abstract V get_value ();
 854                 public abstract void set_value (V value);
 855                 public abstract void unset ();
 856                 public virtual A fold<A> (Gee.FoldMapFunc<A,K,V> f, owned A seed);
 857                 public virtual new bool @foreach (Gee.ForallMapFunc<K,V> f);
 858                 public abstract bool valid { get; }
 859                 public abstract bool mutable { get; }
 860                 public abstract bool read_only { get; }
 861         }
 862         [CCode (cheader_filename = "gee-internals.h")]
 863         [GenericAccessors]
 864         public interface MultiMap<K,V> : GLib.Object {
 865                 public abstract Gee.Set<K> get_keys ();
 866                 public abstract Gee.MultiSet<K> get_all_keys ();
 867                 public abstract Gee.Collection<V> get_values ();
 868                 public abstract bool contains (K key);
 869                 public abstract Gee.Collection<V> @get (K key);
 870                 public abstract void @set (K key, V value);
 871                 public abstract bool remove (K key, V value);
 872                 public abstract bool remove_all (K key);
 873                 public abstract void clear ();
 874                 public abstract Gee.MapIterator<K,V> map_iterator ();
 875                 public abstract int size { get; }
 876                 public abstract bool read_only { get; }
 877                 public GLib.Type key_type { get; }
 878                 public GLib.Type value_type { get; }
 879                 public virtual Gee.MultiMap<K,V> read_only_view { owned get; }
 880         }
 881         [CCode (cheader_filename = "gee-internals.h")]
 882         [GenericAccessors]
 883         public interface MultiSet<G> : Gee.Collection<G> {
 884                 public abstract int count (G item);
 885                 public static Gee.Set<G> empty<G> ();
 886                 public virtual Gee.MultiSet<G> read_only_view { owned get; }
 887         }
 888         [CCode (cheader_filename = "gee-internals.h")]
 889         [GenericAccessors]
 890         public interface Queue<G> : Gee.Collection<G> {
 891                 public const int UNBOUNDED_CAPACITY;
 892                 public virtual bool offer (G element);
 893                 public abstract G peek ();
 894                 public abstract G poll ();
 895                 public virtual int drain (Gee.Collection<G> recipient, int amount = -1);
 896                 public abstract int capacity { get; }
 897                 public abstract int remaining_capacity { get; }
 898                 public abstract bool is_full { get; }
 899         }
 900         [CCode (cheader_filename = "gee-internals.h")]
 901         [GenericAccessors]
 902         public interface Set<G> : Gee.Collection<G> {
 903                 public static Gee.Set<G> empty<G> ();
 904                 public abstract Gee.Set<G> read_only_view { owned get; }
 905         }
 906         [CCode (cheader_filename = "gee-internals.h")]
 907         public interface SortedMap<K,V> : Gee.Map<K,V> {
 908                 public abstract Gee.SortedMap<K,V> head_map (K before);
 909                 public abstract Gee.SortedMap<K,V> tail_map (K after);
 910                 public abstract Gee.SortedMap<K,V> sub_map (K before, K after);
 911                 public static Gee.Map<K,V> empty<K,V> ();
 912                 public abstract Gee.SortedSet<K> ascending_keys { owned get; }
 913                 public abstract Gee.SortedSet<Gee.Map.Entry<K,V>> ascending_entries { owned get; }
 914                 public abstract Gee.SortedMap<K,V> read_only_view { owned get; }
 915         }
 916         [CCode (cheader_filename = "gee-internals.h")]
 917         [GenericAccessors]
 918         public interface SortedSet<G> : Gee.Set<G> {
 919                 public abstract G first ();
 920                 public abstract G last ();
 921                 public abstract Gee.Iterator<G>? iterator_at (G element);
 922                 public abstract G lower (G element);
 923                 public abstract G higher (G element);
 924                 public abstract G floor (G element);
 925                 public abstract G ceil (G element);
 926                 public abstract Gee.SortedSet<G> head_set (G before);
 927                 public abstract Gee.SortedSet<G> tail_set (G after);
 928                 public abstract Gee.SortedSet<G> sub_set (G from, G to);
 929                 public static Gee.SortedSet<G> empty<G> ();
 930                 public abstract Gee.SortedSet<G> read_only_view { owned get; }
 931         }
 932         [CCode (cheader_filename = "gee-internals.h")]
 933         [GenericAccessors]
 934         public interface Traversable<G> : GLib.Object {
 935                 public enum Stream {
 936                         YIELD,
 937                         CONTINUE,
 938                         END
 939                 }
 940                 public abstract new bool @foreach (Gee.ForallFunc<G> f);
 941                 public virtual Gee.Iterator<A> stream<A> (owned Gee.StreamFunc<G,A> f);
 942                 public virtual A fold<A> (Gee.FoldFunc<A,G> f, owned A seed);
 943                 public virtual Gee.Iterator<A> map<A> (Gee.MapFunc<A,G> f);
 944                 public virtual Gee.Iterator<A> scan<A> (Gee.FoldFunc<A,G> f, owned A seed);
 945                 public virtual Gee.Iterator<G> filter (owned Gee.Predicate<G> pred);
 946                 public virtual Gee.Iterator<G> chop (int offset, int length = -1);
 947                 public virtual GLib.Type element_type { get; }
 948         }
 949         [CCode (cheader_filename = "gee-internals.h")]
 950         public delegate uint HashDataFunc<T> (T v);
 951         [CCode (cheader_filename = "gee-internals.h")]
 952         public delegate bool EqualDataFunc<T> (T a, T b);
 953         [CCode (cheader_filename = "gee-internals.h")]
 954         public delegate G LazyFunc<G> ();
 955         [CCode (cheader_filename = "gee-internals.h")]
 956         public delegate A FoldMapFunc<A,K,V> (K k, V v, owned A a);
 957         [CCode (cheader_filename = "gee-internals.h")]
 958         public delegate bool ForallMapFunc<K,V> (K k, V v);
 959         [CCode (cheader_filename = "gee-internals.h")]
 960         public delegate A FoldFunc<A,G> (owned G g, owned A a);
 961         [CCode (cheader_filename = "gee-internals.h")]
 962         public delegate bool ForallFunc<G> (owned G g);
 963         [CCode (cheader_filename = "gee-internals.h")]
 964         public delegate Gee.Lazy<A>? UnfoldFunc<A> ();
 965         [CCode (cheader_filename = "gee-internals.h")]
 966         public delegate Gee.Traversable.Stream StreamFunc<G,A> (Gee.Traversable.Stream state, owned Gee.Lazy<G>? g, out Gee.Lazy<A>? lazy);
 967         [CCode (cheader_filename = "gee-internals.h")]
 968         public delegate A MapFunc<A,G> (owned G g);
 969         [CCode (cheader_filename = "gee-internals.h")]
 970         public delegate bool Predicate<G> (G g);
 971 }