/* queue.c generated by valac 0.18.0, the Vala compiler * generated from queue.vala, do not modify */ /* queue.vala * * Copyright (C) 2009 Didier Villevalois * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Author: * Didier 'Ptitjes Villevalois */ #include #include #define GEE_TYPE_ITERABLE (gee_iterable_get_type ()) #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable)) #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE)) #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface)) typedef struct _GeeIterable GeeIterable; typedef struct _GeeIterableIface GeeIterableIface; #define GEE_TYPE_ITERATOR (gee_iterator_get_type ()) #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator)) #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR)) #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface)) typedef struct _GeeIterator GeeIterator; typedef struct _GeeIteratorIface GeeIteratorIface; #define GEE_TYPE_COLLECTION (gee_collection_get_type ()) #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection)) #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION)) #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface)) typedef struct _GeeCollection GeeCollection; typedef struct _GeeCollectionIface GeeCollectionIface; #define GEE_TYPE_QUEUE (gee_queue_get_type ()) #define GEE_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_QUEUE, GeeQueue)) #define GEE_IS_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_QUEUE)) #define GEE_QUEUE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_QUEUE, GeeQueueIface)) typedef struct _GeeQueue GeeQueue; typedef struct _GeeQueueIface GeeQueueIface; struct _GeeIteratorIface { GTypeInterface parent_iface; gboolean (*next) (GeeIterator* self); gboolean (*has_next) (GeeIterator* self); gboolean (*first) (GeeIterator* self); gpointer (*get) (GeeIterator* self); void (*remove) (GeeIterator* self); }; struct _GeeIterableIface { GTypeInterface parent_iface; GeeIterator* (*iterator) (GeeIterable* self); GType (*get_element_type) (GeeIterable* self); }; struct _GeeCollectionIface { GTypeInterface parent_iface; gboolean (*contains) (GeeCollection* self, gconstpointer item); gboolean (*add) (GeeCollection* self, gconstpointer item); gboolean (*remove) (GeeCollection* self, gconstpointer item); void (*clear) (GeeCollection* self); gboolean (*add_all) (GeeCollection* self, GeeCollection* collection); gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection); gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection); gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection); gpointer* (*to_array) (GeeCollection* self, int* result_length1); gint (*get_size) (GeeCollection* self); gboolean (*get_is_empty) (GeeCollection* self); GeeCollection* (*get_read_only_view) (GeeCollection* self); }; struct _GeeQueueIface { GTypeInterface parent_iface; gboolean (*offer) (GeeQueue* self, gconstpointer element); gpointer (*peek) (GeeQueue* self); gpointer (*poll) (GeeQueue* self); gint (*drain) (GeeQueue* self, GeeCollection* recipient, gint amount); gint (*get_capacity) (GeeQueue* self); gint (*get_remaining_capacity) (GeeQueue* self); gboolean (*get_is_full) (GeeQueue* self); }; GType gee_iterator_get_type (void) G_GNUC_CONST; GType gee_iterable_get_type (void) G_GNUC_CONST; GType gee_collection_get_type (void) G_GNUC_CONST; GType gee_queue_get_type (void) G_GNUC_CONST; gboolean gee_queue_offer (GeeQueue* self, gconstpointer element); gpointer gee_queue_peek (GeeQueue* self); gpointer gee_queue_poll (GeeQueue* self); gint gee_queue_drain (GeeQueue* self, GeeCollection* recipient, gint amount); #define GEE_QUEUE_UNBOUNDED_CAPACITY (-1) gint gee_queue_get_capacity (GeeQueue* self); gint gee_queue_get_remaining_capacity (GeeQueue* self); gboolean gee_queue_get_is_full (GeeQueue* self); /** * Offers the specified element to this queue. * * @param element the element to offer to the queue * * @return ``true`` if the element was added to the queue */ gboolean gee_queue_offer (GeeQueue* self, gconstpointer element) { g_return_val_if_fail (self != NULL, FALSE); return GEE_QUEUE_GET_INTERFACE (self)->offer (self, element); } /** * Peeks (retrieves, but not remove) an element from this queue. * * @return the element peeked from the queue (or ``null`` if none was * available) */ gpointer gee_queue_peek (GeeQueue* self) { g_return_val_if_fail (self != NULL, NULL); return GEE_QUEUE_GET_INTERFACE (self)->peek (self); } /** * Polls (retrieves and remove) an element from this queue. * * @return the element polled from the queue (or ``null`` if none was * available) */ gpointer gee_queue_poll (GeeQueue* self) { g_return_val_if_fail (self != NULL, NULL); return GEE_QUEUE_GET_INTERFACE (self)->poll (self); } /** * Drains the specified amount of elements from this queue in the specified * recipient collection. * * @param recipient the recipient collection to drain the elements to * @param amount the amount of elements to drain * * @return the amount of elements that were actually drained */ gint gee_queue_drain (GeeQueue* self, GeeCollection* recipient, gint amount) { g_return_val_if_fail (self != NULL, 0); return GEE_QUEUE_GET_INTERFACE (self)->drain (self, recipient, amount); } gint gee_queue_get_capacity (GeeQueue* self) { g_return_val_if_fail (self != NULL, 0); return GEE_QUEUE_GET_INTERFACE (self)->get_capacity (self); } gint gee_queue_get_remaining_capacity (GeeQueue* self) { g_return_val_if_fail (self != NULL, 0); return GEE_QUEUE_GET_INTERFACE (self)->get_remaining_capacity (self); } gboolean gee_queue_get_is_full (GeeQueue* self) { g_return_val_if_fail (self != NULL, FALSE); return GEE_QUEUE_GET_INTERFACE (self)->get_is_full (self); } static void gee_queue_base_init (GeeQueueIface * iface) { static gboolean initialized = FALSE; if (!initialized) { initialized = TRUE; /** * The capacity of this queue (or ``null`` if capacity is not bound). */ g_object_interface_install_property (iface, g_param_spec_int ("capacity", "capacity", "capacity", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE)); /** * The remaining capacity of this queue (or ``null`` if capacity is not * bound). */ g_object_interface_install_property (iface, g_param_spec_int ("remaining-capacity", "remaining-capacity", "remaining-capacity", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE)); /** * Specifies whether this queue is full. */ g_object_interface_install_property (iface, g_param_spec_boolean ("is-full", "is-full", "is-full", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE)); } } /** * A collection designed for holding elements prior to processing. * * Although all Queue implementations do not limit the amount of elements they * can contain, this interface supports for capacity-bounded queues. When * capacity is not bound, then the {@link capacity} and * {@link remaining_capacity} both return {@link UNBOUNDED_CAPACITY}. * * This interface defines methods that will never fail whatever the state of * the queue is. For capacity-bounded queues, those methods will either return * ``false`` or ``null`` to specify that the insert or retrieval did not occur * because the queue was full or empty. * * Queue implementations are not limited to First-In-First-Out behavior and can * propose different ordering of their elements. Each Queue implementation have * to specify how it orders its elements. * * Queue implementations do not allow insertion of ``null`` elements, although * some implementations, such as {@link LinkedList}, do not prohibit insertion * of ``null``. Even in the implementations that permit it, ``null`` should not be * inserted into a Queue, as ``null`` is also used as a special return value by * the poll method to indicate that the queue contains no elements. */ GType gee_queue_get_type (void) { static volatile gsize gee_queue_type_id__volatile = 0; if (g_once_init_enter (&gee_queue_type_id__volatile)) { static const GTypeInfo g_define_type_info = { sizeof (GeeQueueIface), (GBaseInitFunc) gee_queue_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL }; GType gee_queue_type_id; gee_queue_type_id = g_type_register_static (G_TYPE_INTERFACE, "GeeQueue", &g_define_type_info, 0); g_type_interface_add_prerequisite (gee_queue_type_id, GEE_TYPE_COLLECTION); g_once_init_leave (&gee_queue_type_id__volatile, gee_queue_type_id); } return gee_queue_type_id__volatile; }