gtask-event-dispatcher.c

Go to the documentation of this file.

#include <gtask/gtask-event-dispatcher.h>
#include <gtask/gtask-packet.h>

#include <gtask/gtask-internals.h>

typedef struct _WatchInfo {
    guint          watch_id;
    GType          watch_type;
    GTaskEventFunc func;
    gpointer       data;
} WatchInfo;

static gpointer parent_class;

static void
gtask_event_dispatcher_class_init( GTaskEventDispatcherClass *klass );

static void
gtask_event_dispatcher_init( GTaskEventDispatcher *dispatcher, gpointer g_class );

static void
gtask_event_dispatcher_dispose( GObject *obj );

static void
gtask_event_dispatcher_finalize( GObject *obj );

GType gtask_event_dispatcher_get_type( void ) {
    static GType type = 0;

    if( type == 0 ) {
        static const GTypeInfo info = {
            sizeof( GTaskEventDispatcherClass ),
            NULL,   /* base init */
            NULL,   /* base_finalize */
            (GClassInitFunc) gtask_event_dispatcher_class_init, /* class_init */
            NULL,   /* class_finalize */
            NULL,   /* class_data */
            sizeof( GTaskEventDispatcher ),
            0,      /* n_preallocs */
            (GInstanceInitFunc) gtask_event_dispatcher_init
        };

        type = g_type_register_static( G_TYPE_OBJECT,
                                       "GTaskEventDispatcher",
                                       &info,
                                       0 );
    }

    return type;
}

static void
gtask_event_dispatcher_class_init( GTaskEventDispatcherClass *klass ) {
    GObjectClass *gobject_class = G_OBJECT_CLASS( klass );

    parent_class = g_type_class_peek_parent( klass );

    gobject_class->dispose = gtask_event_dispatcher_dispose;
    gobject_class->finalize = gtask_event_dispatcher_finalize;
}

static void
gtask_event_dispatcher_init( GTaskEventDispatcher *dispatcher,
                             gpointer g_class )
{
    GTaskEventDispatcherPrivate *private = g_new0( GTaskEventDispatcherPrivate, 1 );

    private->dispose_has_run = FALSE;
    private->watches = g_array_new( FALSE, TRUE, sizeof( WatchInfo ) );
    private->next_watch_id = 1;

    dispatcher->private = private;
}

static void
gtask_event_dispatcher_dispose( GObject *obj ) {
    GTaskEventDispatcher        *dispatcher = GTASK_EVENT_DISPATCHER( obj );
    GTaskEventDispatcherPrivate *private = dispatcher->private;

    if( private->dispose_has_run )
        return;

    g_object_unref( private->parser );

    private->dispose_has_run = TRUE;

    if( G_OBJECT_CLASS( parent_class )->dispose )
        G_OBJECT_CLASS( parent_class )->dispose( obj );
}

static void
gtask_event_dispatcher_finalize( GObject *obj ) {
    GTaskEventDispatcher        *dispatcher = GTASK_EVENT_DISPATCHER( obj );
    GTaskEventDispatcherPrivate *private = dispatcher->private;

    g_array_free( private->watches, TRUE );
    g_free( private );

    if( G_OBJECT_CLASS( parent_class )->finalize )
        G_OBJECT_CLASS( parent_class )->finalize( obj );
}

GTaskEventDispatcher *
gtask_event_dispatcher_new_with_parser( GTaskStreamParser *parser ) {
    GTaskEventDispatcher *dispatcher;

    g_return_val_if_fail( GTASK_IS_STREAM_PARSER( parser ), NULL );

    dispatcher = g_object_new( GTASK_EVENT_DISPATCHER_TYPE, NULL );

    g_object_ref( parser );

    dispatcher->private->parser = parser;

    return dispatcher;
}

guint
gtask_event_dispatcher_add_watch( GTaskEventDispatcher *dispatch,
                                  GType watch_type,
                                  GTaskEventFunc func,
                                  gpointer user_data )
{
    WatchInfo info;

    g_return_val_if_fail( GTASK_IS_EVENT_DISPATCHER( dispatch ), 0 );

    g_debug( "IN: gtask_event_dispatcher_add_watch" );

    info.watch_id = dispatch->private->next_watch_id++;
    info.watch_type = watch_type;
    info.func = func;
    info.data = user_data;

    g_array_append_val( dispatch->private->watches, info );

    g_debug( "LEAVING: gtask_event_dispatcher_add_watch" );
    return info.watch_id;
}

void
gtask_event_dispatcher_remove_watch( GTaskEventDispatcher *dispatch,
                                     guint watch_id )
{
    GTaskEventDispatcherPrivate *private;
    guint                        i;

    g_return_if_fail( GTASK_IS_EVENT_DISPATCHER( dispatch ) );
    g_return_if_fail( watch_id > 0 );

    g_debug( "IN: gtask_event_dispatcher_remove_watch" );

    private = dispatch->private;

    for( i = 0; i < private->watches->len; i++ ) {
        WatchInfo info = g_array_index( private->watches, WatchInfo, i );

        if( info.watch_id == watch_id )
            g_array_remove_index( private->watches, i-- );
        else if( info.watch_id > watch_id )
            return;
    }

    g_debug( "LEAVING: gtask_event_dispatcher_remove_watch" );
}

GTaskStreamParser *
gtask_event_dispatcher_get_stream_parser( GTaskEventDispatcher *dispatch ) {
    g_return_val_if_fail( GTASK_IS_EVENT_DISPATCHER( dispatch ), NULL );

    return dispatch->private->parser;
}


gboolean
gtask_event_dispatcher_private_parse_callback( GIOChannel *chann,
                                               GIOCondition cond,
                                               gpointer data )
{
    GTaskEventDispatcher *dispatcher;
    GTaskStreamParser    *parser;
    GIOStatus             status;
    GObject              *packet;
    GArray               *remove;
    gchar                 buff[1025];
    guint                 num;
    guint                 i;

    g_debug( "IN: gtask_event_dispatcher_private_parse_callback()" );

    g_return_val_if_fail( cond == G_IO_IN, TRUE );
    g_return_val_if_fail( GTASK_IS_EVENT_DISPATCHER( data ), FALSE );

    dispatcher = GTASK_EVENT_DISPATCHER( data );
    remove = g_array_new( FALSE, FALSE, sizeof( guint ) );

    parser = gtask_event_dispatcher_get_stream_parser( dispatcher );

    status = g_io_channel_read_chars( chann, buff, 1024, &num, NULL );

    buff[num] = '\0';

    switch( status ) {
        case G_IO_STATUS_EOF:
            return FALSE;
        case G_IO_STATUS_ERROR:
            g_message( "status == G_IO_STATUS_ERROR" );
            return FALSE;
        case G_IO_STATUS_AGAIN:
            return TRUE;
        default:
            break;
    }

    if( !gtask_stream_parser_push_data( parser, buff, num ) ) {
        g_warning( "parsing error on stream" );
        return FALSE;
    }

    if( !gtask_stream_parser_has_packets( parser ) ) {
        g_warning( "no new packets created" );
        return TRUE;
    }

    g_debug( "new packets are in the queue" );
    while( ( packet = gtask_stream_parser_get_next_packet( parser ) ) != NULL )
    {
        GType   type = G_OBJECT_TYPE( packet );
        GArray *watches = dispatcher->private->watches;
        guint   len = watches->len;

        g_debug( "EventDispatcher: packet_type: %s", G_OBJECT_TYPE_NAME( packet ) );

        for( i = 0; i < len; i++ ) {
            WatchInfo info = g_array_index( watches, WatchInfo, i );

            if( g_type_is_a( type, info.watch_type ) ) {
                g_warning( "dispatching to watch candidate: %p", packet );

                if( !info.func( dispatcher, (GObject *) packet, info.data ) ) {
                    g_array_append_val( remove, i );
                }

                g_warning( "done dispatching to watch candidate: %p", packet );
            }
        }

        g_warning( "unref'ing packet: %p %s", packet, G_OBJECT_TYPE_NAME( packet ) );
        if( !G_IS_OBJECT( packet ) ) {
            g_warning( "WTF?! it's not an object?" );
        } else {
            g_warning( "Back in the real world glib thinks this is an object" );
        }
        g_object_unref( packet );
        g_warning( "done unref'ing packet" );
    }
    g_warning( "no more packets" );

    for( i = 0; i < remove->len; i++ ) {
        gtask_event_dispatcher_remove_watch( dispatcher,
                                            g_array_index( remove, guint, i ) );
    }

    g_warning( "done removing people" );

    g_array_free( remove, TRUE );

    g_debug( "LEAVING: gtask_event_dispatcher_private_parse_callback()" );

    return TRUE;
}

---