gtask-role-packet.c

Go to the documentation of this file.

#include <string.h>
#include <gtask/gtask-role-packet.h>

/* @{ */

static gpointer parent_class = NULL;

static void
gtask_role_packet_class_init( GTaskRolePacketClass *klass );

static void
gtask_role_packet_init( GTaskRolePacket *packet, gpointer g_class );

static void
gtask_role_packet_finalize( GObject *obj );

static gboolean
gtask_role_packet_serialize_to( GTaskPacket *packet,
                                GTaskConnection *conn );

/*
static void
gtask_role_packet_set_property( GObject *object,
                                guint param_id,
                                const GValue *value,
                                GParamSpec *pspec  );

static void
gtask_role_packet_get_property( GObject *object,
                                guint param_id,
                                const GValue *value,
                                GParamSpec *pspec  );
*/

GType gtask_activity_state_get_type( ) {
    static GType type = 0;

    if( type == 0 ) {
        static const GEnumValue values[] = {
            { GTASK_ROLE_NONE, "GTASK_ROLE_NONE", "none" },
            { GTASK_ROLE_NONE, "GTASK_ROLE_PROXY", "proxy" },
            { GTASK_ROLE_NONE, "GTASK_ROLE_REPORTER", "reporter" },
            { GTASK_ROLE_NONE, "GTASK_ROLE_PROVIDER", "provider" },
            { 0, NULL, NULL }
        };

        type = g_enum_register_static( "GTaskRole", values );
    }

    return type;
}


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

    if( type == 0 ) {
        static const GTypeInfo info = {
            sizeof( GTaskRolePacketClass ),
            NULL,   /* base_init */
            NULL,   /* base_finalize */
            (GClassInitFunc) gtask_role_packet_class_init,  /* class_init */
            NULL,   /* class_finalize */
            NULL,   /* class_data */
            sizeof( GTaskRolePacket ),
            0,      /* n_preallocs */
            (GInstanceInitFunc) gtask_role_packet_init
        };

        type = g_type_register_static( GTASK_PACKET_TYPE,
                                       "GTaskRolePacket",
                                       &info,
                                       0 );
    }

    return type;
}

static void
gtask_role_packet_class_init( GTaskRolePacketClass *klass ) {
    GObjectClass     *gobject_class = G_OBJECT_CLASS( klass );
    GTaskPacketClass *packet_class = GTASK_PACKET_CLASS( klass );

    parent_class = g_type_class_peek_parent( klass );

    gobject_class->finalize = gtask_role_packet_finalize;
    /*
    gobject_class->set_property = gtask_role_packet_set_property;
    gobject_class->get_property = gtask_role_packet_get_property;
    */

    packet_class->serialize_packet = gtask_role_packet_serialize_to;
}

static void
gtask_role_packet_init( GTaskRolePacket *packet, gpointer g_class ) {
    packet->private = g_new0( GTaskRolePacketPrivate, 1 );

    packet->private->role = GTASK_ROLE_NONE;
}

static void
gtask_role_packet_finalize( GObject *obj ) {
    GTaskRolePacket *packet = GTASK_ROLE_PACKET( obj );

    g_free( packet->private );

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

static gboolean
gtask_role_packet_serialize_to( GTaskPacket *packet,
                                GTaskConnection *conn )
{
    GTaskRolePacket    *r_packet;
    xmlOutputBufferPtr  xml_output;
    xmlDocPtr           doc;
    xmlNodePtr          role_node;
    xmlNodePtr          role;

    g_return_val_if_fail( GTASK_IS_ROLE_PACKET( packet ), FALSE );
    g_return_val_if_fail( GTASK_IS_CONNECTION( conn ), FALSE );
    g_return_val_if_fail( gtask_connection_is_connected( conn ), FALSE );

    r_packet = (GTaskRolePacket *) packet;

    doc = xmlNewDoc( "1.0" );

    if( !doc )
        return FALSE;

    role_node = xmlNewNode( NULL, "role" );

    if( !role_node ) {
        xmlFreeDoc( doc );

         return FALSE;
    }

    xmlDocSetRootElement( doc, role_node );

    role = xmlNewText( gtask_role_packet_get_role_name( r_packet ) );

    if( !role ) {
        xmlFreeDoc( doc );

        return FALSE;
    }

    xmlAddChild( role_node, role );

    xml_output = gtask_connection_get_xml_output_buffer( conn );
    xmlNodeDumpOutput( xml_output, doc, role_node, 1, 0, NULL );
    xmlOutputBufferFlush( xml_output );

    xmlFreeDoc( doc );

    return TRUE;
}

GTaskRolePacket *
gtask_role_packet_new( void ) {
    g_warning( "GTaskRolePacket has been deprecated. GTaskConnection now completely wraps its functionality." );

    return g_object_new( GTASK_ROLE_PACKET_TYPE, NULL );
}

GTaskRolePacket *
gtask_role_packet_new_with_role( GTaskRole role ) {
    GTaskRolePacket *packet = gtask_role_packet_new( );

    gtask_role_packet_set_role( packet, role );

    return packet;
}

GTaskRole
gtask_role_packet_get_role( GTaskRolePacket *packet ) {
    g_return_val_if_fail( GTASK_IS_ROLE_PACKET( packet ), GTASK_ROLE_NONE );

    return packet->private->role;
}

void
gtask_role_packet_set_role( GTaskRolePacket *packet, GTaskRole role ) {
    g_return_if_fail( GTASK_IS_ROLE_PACKET( packet ) );

    packet->private->role = role;
}

void
gtask_role_packet_set_role_from_name( GTaskRolePacket *packet,
                                      const char *name )
{
    g_return_if_fail( GTASK_IS_ROLE_PACKET( packet ) );
    g_return_if_fail( name != NULL );

    gtask_role_packet_set_role( packet, gtask_role_from_name( name ) );
}

const char *
gtask_role_packet_get_role_name( GTaskRolePacket *packet ) {
    g_return_val_if_fail( GTASK_IS_ROLE_PACKET( packet ), "none" );

    return gtask_role_name( gtask_role_packet_get_role( packet ) );
}

GTaskRole
gtask_role_from_name( const char *name ) {
    g_return_val_if_fail( name != NULL, GTASK_ROLE_NONE );

    if( strcasecmp( name, "proxy" ) == 0 ) {
        return GTASK_ROLE_PROXY;
    } else if( strcasecmp( name, "reporter" ) == 0 ) {
        return GTASK_ROLE_REPORTER;
    } else if( strcasecmp( name, "provider" ) == 0 ) {
        return GTASK_ROLE_PROVIDER;
    }

    return GTASK_ROLE_NONE;
}

const char *
gtask_role_name( GTaskRole role ) {
    switch( role ) {
        case GTASK_ROLE_PROXY:
            return "proxy";
        case GTASK_ROLE_REPORTER:
            return "reporter";
        case GTASK_ROLE_PROVIDER:
            return "provider";
        case GTASK_ROLE_NONE:
        default:
            return "none";
    }

    return "none";
}

/* @} */

---