gtask-error-packet.c

Go to the documentation of this file.

#include <gtask/gtask-error-packet.h>

/* @{ */

static gpointer parent_class;

static void
gtask_error_packet_class_init( GTaskErrorPacketClass *klass );

static void
gtask_error_packet_init( GTaskErrorPacket *packet, gpointer g_class );

static void
gtask_error_packet_finalize( GObject *obj );

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

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

    if( type == 0 ) {
        static const GTypeInfo info = {
            sizeof( GTaskErrorPacketClass ),
            NULL,   /* base_init */
            NULL,   /* base_finalize */
            (GClassInitFunc) gtask_error_packet_class_init,   /* class_init */
            NULL,   /* class_finalize */
            NULL,   /* class_data */
            sizeof( GTaskErrorPacket ),
            0,      /* n_preallocs */
            (GInstanceInitFunc) gtask_error_packet_init
        };

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

    return type;
}

static void
gtask_error_packet_class_init( GTaskErrorPacketClass *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_error_packet_finalize;

    packet_class->serialize_packet = gtask_error_packet_serialize_to;
}

static void
gtask_error_packet_init( GTaskErrorPacket *packet, gpointer g_class ) {
    GTaskErrorPacketPrivate *private = g_new0( GTaskErrorPacketPrivate, 1 );

    packet->private = private;

    private->error = GTASK_ERROR_NONE;
    private->error_msg = g_string_new( NULL );
}

static void
gtask_error_packet_finalize( GObject *obj ) {
    GTaskErrorPacket        *packet = GTASK_ERROR_PACKET( obj );
    GTaskErrorPacketPrivate *private = packet->private;

    g_string_free( private->error_msg, TRUE );

    g_free( private );

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

static gboolean
gtask_error_packet_serialize_to( GTaskPacket *packet, GTaskConnection *conn ) {
    GTaskErrorPacket   *e_packet;
    xmlOutputBufferPtr  xml_output;
    xmlDocPtr           doc;
    xmlNodePtr          error_node;
    xmlNodePtr          error_msg;

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

    e_packet = (GTaskErrorPacket *) packet;

    doc = xmlNewDoc( "1.0" );

    g_return_val_if_fail( doc != NULL, FALSE );

    error_node = xmlNewNode( NULL, "error" );

    if( !error_node ) {
        xmlFreeDoc( doc );

        return FALSE;
    }

    xmlDocSetRootElement( doc, error_node );
    xmlNewProp( error_node, "type", "0" ); //packet->private->error );

    error_msg = xmlNewText( e_packet->private->error_msg->str );

    if( !error_msg ) {
        xmlFreeDoc( doc );

        return FALSE;
    }

    xmlAddChild( error_node, error_msg );

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

    xmlFreeDoc( doc );

    return TRUE;
}

GTaskErrorPacket *
gtask_error_packet_new( ) {
    return g_object_new( GTASK_ERROR_PACKET_TYPE, NULL );
}

GTaskErrorType
gtask_error_packet_get_error_type( GTaskErrorPacket *packet ) {
    g_return_val_if_fail( GTASK_IS_ERROR_PACKET( packet ), GTASK_ERROR_NONE );

    return packet->private->error;
}

void
gtask_error_packet_set_error_type( GTaskErrorPacket *packet,
                                   GTaskErrorType error )
{
    g_return_if_fail( GTASK_IS_ERROR_PACKET( packet ) );

    packet->private->error = error;
}

const char *
gtask_error_packet_get_error_message( GTaskErrorPacket *packet ) {
    g_return_val_if_fail( GTASK_IS_ERROR_PACKET( packet ), "" );

    return packet->private->error_msg->str;
}

void
gtask_error_packet_set_error_message( GTaskErrorPacket *packet,
                                      const char *error_msg )
{
    GTaskErrorPacketPrivate *private;

    g_return_if_fail( GTASK_IS_ERROR_PACKET( packet ) );

    private = packet->private;

    g_string_assign( private->error_msg, error_msg );
}

/* @} */

---