*/
/**
- * Skeletal implementation of the {@link Gee.Collection} interface.
+ * Skeletal implementation of the {@link Collection} interface.
*
* Contains common code shared by all collection implementations.
*
- * @see Gee.AbstractList
+ * @see AbstractList
+ * @see AbstractSet
+ * @see AbstractMultiSet
*/
public abstract class Gee.AbstractCollection<G> : Object, Iterable<G>, Collection<G> {
*/
/**
- * Skeletal implementation of the {@link Gee.List} interface.
+ * Skeletal implementation of the {@link List} interface.
*
* Contains common code shared by all list implementations.
*
- * @see Gee.ArrayList
- * @see Gee.LinkedList
+ * @see ArrayList
+ * @see LinkedList
*/
public abstract class Gee.AbstractList<G> : Gee.AbstractCollection<G>, List<G> {
*/
/**
- * Skeletal implementation of the {@link Gee.Map} interface.
+ * Skeletal implementation of the {@link Map} interface.
*
* Contains common code shared by all map implementations.
*
- * @see Gee.Map
- * @see Gee.TreeMap
- * @see Gee.HashMap
+ * @see HashMap
+ * @see TreeMap
*/
public abstract class Gee.AbstractMap<K,V> : Object, Iterable<Map.Entry<K,V>>, Map<K,V> {
*/
/**
- * Skeletal implementation of the {@link Gee.MultiSet} interface.
+ * Skeletal implementation of the {@link MultiSet} interface.
+ *
+ * @see HashMultiSet
+ * @see TreeMultiSet
*/
public abstract class Gee.AbstractMultiSet<G> : AbstractCollection<G>, MultiSet<G> {
public override int size {
*/
/**
- * Skeletal implementation of the {@link Gee.Queue} interface.
+ * Skeletal implementation of the {@link Queue} interface.
*
* Contains common code shared by all queue implementations.
*
- * @see Gee.PriorityQueue
+ * @see PriorityQueue
*/
public abstract class Gee.AbstractQueue<G> : Gee.AbstractCollection<G>, Queue<G> {
/**
*/
/**
- * Skeletal implementation of the {@link Gee.Set} interface.
+ * Skeletal implementation of the {@link Set} interface.
*
* Contains common code shared by all set implementations.
*
- * @see Gee.TreeSet
- * @see Gee.HashSet
+ * @see HashSet
+ * @see TreeSet
*/
public abstract class Gee.AbstractSet<G> : Gee.AbstractCollection<G>, Set<G> {
using GLib;
/**
- * Resizable array implementation of the {@link Gee.List} interface.
+ * Resizable array implementation of the {@link List} interface.
*
* The storage array grows automatically when needed.
*
* This implementation is pretty good for rarely modified data. Because they are
* stored in an array this structure does not fit for highly mutable data. For an
- * alternative implementation see {@link Gee.LinkedList}.
+ * alternative implementation see {@link LinkedList}.
*
- * @see Gee.LinkedList
+ * @see LinkedList
*/
public class Gee.ArrayList<G> : AbstractList<G> {
/**
*/
/**
- * This interface defines a total ordering among each class implementing it.
+ * This interface defines a total ordering among instances of each class
+ * implementing it.
*/
public interface Gee.Comparable<G> : Object {
/**
namespace Gee {
/**
- * Helper class for equal, hash and compare functions.
+ * Helpers for equal, hash and compare functions.
+ *
+ * With those functions, you can retrieve the equal, hash and compare
+ * functions that best match your element, key or value types. Supported
+ * types are (non-boxed) primitive, string and `Object` types.
+ *
+ * A special care is taken for classes inheriting from the
+ * {@link Comparable} interface. For such types, an appropriate compare
+ * function is returned that calls {@link Comparable.compare_to}.
+ *
*/
namespace Functions {
using GLib;
/**
- * Hash table implementation of the {@link Gee.Map} interface.
+ * Hash table implementation of the {@link Map} interface.
*
* This implementation is better fit for highly heterogenous key values.
* In case of high key hashes redundancy or higher amount of data prefer using
- * tree implementation like {@link Gee.TreeMap}.
+ * tree implementation like {@link TreeMap}.
*
- * @see Gee.TreeMap
+ * @see TreeMap
*/
public class Gee.HashMap<K,V> : Gee.AbstractMap<K,V> {
/**
*/
/**
- * A MultiMap implemented using a HashMap of Sets
+ * Hash table implementation of the {@link MultiMap} interface.
*/
public class Gee.HashMultiMap<K,V> : GLib.Object, MultiMap<K,V> {
public int size {
*/
/**
- * A hash based implementation of the {@link Gee.MultiSet} interface.
+ * Hash table implementation of the {@link MultiSet} interface.
*/
public class Gee.HashMultiSet<G> : AbstractMultiSet<G> {
public HashFunc hash_func {
using GLib;
/**
- * Hash table implementation of the {@link Gee.Set} interface.
+ * Hash table implementation of the {@link Set} interface.
*
* This implementation is better fit for highly heterogenous values.
* In case of high value hashes redundancy or higher amount of data prefer using
- * tree implementation like {@link Gee.TreeSet}.
+ * tree implementation like {@link TreeSet}.
*
- * @see Gee.TreeSet
+ * @see TreeSet
*/
public class Gee.HashSet<G> : AbstractSet<G> {
/**
using GLib;
/**
- * An object that can provide an {@link Gee.Iterator}.
+ * An object that can provide an {@link Iterator}.
*/
public interface Gee.Iterable<G> : GLib.Object {
/**
public abstract Type element_type { get; }
/**
- * Returns a Iterator that can be used for simple iteration over a
+ * Returns a {@link Iterator} that can be used for simple iteration over a
* collection.
*
- * @return a Iterator that can be used for simple iteration over a
+ * @return a {@link Iterator} that can be used for simple iteration over a
* collection
*/
public abstract Iterator<G> iterator ();
*/
/**
- * Doubly-linked list implementation of the {@link Gee.List} interface.
+ * Doubly-linked list implementation of the {@link List} interface.
*
* This implementation is pretty well designed for highly mutable data. When
- * indexed access is privileged prefer using {@link Gee.ArrayList}.
+ * indexed access is privileged prefer using {@link ArrayList}.
*
- * @see Gee.ArrayList
+ * @see ArrayList
*/
public class Gee.LinkedList<G> : AbstractList<G>, Queue<G>, Deque<G> {
private int _size = 0;
* except before the first call to {@link next} or {@link first}, or, when an
* item has been removed, until the next call to {@link next} or {@link first}.
*
- * Please note that when the iterator is out of track, neither {@link get} nor
- * {@link remove} are defined and both will fail. After the next call to
- * {@link next} or {@link first}, they will be defined again.
+ * Please note that when the iterator is out of track, neither {@link get_key},
+ * {@link get_value}, {@link set_value} nor {@link unset} are defined and all
+ * will fail. After the next call to {@link next} or {@link first}, they will
+ * be defined again.
*/
public interface Gee.MapIterator<K,V> : GLib.Object {
/**
/**
* Unsets the current entry in the iteration. The cursor is set in an
- * in-between state. Both {@link get} and {@link unset} will fail until
- * the next move of the cursor (calling {@link next} or {@link first}).
+ * in-between state. {@link get_key}, {@link get_value}, {@link set_value}
+ * and {@link unset} will fail until the next move of the cursor (calling
+ * {@link next} or {@link first}).
*/
public abstract void unset ();
}
*/
/**
- * A MultiMap is a map where you can associate multiple values to the
- * same key.
+ * A map with multiple values per key.
*/
public interface Gee.MultiMap<K,V> : GLib.Object {
/**
* @param key the key to remove from the map
* @param value the value to remove from the map
*
- * @return true if the map has been changed, false otherwise
+ * @return true if the map has been changed, false otherwise
*/
public abstract bool remove (K key, V value);
/**
- * Removes the specified key and all the associated values from this multimap.
+ * Removes the specified key and all the associated values from this
+ * multimap.
*
- * @param key the key to remove from the map
+ * @param key the key to remove from the map
*
* @return true if the map has been changed, false otherwise
*/
*/
/**
- * A MultiSet is a collection allowing duplicates.
+ * A collection with duplicate elements.
*/
public interface Gee.MultiSet<G> : Collection<G> {
/**
- * Returns the number of occurences of an item in this MultiSet
+ * Returns the number of occurences of an item in this multiset.
*
* @param item the item to count occurences of
- * @return the number of occurences of the item in this multiset.
+ *
+ * @return the number of occurences of the item in this multiset.
*/
public abstract int count (G item);
}
*/
/**
- * A unbounded priority queue implementation of the {@link Gee.Queue}.
+ * Relaxed fibonacci heap priority queue implementation of the {@link Queue}.
*
* The elements of the priority queue are ordered according to their natural
* ordering, or by a compare_func provided at queue construction time. A
using GLib;
/**
- * Read-only view for {@link Gee.Collection} collections.
+ * Read-only view for {@link Collection} collections.
*
- * This class decorates any class which implements the {@link Gee.Collection}
+ * This class decorates any class which implements the {@link Collection}
* interface by making it read only. Any method which normally modify data will
* throw an error.
*
- * @see Gee.Collection
+ * @see Collection
*/
internal class Gee.ReadOnlyCollection<G> : Object, Iterable<G>, Collection<G> {
using GLib;
/**
- * Read-only view for {@link Gee.List} collections.
+ * Read-only view for {@link List} collections.
*
- * This class decorates any class which implements the {@link Gee.List}
+ * This class decorates any class which implements the {@link List}
* interface by making it read only. Any method which normally modify data will
* throw an error.
*
- * @see Gee.List
+ * @see List
*/
internal class Gee.ReadOnlyList<G> : Gee.ReadOnlyCollection<G>, List<G> {
using GLib;
/**
- * Read-only view for {@link Gee.Map} collections.
+ * Read-only view for {@link Map} collections.
*
- * This class decorates any class which implements the {@link Gee.Map} interface
+ * This class decorates any class which implements the {@link Map} interface
* by making it read only. Any method which normally modify data will throw an
* error.
*
- * @see Gee.Map
+ * @see Map
*/
internal class Gee.ReadOnlyMap<K,V> : Object, Iterable<Map.Entry<K,V>>, Map<K,V> {
using GLib;
/**
- * Read-only view for {@link Gee.Set} collections.
+ * Read-only view for {@link Set} collections.
*
- * This class decorates any class which implements the {@link Gee.Set} interface
+ * This class decorates any class which implements the {@link Set} interface
* by making it read only. Any method which normally modify data will throw an
* error.
*
- * @see Gee.Set
+ * @see Set
*/
internal class Gee.ReadOnlySet<G> : Gee.ReadOnlyCollection<G>, Set<G> {
using GLib;
/**
- * Left-leaning red-black tree implementation of the {@link Gee.Map} interface.
+ * Left-leaning red-black tree implementation of the {@link Map} interface.
*
* This implementation is especially well designed for large quantity of
* data. The (balanced) tree implementation insure that the set and get
* methods are in logarithmic complexity.
*
- * @see Gee.HashMap
+ * @see HashMap
*/
public class Gee.TreeMap<K,V> : Gee.AbstractMap<K,V> {
/**
*/
/**
- * A tree based implementation of the {@link Gee.MultiSet} interface.
+ * Left-leaning red-black tree implementation of the {@link MultiSet}
+ * interface.
*/
public class Gee.TreeMultiSet<G> : AbstractMultiSet<G> {
public CompareFunc compare_func {
using GLib;
/**
- * Left-leaning red-black tree implementation of the {@link Gee.Set} interface.
+ * Left-leaning red-black tree implementation of the {@link Set} interface.
*
* This implementation is especially well designed for large quantity of
* data. The (balanced) tree implementation insure that the set and get
* methods are in logarithmic complexity. For a linear implementation see
- * {@link Gee.HashSet}.
+ * {@link HashSet}.
*
- * @see Gee.HashSet
+ * @see HashSet
*/
public class Gee.TreeSet<G> : AbstractSet<G>, SortedSet<G> {
/**
projects / platform / upstream / libgee.git / commitdiff