gio2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/gio2/{gsocket.c → rbgiosocket.c}

@@ -1,33 +1,31 @@
-/* -*- c-file-style: "ruby" -*- */
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- * Ruby/GIO: a Ruby binding of gio-2.0.x.
- * Copyright (C) 2008-2009  Ruby-GNOME2 Project Team
+ *  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.
+ *  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.
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  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 "gio2.h"
+#include "rbgio2private.h"
 
+#define RG_TARGET_NAMESPACE cSocket
 #define _SELF(value) RVAL2GSOCKET(value)
 
-#define RVAL2GIOCONDITION(value) RVAL2GFLAGS((value), G_TYPE_IO_CONDITION)
-
-#define GIOCONDITION2RVAL(value) GENUM2RVAL((value), G_TYPE_IO_CONDITION)
-
 static VALUE
-socket_initialize(int argc, VALUE *argv, VALUE self)
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
         VALUE family, type, protocol;
         GError *error = NULL;
@@ -47,7 +45,7 @@ socket_initialize(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socket_new_from_fd(G_GNUC_UNUSED VALUE self, VALUE id)
+rg_s_new_from_fd(G_GNUC_UNUSED VALUE self, VALUE id)
 {
         GError *error = NULL;
         GSocket *socket;
@@ -60,7 +58,7 @@ socket_new_from_fd(G_GNUC_UNUSED VALUE self, VALUE id)
 }
 
 static VALUE
-socket_bind(VALUE self, VALUE address, VALUE allow_reuse)
+rg_bind(VALUE self, VALUE address, VALUE allow_reuse)
 {
         GError *error = NULL;
 
@@ -74,7 +72,7 @@ socket_bind(VALUE self, VALUE address, VALUE allow_reuse)
 }
 
 static VALUE
-socket_listen(VALUE self)
+rg_listen(VALUE self)
 {
         GError *error = NULL;
 
@@ -85,7 +83,7 @@ socket_listen(VALUE self)
 }
 
 static VALUE
-socket_accept(int argc, VALUE *argv, VALUE self)
+rg_accept(int argc, VALUE *argv, VALUE self)
 {
         VALUE cancellable;
         GError *error = NULL;
@@ -102,7 +100,7 @@ socket_accept(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socket_connect(int argc, VALUE *argv, VALUE self)
+rg_connect(int argc, VALUE *argv, VALUE self)
 {
         VALUE address, cancellable;
         GError *error = NULL;
@@ -119,7 +117,7 @@ socket_connect(int argc, VALUE *argv, VALUE self)
 
 /* TODO: This makes very little sense in Ruby.  How do we deal with it? */
 static VALUE
-socket_check_connect_result(VALUE self)
+rg_check_connect_result(VALUE self)
 {
         GError *error = NULL;
 
@@ -130,7 +128,7 @@ socket_check_connect_result(VALUE self)
 }
 
 static VALUE
-socket_receive(int argc, VALUE *argv, VALUE self)
+rg_receive(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbbytes, cancellable, result;
         GError *error = NULL;
@@ -148,7 +146,7 @@ socket_receive(int argc, VALUE *argv, VALUE self)
         if (read == -1)
                 rbgio_raise_error(error);
 
-        /* TODO: This is what Ruby does, but I can’t figure out why one needs
+        /* TODO: This is what Ruby does, but I can't figure out why one needs
          * both. */
         rb_str_set_len(result, read);
         rb_str_resize(result, read);
@@ -158,7 +156,7 @@ socket_receive(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socket_receive_from(int argc, VALUE *argv, VALUE self)
+rg_receive_from(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbbytes, cancellable, result;
         GSocketAddress *address;
@@ -186,7 +184,7 @@ socket_receive_from(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socket_send(int argc, VALUE *argv, VALUE self)
+rg_send(int argc, VALUE *argv, VALUE self)
 {
         VALUE buffer, cancellable;
         GError *error = NULL;
@@ -206,7 +204,7 @@ socket_send(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socket_send_to(int argc, VALUE *argv, VALUE self)
+rg_send_to(int argc, VALUE *argv, VALUE self)
 {
         VALUE address, buffer, cancellable;
         GError *error = NULL;
@@ -227,7 +225,7 @@ socket_send_to(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socket_close(VALUE self)
+rg_close(VALUE self)
 {
         GError *error = NULL;
 
@@ -238,13 +236,13 @@ socket_close(VALUE self)
 }
 
 static VALUE
-socket_is_closed(VALUE self)
+rg_closed_p(VALUE self)
 {
         return CBOOL2RVAL(g_socket_is_closed(_SELF(self)));
 }
 
 static VALUE
-socket_shutdown(VALUE self, VALUE shutdown_read, VALUE shutdown_write)
+rg_shutdown(VALUE self, VALUE shutdown_read, VALUE shutdown_write)
 {
         GError *error = NULL;
 
@@ -258,13 +256,13 @@ socket_shutdown(VALUE self, VALUE shutdown_read, VALUE shutdown_write)
 }
 
 static VALUE
-socket_is_connected(VALUE self)
+rg_connected_p(VALUE self)
 {
         return (g_socket_is_connected(_SELF(self)));
 }
 
 static VALUE
-socket_create_source(int argc, VALUE *argv, VALUE self)
+rg_create_source(int argc, VALUE *argv, VALUE self)
 {
         VALUE condition, cancellable;
 
@@ -276,14 +274,14 @@ socket_create_source(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socket_condition_check(VALUE self, VALUE condition)
+rg_condition_check(VALUE self, VALUE condition)
 {
         return GIOCONDITION2RVAL(g_socket_condition_check(_SELF(self),
                                                           RVAL2GIOCONDITION(condition)));
 }
 
 static VALUE
-socket_condition_wait(int argc, VALUE *argv, VALUE self)
+rg_condition_wait(int argc, VALUE *argv, VALUE self)
 {
         VALUE condition, cancellable;
         GError *error = NULL;
@@ -325,48 +323,48 @@ socket_get_remote_address(VALUE self)
 }
 
 static VALUE
-socket_speaks_ipv4(VALUE self)
+rg_speaks_ipv4_p(VALUE self)
 {
         return CBOOL2RVAL(g_socket_speaks_ipv4(_SELF(self)));
 }
 
 void
-Init_gsocket(VALUE glib)
+Init_gsocket(VALUE mGio)
 {
-        VALUE socket = G_DEF_CLASS(G_TYPE_SOCKET, "Socket", glib);
-
-        G_DEF_CLASS(G_TYPE_SOCKET_FAMILY, "Family", socket);
-        G_DEF_CONSTANTS(socket, G_TYPE_SOCKET_FAMILY, "G_SOCKET_");
-
-        G_DEF_CLASS(G_TYPE_SOCKET_TYPE, "Type", socket);
-        G_DEF_CONSTANTS(socket, G_TYPE_SOCKET_TYPE, "G_SOCKET_");
-
-        G_DEF_CLASS(G_TYPE_SOCKET_PROTOCOL, "Protocol", socket);
-        G_DEF_CONSTANTS(socket, G_TYPE_SOCKET_PROTOCOL, "G_SOCKET_");
-
-        G_DEF_CLASS(G_TYPE_SOCKET_MSG_FLAGS, "MsgFlags", socket);
-        G_DEF_CONSTANTS(socket, G_TYPE_SOCKET_MSG_FLAGS, "G_SOCKET_");
-
-        rb_define_singleton_method(socket, "new_from_fd", socket_new_from_fd, 1);
-
-        rb_define_method(socket, "initialize", socket_initialize, -1);
-        rb_define_method(socket, "bind", socket_bind, 2);
-        rb_define_method(socket, "listen", socket_listen, 0);
-        rb_define_method(socket, "accept", socket_accept, -1);
-        rb_define_method(socket, "connect", socket_connect, -1);
-        rb_define_method(socket, "check_connect_result", socket_check_connect_result, 0);
-        rb_define_method(socket, "receive", socket_receive, -1);
-        rb_define_method(socket, "receive_from", socket_receive_from, -1);
-        rb_define_method(socket, "send", socket_send, -1);
-        rb_define_method(socket, "send_to", socket_send_to, -1);
-        rb_define_method(socket, "close", socket_close, -1);
-        rb_define_method(socket, "closed?", socket_is_closed, 0);
-        rb_define_method(socket, "shutdown", socket_shutdown, 2);
-        rb_define_method(socket, "connected?", socket_is_connected, 0);
-        rb_define_method(socket, "create_source", socket_create_source, -1);
-        rb_define_method(socket, "condition_check", socket_condition_check, 1);
-        rb_define_method(socket, "condition_wait", socket_condition_wait, -1);
-        G_REPLACE_GET_PROPERTY(socket, "local_address", socket_get_local_address, 0);
-        G_REPLACE_GET_PROPERTY(socket, "remote_address", socket_get_remote_address, 0);
-        rb_define_method(socket, "speaks_ipv4?", socket_speaks_ipv4, 0);
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_SOCKET, "Socket", mGio);
+
+        G_DEF_CLASS(G_TYPE_SOCKET_FAMILY, "Family", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_SOCKET_FAMILY, "G_SOCKET_");
+
+        G_DEF_CLASS(G_TYPE_SOCKET_TYPE, "Type", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_SOCKET_TYPE, "G_SOCKET_");
+
+        G_DEF_CLASS(G_TYPE_SOCKET_PROTOCOL, "Protocol", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_SOCKET_PROTOCOL, "G_SOCKET_");
+
+        G_DEF_CLASS(G_TYPE_SOCKET_MSG_FLAGS, "MsgFlags", RG_TARGET_NAMESPACE);
+        G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_SOCKET_MSG_FLAGS, "G_SOCKET_");
+
+        RG_DEF_SMETHOD(new_from_fd, 1);
+
+        RG_DEF_METHOD(initialize, -1);
+        RG_DEF_METHOD(bind, 2);
+        RG_DEF_METHOD(listen, 0);
+        RG_DEF_METHOD(accept, -1);
+        RG_DEF_METHOD(connect, -1);
+        RG_DEF_METHOD(check_connect_result, 0);
+        RG_DEF_METHOD(receive, -1);
+        RG_DEF_METHOD(receive_from, -1);
+        RG_DEF_METHOD(send, -1);
+        RG_DEF_METHOD(send_to, -1);
+        RG_DEF_METHOD(close, -1);
+        RG_DEF_METHOD_P(closed, 0);
+        RG_DEF_METHOD(shutdown, 2);
+        RG_DEF_METHOD_P(connected, 0);
+        RG_DEF_METHOD(create_source, -1);
+        RG_DEF_METHOD(condition_check, 1);
+        RG_DEF_METHOD(condition_wait, -1);
+        G_REPLACE_GET_PROPERTY(RG_TARGET_NAMESPACE, "local_address", socket_get_local_address, 0);
+        G_REPLACE_GET_PROPERTY(RG_TARGET_NAMESPACE, "remote_address", socket_get_remote_address, 0);
+        RG_DEF_METHOD_P(speaks_ipv4, 0);
 }

data/ext/gio2/rbgiosocketaddress.c

@@ -0,0 +1,34 @@
+/* -*- 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"
+
+/* TODO: new_from_native? */
+
+/* TODO: to_native? */
+
+/* TODO: get_native_size? */
+
+void
+Init_gsocketaddress(VALUE mGio)
+{
+        (void)G_DEF_CLASS(G_TYPE_SOCKET_ADDRESS, "SocketAddress", mGio);
+}

data/ext/gio2/rbgiosocketaddressenumerator.c

@@ -0,0 +1,83 @@
+/*
+ *  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 cSocketAddressEnumerator
+#define _SELF(value) RVAL2GSOCKETADDRESSENUMERATOR(value)
+
+static VALUE
+rg_next(int argc, VALUE *argv, VALUE self)
+{
+        VALUE cancellable;
+        GError *error = NULL;
+        GSocketAddress *address;
+
+        rb_scan_args(argc, argv, "01", &cancellable);
+        address = g_socket_address_enumerator_next(_SELF(self),
+                                                   RVAL2GCANCELLABLE(cancellable),
+                                                   &error);
+        if (error != NULL)
+                rbgio_raise_error(error);
+
+        return GOBJ2RVAL(address);
+}
+
+static VALUE
+rg_next_async(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbcancellable, block;
+        GCancellable *cancellable;
+
+        rb_scan_args(argc, argv, "01&", &rbcancellable, &block);
+        cancellable = RVAL2GCANCELLABLE(rbcancellable);
+        SAVE_BLOCK(block);
+        g_socket_address_enumerator_next_async(_SELF(self),
+                                               cancellable,
+                                               rbgio_async_ready_callback,
+                                               (gpointer)block);
+
+        return self;
+}
+
+static VALUE
+rg_next_finish(VALUE self, VALUE result)
+{
+        GError *error = NULL;
+        GSocketAddress *address;
+
+        address = g_socket_address_enumerator_next_finish(_SELF(self),
+                                                          RVAL2GASYNCRESULT(result),
+                                                          &error);
+        if (address == NULL)
+                rbgio_raise_error(error);
+
+        return GOBJ2RVAL(address);
+}
+
+void
+Init_gsocketaddressenumerator(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_SOCKET_ADDRESS_ENUMERATOR, "SocketAddressEnumerator", mGio);
+
+        RG_DEF_METHOD(next, -1);
+        RG_DEF_METHOD(next_async, -1);
+        RG_DEF_METHOD(next_finish, 1);
+}

data/ext/gio2/{gsocketclient.c → rbgiosocketclient.c}

@@ -1,29 +1,31 @@
-/* -*- c-file-style: "ruby" -*- */
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- * Ruby/GIO: a Ruby binding of gio-2.0.x.
- * Copyright (C) 2008-2009  Ruby-GNOME2 Project Team
+ *  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.
+ *  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.
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  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 "gio2.h"
+#include "rbgio2private.h"
 
-#define _SELF(value) G_SOCKET_CLIENT(RVAL2GOBJ(value))
+#define RG_TARGET_NAMESPACE cSocketClient
+#define _SELF(value) RVAL2GSOCKETCLIENT(value)
 
 static VALUE
-socketclient_initialize(VALUE self)
+rg_initialize(VALUE self)
 {
         G_INITIALIZE(self, g_socket_client_new());
 
@@ -31,7 +33,7 @@ socketclient_initialize(VALUE self)
 }
 
 static VALUE
-socketclient_connect(int argc, VALUE *argv, VALUE self)
+rg_connect(int argc, VALUE *argv, VALUE self)
 {
         VALUE connectable, cancellable;
         GError *error = NULL;
@@ -49,7 +51,7 @@ socketclient_connect(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socketclient_connect_async(int argc, VALUE *argv, VALUE self)
+rg_connect_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbconnectable, rbcancellable, block;
         GCancellable *cancellable;
@@ -86,13 +88,13 @@ connection_finish_method(ConnectionFinishMethod method, VALUE self, VALUE result
 }
 
 static VALUE
-socketclient_connect_finish(VALUE self, VALUE result)
+rg_connect_finish(VALUE self, VALUE result)
 {
         return connection_finish_method(g_socket_client_connect_finish, self, result);
 }
 
 static VALUE
-socketclient_connect_to_host(int argc, VALUE *argv, VALUE self)
+rg_connect_to_host(int argc, VALUE *argv, VALUE self)
 {
         VALUE host_and_port, default_port, cancellable;
         GError *error = NULL;
@@ -111,7 +113,7 @@ socketclient_connect_to_host(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socketclient_connect_to_host_async(int argc, VALUE *argv, VALUE self)
+rg_connect_to_host_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbhost_and_port, rbdefault_port, rbcancellable, block;
         GCancellable *cancellable;
@@ -134,13 +136,13 @@ socketclient_connect_to_host_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socketclient_connect_to_host_finish(VALUE self, VALUE result)
+rg_connect_to_host_finish(VALUE self, VALUE result)
 {
         return connection_finish_method(g_socket_client_connect_to_host_finish, self, result);
 }
 
 static VALUE
-socketclient_connect_to_service(int argc, VALUE *argv, VALUE self)
+rg_connect_to_service(int argc, VALUE *argv, VALUE self)
 {
         VALUE domain, service, cancellable;
         GError *error = NULL;
@@ -159,7 +161,7 @@ socketclient_connect_to_service(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socketclient_connect_to_service_async(int argc, VALUE *argv, VALUE self)
+rg_connect_to_service_async(int argc, VALUE *argv, VALUE self)
 {
         VALUE rbdomain, rbservice, rbcancellable, block;
         GCancellable *cancellable;
@@ -182,24 +184,24 @@ socketclient_connect_to_service_async(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-socketclient_connect_to_service_finish(VALUE self, VALUE result)
+rg_connect_to_service_finish(VALUE self, VALUE result)
 {
         return connection_finish_method(g_socket_client_connect_to_service_finish, self, result);
 }
 
 void
-Init_gsocketclient(VALUE glib)
+Init_gsocketclient(VALUE mGio)
 {
-        VALUE socketclient = G_DEF_CLASS(G_TYPE_SOCKET_CLIENT, "SocketClient", glib);
-
-        rb_define_method(socketclient, "initialize", socketclient_initialize, 0);
-        rb_define_method(socketclient, "connect", socketclient_connect, -1);
-        rb_define_method(socketclient, "connect_async", socketclient_connect_async, -1);
-        rb_define_method(socketclient, "connect_finish", socketclient_connect_finish, 1);
-        rb_define_method(socketclient, "connect_to_host", socketclient_connect_to_host, -1);
-        rb_define_method(socketclient, "connect_to_host_async", socketclient_connect_to_host_async, -1);
-        rb_define_method(socketclient, "connect_to_host_finish", socketclient_connect_to_host_finish, 1);
-        rb_define_method(socketclient, "connect_to_service", socketclient_connect_to_service, -1);
-        rb_define_method(socketclient, "connect_to_service_async", socketclient_connect_to_service_async, -1);
-        rb_define_method(socketclient, "connect_to_service_finish", socketclient_connect_to_service_finish, 1);
+        VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_SOCKET_CLIENT, "SocketClient", mGio);
+
+        RG_DEF_METHOD(initialize, 0);
+        RG_DEF_METHOD(connect, -1);
+        RG_DEF_METHOD(connect_async, -1);
+        RG_DEF_METHOD(connect_finish, 1);
+        RG_DEF_METHOD(connect_to_host, -1);
+        RG_DEF_METHOD(connect_to_host_async, -1);
+        RG_DEF_METHOD(connect_to_host_finish, 1);
+        RG_DEF_METHOD(connect_to_service, -1);
+        RG_DEF_METHOD(connect_to_service_async, -1);
+        RG_DEF_METHOD(connect_to_service_finish, 1);
 }

data/ext/gio2/rbgiosocketconnectable.c

@@ -0,0 +1,41 @@
+/* -*- 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 mSocketConnectable
+#define _SELF(value) RVAL2GSOCKETCONNECTABLE(value)
+
+static VALUE
+rg_enumerate(VALUE self)
+{
+        return GOBJ2RVAL(g_socket_connectable_enumerate(_SELF(self)));
+}
+
+void
+Init_gsocketconnectable(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE;
+
+        RG_TARGET_NAMESPACE = G_DEF_INTERFACE(G_TYPE_SOCKET_CONNECTABLE, "SocketConnectable", mGio);
+
+        RG_DEF_METHOD(enumerate, 0);
+}

data/ext/gio2/rbgiosocketconnection.c

@@ -0,0 +1,66 @@
+/* -*- 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 cSocketConnection
+#define _SELF(value) RVAL2GSOCKETCONNECTION(value)
+
+static VALUE
+rg_local_address(VALUE self)
+{
+        GError *error = NULL;
+        GSocketAddress *address;
+
+        address = g_socket_connection_get_local_address(_SELF(self), &error);
+        if (address == NULL)
+                rbgio_raise_error(error);
+
+        return GOBJ2RVAL_UNREF(address);
+}
+
+static VALUE
+rg_remote_address(VALUE self)
+{
+        GError *error = NULL;
+        GSocketAddress *address;
+
+        address = g_socket_connection_get_remote_address(_SELF(self), &error);
+        if (address == NULL)
+                rbgio_raise_error(error);
+
+        return GOBJ2RVAL_UNREF(address);
+}
+
+/* TODO: lookup_type */
+
+/* TODO: register_type */
+
+void
+Init_gsocketconnection(VALUE mGio)
+{
+        VALUE RG_TARGET_NAMESPACE;
+
+        RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_SOCKET_CONNECTION, "SocketConnection", mGio);
+
+        RG_DEF_METHOD(local_address, 0);
+        RG_DEF_METHOD(remote_address, 0);
+}