gio2 2.1.0-x86-mingw32 → 2.2.0-x86-mingw32

data/ext/gio2/rbgiooutputstream.c

@@ -1,331 +0,0 @@
-/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
- *  Copyright (C) 2008-2009  Ruby-GNOME2 Project Team
- *
- *  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
- */
-
-#include "rbgio2private.h"
-
-#define RG_TARGET_NAMESPACE cOutputStream
-#define _SELF(value) RVAL2GOUTPUTSTREAM(value)
-
-#define RVAL2GOUTPUTSTREAMSPLICEFLAGSDEFAULT(value) \
-        RVAL2TYPE_WITH_DEFAULT((value), \
-                               RVAL2GOUTPUTSTREAMSPLICEFLAGS, \
-                               G_OUTPUT_STREAM_SPLICE_NONE)
-
-static VALUE
-rg_write(int argc, VALUE *argv, VALUE self)
-{
-        VALUE rbbuffer, cancellable;
-        const char *buffer;
-        GError *error = NULL;
-        gssize bytes_written;
-
-        rb_scan_args(argc, argv, "11", &rbbuffer, &cancellable);
-        buffer = RVAL2CSTR(rbbuffer);
-        bytes_written = g_output_stream_write(_SELF(self),
-                                              buffer,
-                                              (gsize)RSTRING_LEN(rbbuffer),
-                                              RVAL2GCANCELLABLE(cancellable),
-                                              &error);
-        if (bytes_written == -1)
-                rbgio_raise_error(error);
-
-        return GSSIZE2RVAL(bytes_written);
-}
-
-static VALUE
-rg_write_all(int argc, VALUE *argv, VALUE self)
-{
-        VALUE rbbuffer, cancellable;
-        const char *buffer;
-        gsize bytes_written;
-        GError *error = NULL;
-
-        rb_scan_args(argc, argv, "11", &rbbuffer, &cancellable);
-        buffer = RVAL2CSTR(rbbuffer);
-        if (!g_output_stream_write_all(_SELF(self),
-                                       buffer,
-                                       (gsize)RSTRING_LEN(rbbuffer),
-                                       &bytes_written,
-                                       RVAL2GCANCELLABLE(cancellable),
-                                       &error))
-                rbgio_raise_error(error);
-
-        return GSIZE2RVAL(bytes_written);
-}
-
-static VALUE
-rg_splice(int argc, VALUE *argv, VALUE self)
-{
-        VALUE source, flags, cancellable;
-        GError *error = NULL;
-        gssize bytes_spliced;
-
-        rb_scan_args(argc, argv, "12", &source, &flags, &cancellable);
-        bytes_spliced = g_output_stream_splice(_SELF(self),
-                                               RVAL2GINPUTSTREAM(source),
-                                               RVAL2GOUTPUTSTREAMSPLICEFLAGSDEFAULT(flags),
-                                               RVAL2GCANCELLABLE(cancellable),
-                                               &error);
-        if (bytes_spliced == -1)
-                rbgio_raise_error(error);
-
-        return GSSIZE2RVAL(bytes_spliced);
-}
-
-typedef gboolean (*CancellableMethod)(GOutputStream *, GCancellable *, GError **);
-
-static VALUE
-cancellable_method(CancellableMethod method, int argc, VALUE *argv, VALUE self)
-{
-        VALUE cancellable;
-        GError *error = NULL;
-
-        rb_scan_args(argc, argv, "01", &cancellable);
-        if (!method(_SELF(self), RVAL2GCANCELLABLE(cancellable), &error))
-                rbgio_raise_error(error);
-
-        return self;
-}
-
-static VALUE
-rg_flush(int argc, VALUE *argv, VALUE self)
-{
-        return cancellable_method(g_output_stream_flush, argc, argv, self);
-}
-
-static VALUE
-rg_close(int argc, VALUE *argv, VALUE self)
-{
-        return cancellable_method(g_output_stream_close, argc, argv, self);
-}
-
-/* TODO: Does it make sense to use buffer and count?  We should probably
- * provide a better wrapper that simply pumps out buffer while count hasn't
- * been reached, calling the callback with the bytes written, then with the
- * result. */
-static VALUE
-rg_write_async(int argc, VALUE *argv, VALUE self)
-{
-        VALUE rbbuffer, rbcount, rbio_priority, rbcancellable, block;
-        const gchar *buffer;
-        gsize count;
-        int io_priority;
-        GCancellable *cancellable;
-
-        rb_scan_args(argc, argv, "22&", &rbbuffer, &rbcount, &rbio_priority, &rbcancellable, &block);
-        buffer = RVAL2CSTR(rbbuffer);
-        count = RVAL2GSIZE(rbcount);
-        io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
-        cancellable = RVAL2GCANCELLABLE(rbcancellable);
-        SAVE_BLOCK(block);
-        g_output_stream_write_async(_SELF(self),
-                                    buffer,
-                                    count,
-                                    io_priority,
-                                    cancellable,
-                                    rbgio_async_ready_callback,
-                                    (gpointer)block);
-
-        return self;
-}
-
-typedef gssize (*SSizeFinishMethod)(GOutputStream *, GAsyncResult *, GError **);
-
-static VALUE
-ssize_finish_method(SSizeFinishMethod method, VALUE self, VALUE result)
-{
-        GError *error = NULL;
-        gssize bytes_read;
-
-        bytes_read = method(_SELF(self), RVAL2GASYNCRESULT(result), &error);
-        if (error != NULL)
-                rbgio_raise_error(error);
-
-        return GSSIZE2RVAL(bytes_read);
-}
-
-static VALUE
-rg_write_finish(VALUE self, VALUE result)
-{
-        return ssize_finish_method(g_output_stream_write_finish, self, result);
-}
-
-static VALUE
-rg_splice_async(int argc, VALUE *argv, VALUE self)
-{
-        VALUE rbsource, rbflags, rbio_priority, rbcancellable, block;
-        GInputStream *source;
-        GOutputStreamSpliceFlags flags;
-        int io_priority;
-        GCancellable *cancellable;
-
-        rb_scan_args(argc, argv, "12&", &rbsource, &rbflags, &rbio_priority, &rbcancellable, &block);
-        source = RVAL2GINPUTSTREAM(rbsource);
-        flags = RVAL2GOUTPUTSTREAMSPLICEFLAGSDEFAULT(rbflags);
-        io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
-        cancellable = RVAL2GCANCELLABLE(rbcancellable);
-        SAVE_BLOCK(block);
-        g_output_stream_splice_async(_SELF(self),
-                                     source,
-                                     flags,
-                                     io_priority,
-                                     cancellable,
-                                     rbgio_async_ready_callback,
-                                     (gpointer)block);
-
-        return self;
-}
-
-static VALUE
-rg_splice_finish(VALUE self, VALUE result)
-{
-        return ssize_finish_method(g_output_stream_splice_finish, self, result);
-}
-
-static VALUE
-rg_flush_async(int argc, VALUE *argv, VALUE self)
-{
-        VALUE rbio_priority, rbcancellable, block;
-        int io_priority;
-        GCancellable *cancellable;
-
-        rb_scan_args(argc, argv, "02&", &rbio_priority, &rbcancellable, &block);
-        io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
-        cancellable = RVAL2GCANCELLABLE(rbcancellable);
-        SAVE_BLOCK(block);
-        g_output_stream_flush_async(_SELF(self),
-                                    io_priority,
-                                    cancellable,
-                                    rbgio_async_ready_callback,
-                                    (gpointer)block);
-
-        return self;
-}
-
-typedef gboolean (*BooleanFinishMethod)(GOutputStream *, GAsyncResult *, GError **);
-
-static VALUE
-boolean_finish_method(BooleanFinishMethod method, VALUE self, VALUE result)
-{
-        GError *error = NULL;
-
-        if (!method(_SELF(self), RVAL2GASYNCRESULT(result), &error))
-                rbgio_raise_error(error);
-
-        return self;
-}
-
-static VALUE
-rg_flush_finish(VALUE self, VALUE result)
-{
-        return boolean_finish_method(g_output_stream_flush_finish, self, result);
-}
-
-static VALUE
-rg_close_async(int argc, VALUE *argv, VALUE self)
-{
-        VALUE rbio_priority, rbcancellable, block;
-        int io_priority;
-        GCancellable *cancellable;
-
-        rb_scan_args(argc, argv, "02&", &rbio_priority, &rbcancellable, &block);
-        io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
-        cancellable = RVAL2GCANCELLABLE(rbcancellable);
-        SAVE_BLOCK(block);
-        g_output_stream_close_async(_SELF(self),
-                                    io_priority,
-                                    cancellable,
-                                    rbgio_async_ready_callback,
-                                    (gpointer)block);
-
-        return self;
-}
-
-static VALUE
-rg_close_finish(VALUE self, VALUE result)
-{
-        return boolean_finish_method(g_output_stream_close_finish, self, result);
-}
-
-static VALUE
-rg_closing_p(VALUE self)
-{
-        return CBOOL2RVAL(g_output_stream_is_closing(_SELF(self)));
-}
-
-static VALUE
-rg_closed_p(VALUE self)
-{
-        return CBOOL2RVAL(g_output_stream_is_closed(_SELF(self)));
-}
-
-static VALUE
-rg_has_pending_p(VALUE self)
-{
-        return CBOOL2RVAL(g_output_stream_has_pending(_SELF(self)));
-}
-
-static VALUE
-rg_set_pending(VALUE self)
-{
-        GError *error = NULL;
-
-        if (!g_output_stream_set_pending(_SELF(self), &error))
-                rbgio_raise_error(error);
-
-        return self;
-}
-
-static VALUE
-rg_clear_pending(VALUE self)
-{
-        g_output_stream_clear_pending(_SELF(self));
-
-        return self;
-}
-
-void
-Init_goutputstream(VALUE mGio)
-{
-        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_OUTPUT_STREAM, "OutputStream", mGio);
-
-        G_DEF_CLASS(G_TYPE_OUTPUT_STREAM_SPLICE_FLAGS, "SpliceFlags", RG_TARGET_NAMESPACE);
-        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_OUTPUT_STREAM_SPLICE_FLAGS, "G_OUTPUT_STREAM_");
-
-        RG_DEF_METHOD(write, -1);
-        RG_DEF_METHOD(write_all, -1);
-        RG_DEF_METHOD(splice, -1);
-        RG_DEF_METHOD(flush, -1);
-        RG_DEF_METHOD(close, -1);
-        RG_DEF_METHOD(write_async, -1);
-        RG_DEF_METHOD(write_finish, 1);
-        RG_DEF_METHOD(splice_async, -1);
-        RG_DEF_METHOD(splice_finish, 1);
-        RG_DEF_METHOD(flush_async, -1);
-        RG_DEF_METHOD(flush_finish, 1);
-        RG_DEF_METHOD(close_async, -1);
-        RG_DEF_METHOD(close_finish, 0);
-        RG_DEF_METHOD_P(closing, 0);
-        RG_DEF_METHOD_P(closed, 0);
-        RG_DEF_METHOD_P(has_pending, 0);
-        RG_DEF_METHOD(set_pending, 0);
-        RG_DEF_METHOD(clear_pending, 0);
-}

data/ext/gio2/rbgioresolver.c

@@ -1,230 +0,0 @@
-/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
- *  Copyright (C) 2008-2009  Ruby-GNOME2 Project Team
- *
- *  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
- */
-
-#include "rbgio2private.h"
-
-#define RG_TARGET_NAMESPACE cResolver
-#define _SELF(value) RVAL2GRESOLVER(value)
-
-static VALUE
-rg_s_default(G_GNUC_UNUSED VALUE self)
-{
-        return GOBJ2RVAL_UNREF(g_resolver_get_default());
-}
-
-static VALUE
-rg_s_set_default(G_GNUC_UNUSED VALUE self, VALUE resolver)
-{
-        g_resolver_set_default(_SELF(resolver));
-
-        return self;
-}
-
-static VALUE
-rg_lookup_by_name(VALUE self, VALUE hostname, VALUE cancellable)
-{
-        GError *error = NULL;
-        GList *addresses;
-
-        addresses = g_resolver_lookup_by_name(_SELF(self),
-                                              RVAL2CSTR(hostname),
-                                              RVAL2GCANCELLABLE(cancellable),
-                                              &error);
-        if (addresses == NULL)
-                rbgio_raise_error(error);
-
-        return GLIST2ARY_UNREF_FREE(addresses);
-}
-
-static VALUE
-rg_lookup_by_name_async(int argc, VALUE *argv, VALUE self)
-{
-        VALUE rbhostname, rbcancellable, block;
-        const gchar *hostname;
-        GCancellable *cancellable;
-
-        rb_scan_args(argc, argv, "11&", &hostname, &rbcancellable, &block);
-        hostname = RVAL2CSTR(rbhostname);
-        cancellable = RVAL2GCANCELLABLE(rbcancellable);
-        SAVE_BLOCK(block);
-        g_resolver_lookup_by_name_async(_SELF(self),
-                                        hostname,
-                                        cancellable,
-                                        rbgio_async_ready_callback,
-                                        (gpointer)block);
-
-        return self;
-}
-
-static VALUE
-rg_lookup_by_name_finish(VALUE self, VALUE result)
-{
-        GError *error = NULL;
-        GList *addresses;
-
-        addresses = g_resolver_lookup_by_name_finish(_SELF(self),
-                                                     RVAL2GASYNCRESULT(result),
-                                                     &error);
-        if (addresses == NULL)
-                rbgio_raise_error(error);
-
-        return GLIST2ARY_UNREF_FREE(addresses);
-}
-
-static VALUE
-rg_lookup_by_address(int argc, VALUE *argv, VALUE self)
-{
-        VALUE address, cancellable;
-        GError *error = NULL;
-        gchar *hostname;
-
-        rb_scan_args(argc, argv, "11", &address, &cancellable);
-        hostname = g_resolver_lookup_by_address(_SELF(self),
-                                                RVAL2GINETADDRESS(address),
-                                                RVAL2GCANCELLABLE(cancellable),
-                                                &error);
-        if (hostname == NULL)
-                rbgio_raise_error(error);
-
-        return CSTR2RVAL_FREE(hostname);
-}
-
-static VALUE
-rg_lookup_by_address_async(int argc, VALUE *argv, VALUE self)
-{
-        VALUE rbaddress, rbcancellable, block;
-        GInetAddress *address;
-        GCancellable *cancellable;
-
-        rb_scan_args(argc, argv, "11&", &rbaddress, &rbcancellable, &block);
-        address = RVAL2GINETADDRESS(rbaddress);
-        cancellable = RVAL2GCANCELLABLE(rbcancellable);
-        SAVE_BLOCK(block);
-        g_resolver_lookup_by_address_async(_SELF(self),
-                                           address,
-                                           cancellable,
-                                           rbgio_async_ready_callback,
-                                           (gpointer)block);
-
-        return self;
-}
-
-static VALUE
-rg_lookup_by_address_finish(VALUE self, VALUE result)
-{
-        GError *error = NULL;
-        gchar *hostname;
-
-        hostname = g_resolver_lookup_by_address_finish(_SELF(self),
-                                                       RVAL2GASYNCRESULT(result),
-                                                       &error);
-        if (hostname == NULL)
-                rbgio_raise_error(error);
-
-        return CSTR2RVAL_FREE(hostname);
-}
-
-static VALUE
-rg_lookup_service(int argc, VALUE *argv, VALUE self)
-{
-        VALUE service, protocol, domain, cancellable;
-        GError *error = NULL;
-        GList *targets;
-
-        rb_scan_args(argc, argv, "31", &service, &protocol, &domain, &cancellable);
-        targets = g_resolver_lookup_service(_SELF(self),
-                                            RVAL2CSTR(service),
-                                            RVAL2CSTR(protocol),
-                                            RVAL2CSTR(domain),
-                                            RVAL2GCANCELLABLE(cancellable),
-                                            &error);
-        if (targets == NULL)
-                rbgio_raise_error(error);
-
-        return GLIST2ARY_UNREF_FREE(targets);
-}
-
-static VALUE
-rg_lookup_service_async(int argc, VALUE *argv, VALUE self)
-{
-        VALUE rbservice, rbprotocol, rbdomain, rbcancellable, block;
-        const gchar *service;
-        const gchar *protocol;
-        const gchar *domain;
-        GCancellable *cancellable;
-
-        rb_scan_args(argc, argv, "31&", &rbservice, &rbprotocol, &rbdomain, &rbcancellable, &block);
-        service = RVAL2CSTR(rbservice);
-        protocol = RVAL2CSTR(rbprotocol);
-        domain = RVAL2CSTR(rbdomain);
-        cancellable = RVAL2GCANCELLABLE(rbcancellable);
-        SAVE_BLOCK(block);
-        g_resolver_lookup_service_async(_SELF(self),
-                                        service,
-                                        protocol,
-                                        domain,
-                                        cancellable,
-                                        rbgio_async_ready_callback,
-                                        (gpointer)block);
-
-        return self;
-}
-
-static VALUE
-rg_lookup_service_finish(VALUE self, VALUE result)
-{
-        GError *error = NULL;
-        GList *targets;
-
-        targets = g_resolver_lookup_service_finish(_SELF(self), RVAL2GASYNCRESULT(result), &error);
-        if (targets == NULL)
-                rbgio_raise_error(error);
-
-        return GLIST2ARY_UNREF_FREE(targets);
-}
-
-void
-Init_gresolver(VALUE mGio)
-{
-        VALUE RG_TARGET_NAMESPACE, error;
-
-        RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_RESOLVER, "Resolver", mGio);
-
-        RG_DEF_SMETHOD(default, 0);
-        RG_DEF_SMETHOD(set_default, 1);
-
-        /* TODO: Taint result of these methods? */
-        RG_DEF_METHOD(lookup_by_name, 2);
-        RG_DEF_METHOD(lookup_by_name_async, -1);
-        RG_DEF_METHOD(lookup_by_name_finish, 1);
-        RG_DEF_METHOD(lookup_by_address, -1);
-        RG_DEF_METHOD(lookup_by_address_async, -1);
-        RG_DEF_METHOD(lookup_by_address_finish, 1);
-        RG_DEF_METHOD(lookup_service, -1);
-        RG_DEF_METHOD(lookup_service_async, -1);
-        RG_DEF_METHOD(lookup_service_finish, 1);
-
-        error = rbgio_define_domain_error(RG_TARGET_NAMESPACE, "Error", G_RESOLVER_ERROR, "GResolverErrorEnum", rb_eIOError);
-
-        rbgio_define_error(RG_TARGET_NAMESPACE, "NotFoundError", G_RESOLVER_ERROR_NOT_FOUND, error);
-        rbgio_define_error(RG_TARGET_NAMESPACE, "TemporaryFailureError", G_RESOLVER_ERROR_TEMPORARY_FAILURE, error);
-        rbgio_define_error(RG_TARGET_NAMESPACE, "InternalError", G_RESOLVER_ERROR_INTERNAL, error);
-}

data/ext/gio2/rbgioseekable.c

@@ -1,91 +0,0 @@
-/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
- *  Copyright (C) 2008-2009  Ruby-GNOME2 Project Team
- *
- *  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
- */
-
-#include "rbgio2private.h"
-
-#define RG_TARGET_NAMESPACE mSeekable
-#define _SELF(value) RVAL2GSEEKABLE(value)
-
-#define RVAL2GSEEKTYPEDEFAULT(value) \
-        RVAL2TYPE_WITH_DEFAULT((value), NUM2INT, G_SEEK_CUR)
-
-static VALUE
-rg_tell(VALUE self)
-{
-        return GOFFSET2RVAL(g_seekable_tell(_SELF(self)));
-}
-
-static VALUE
-rg_can_seek_p(VALUE self)
-{
-        return CBOOL2RVAL(g_seekable_can_seek(_SELF(self)));
-}
-
-static VALUE
-rg_seek(int argc, VALUE *argv, VALUE self)
-{
-        VALUE offset, type, cancellable;
-        GError *error = NULL;
-
-        rb_scan_args(argc, argv, "12", &offset, &type, &cancellable);
-        if (!g_seekable_seek(_SELF(self),
-                             RVAL2GOFFSET(offset),
-                             RVAL2GSEEKTYPEDEFAULT(type),
-                             RVAL2GCANCELLABLE(cancellable),
-                             &error))
-                rbgio_raise_error(error);
-
-        return self;
-}
-
-static VALUE
-rg_can_truncate_p(VALUE self)
-{
-        return CBOOL2RVAL(g_seekable_can_truncate(_SELF(self)));
-}
-
-static VALUE
-rg_truncate(int argc, VALUE *argv, VALUE self)
-{
-        VALUE offset, cancellable;
-        GError *error = NULL;
-
-        rb_scan_args(argc, argv, "11", &offset, &cancellable);
-        if (!g_seekable_truncate(_SELF(self),
-                                 RVAL2GOFFSET(offset),
-                                 RVAL2GCANCELLABLE(cancellable),
-                                 &error))
-                rbgio_raise_error(error);
-
-        return self;
-}
-
-void
-Init_gseekable(VALUE mGio)
-{
-        VALUE RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_SEEKABLE, "Seekable", mGio);
-
-        RG_DEF_METHOD(tell, 0);
-        RG_DEF_METHOD_P(can_seek, 0);
-        RG_DEF_METHOD(seek, -1);
-        RG_DEF_METHOD_P(can_truncate, 0);
-        RG_DEF_METHOD(truncate, -1);
-}