Run clang-format on the examples.

3 files changed, 710 insertions, 736 deletions

diff --git a/examples/network/resolver.cc b/examples/network/resolver.cc
index a4f60bd0..97dc4d71 100644
--- a/examples/network/resolver.cc
+++ b/examples/network/resolver.cc
@@ -20,12 +20,12 @@
  */
 
 #ifndef _WIN32
-# include <config.h>
+#include <config.h>
 #endif
 #include <giomm.h>
-#include <thread>
 #include <iostream>
 #include <mutex>
+#include <thread>
 
 #include <cerrno>
 #include <csignal>
@@ -34,7 +34,7 @@
 #include <cstring>
 
 #ifndef G_OS_WIN32
-# include <unistd.h>
+#include <unistd.h>
 #endif
 
 #include <gio/gio.h>
@@ -45,165 +45,157 @@ static Glib::RefPtr<Glib::MainLoop> loop;
 static int nlookups = 0;
 
 static void G_GNUC_NORETURN
-usage (void)
+usage(void)
 {
-    std::cerr
-        << "Usage: resolver [-t] [-s] [hostname | IP | service/protocol/domain ] ...\n"
-        << "       resolver [-t] [-s] -c [hostname | IP | service/protocol/domain ]\n"
-        << "       Use -s to do synchronous lookups.\n"
-        << "       Use -c (and only a single resolvable argument) to test GSocketConnectable.\n";
-    exit (1);
+  std::cerr
+    << "Usage: resolver [-t] [-s] [hostname | IP | service/protocol/domain ] ...\n"
+    << "       resolver [-t] [-s] -c [hostname | IP | service/protocol/domain ]\n"
+    << "       Use -s to do synchronous lookups.\n"
+    << "       Use -c (and only a single resolvable argument) to test GSocketConnectable.\n";
+  exit(1);
 }
 
 static std::mutex response_mutex;
 
 static bool
-idle_quit ()
+idle_quit()
 {
-    loop->quit ();
-    return false;
+  loop->quit();
+  return false;
 }
 
 static void
-done_lookup (void)
+done_lookup(void)
 {
   nlookups--;
   if (nlookups == 0)
-    {
-      /* In the sync case we need to make sure we don't call
-       * g_main_loop_quit before the loop is actually running...
-       */
-        Glib::signal_idle ().connect (sigc::ptr_fun (idle_quit));
-    }
+  {
+    /* In the sync case we need to make sure we don't call
+     * g_main_loop_quit before the loop is actually running...
+     */
+    Glib::signal_idle().connect(sigc::ptr_fun(idle_quit));
+  }
 }
 
 static void
-print_resolved_name (const Glib::ustring& phys,
-                     const Glib::ustring& name)
+print_resolved_name(const Glib::ustring& phys, const Glib::ustring& name)
 {
-  std::lock_guard<std::mutex> lock_guard (response_mutex);
-  std::cout
-      << Glib::ustring::compose ("Address: %1\n", phys)
-      << Glib::ustring::compose ("Name:    %1\n", name)
-      << std::endl;
+  std::lock_guard<std::mutex> lock_guard(response_mutex);
+  std::cout << Glib::ustring::compose("Address: %1\n", phys)
+            << Glib::ustring::compose("Name:    %1\n", name) << std::endl;
 
-  done_lookup ();
+  done_lookup();
 }
 
 static void
-print_resolved_addresses (const Glib::ustring& name,
-                          const std::list<Glib::RefPtr<Gio::InetAddress>>& addresses)
+print_resolved_addresses(
+  const Glib::ustring& name, const std::list<Glib::RefPtr<Gio::InetAddress>>& addresses)
 {
-    std::lock_guard<std::mutex> lock_guard (response_mutex);
-    std::cout << Glib::ustring::compose ("Name:    %1\n", name);
-    for (const auto& i : addresses)
-    {
-        std::cout << Glib::ustring::compose ("Address: %1\n", i->to_string ());
-    }
-    std::cout << std::endl;
+  std::lock_guard<std::mutex> lock_guard(response_mutex);
+  std::cout << Glib::ustring::compose("Name:    %1\n", name);
+  for (const auto& i : addresses)
+  {
+    std::cout << Glib::ustring::compose("Address: %1\n", i->to_string());
+  }
+  std::cout << std::endl;
 
-    done_lookup ();
+  done_lookup();
 }
 
 static void
-print_resolved_service (const Glib::ustring& service,
-                        const std::list<Gio::SrvTarget>& targets)
+print_resolved_service(const Glib::ustring& service, const std::list<Gio::SrvTarget>& targets)
 {
-    std::lock_guard<std::mutex> lock_guard (response_mutex);
-    std::cout << Glib::ustring::compose ("Service: %1\n", service);
-    for (const auto& i : targets)
-    {
-        std::cout <<
-            Glib::ustring::compose ("%1:%2 (pri %3, weight %4)\n",
-                                    i.get_hostname (),
-                                    i.get_port (),
-                                    i.get_priority (),
-                                    i.get_weight ());
-    }
-    std::cout << std::endl;
+  std::lock_guard<std::mutex> lock_guard(response_mutex);
+  std::cout << Glib::ustring::compose("Service: %1\n", service);
+  for (const auto& i : targets)
+  {
+    std::cout << Glib::ustring::compose("%1:%2 (pri %3, weight %4)\n", i.get_hostname(),
+      i.get_port(), i.get_priority(), i.get_weight());
+  }
+  std::cout << std::endl;
 
-    done_lookup ();
+  done_lookup();
 }
 
 static std::vector<Glib::ustring>
-split_service_parts (const Glib::ustring& arg)
+split_service_parts(const Glib::ustring& arg)
 {
-    std::vector<Glib::ustring> parts;
-    std::size_t delim1 = 0;
-    std::size_t delim2 = 0;
-    delim1 = arg.find ('/', 0);
-    if (delim1 == std::string::npos)
-        return parts;
-    delim2 = arg.find ('/', delim1 + 1);
-    if (delim2 == std::string::npos)
-        return parts;
-    parts.emplace_back (arg.substr (0, delim1));
-    parts.emplace_back (arg.substr (delim1 + 1, delim2 - delim1 - 1));
-    parts.emplace_back (arg.substr (delim2 + 1));
-
+  std::vector<Glib::ustring> parts;
+  std::size_t delim1 = 0;
+  std::size_t delim2 = 0;
+  delim1 = arg.find('/', 0);
+  if (delim1 == std::string::npos)
     return parts;
+  delim2 = arg.find('/', delim1 + 1);
+  if (delim2 == std::string::npos)
+    return parts;
+  parts.emplace_back(arg.substr(0, delim1));
+  parts.emplace_back(arg.substr(delim1 + 1, delim2 - delim1 - 1));
+  parts.emplace_back(arg.substr(delim2 + 1));
+
+  return parts;
 }
 
 static void
-lookup_one_sync (const Glib::ustring& arg)
+lookup_one_sync(const Glib::ustring& arg)
 {
-    if (arg.find ('/') != std::string::npos)
+  if (arg.find('/') != std::string::npos)
+  {
+    /* service/protocol/domain */
+    const auto parts = split_service_parts(arg);
+    if (parts.size() != 3)
     {
-        /* service/protocol/domain */
-        const auto parts = split_service_parts (arg);
-        if (parts.size () != 3) {
-            usage ();
-            return;
-        }
-
-        try
-        {
-            const auto targets = resolver->lookup_service (parts[0], parts[1], parts[2],
-                                                cancellable);
-            print_resolved_service (arg, targets);
-        }
-        catch (const Gio::ResolverError& err)
-        {
-            std::cerr << err.what () << std::endl;
-        }
+      usage();
+      return;
     }
-    else if (Gio::hostname_is_ip_address (arg))
+
+    try
     {
-        auto addr = Gio::InetAddress::create (arg);
-        try
-        {
-            Glib::ustring name = resolver->lookup_by_address (addr, cancellable);
-            print_resolved_name (arg, name);
-        }
-        catch (const Gio::ResolverError& err)
-        {
-            std::cerr << err.what () << std::endl;
-        }
+      const auto targets = resolver->lookup_service(parts[0], parts[1], parts[2], cancellable);
+      print_resolved_service(arg, targets);
     }
-    else
+    catch (const Gio::ResolverError& err)
+    {
+      std::cerr << err.what() << std::endl;
+    }
+  }
+  else if (Gio::hostname_is_ip_address(arg))
+  {
+    auto addr = Gio::InetAddress::create(arg);
+    try
     {
-        std::list<Glib::RefPtr<Gio::InetAddress> > addresses;
-
-        try
-        {
-            addresses = resolver->lookup_by_name (arg, cancellable);
-            print_resolved_addresses (arg, addresses);
-        }
-        catch (const Gio::ResolverError& err)
-        {
-            std::cerr << err.what () << std::endl;
-        }
+      Glib::ustring name = resolver->lookup_by_address(addr, cancellable);
+      print_resolved_name(arg, name);
     }
+    catch (const Gio::ResolverError& err)
+    {
+      std::cerr << err.what() << std::endl;
+    }
+  }
+  else
+  {
+    std::list<Glib::RefPtr<Gio::InetAddress>> addresses;
+
+    try
+    {
+      addresses = resolver->lookup_by_name(arg, cancellable);
+      print_resolved_addresses(arg, addresses);
+    }
+    catch (const Gio::ResolverError& err)
+    {
+      std::cerr << err.what() << std::endl;
+    }
+  }
 }
 
 static void
-lookup_thread (const Glib::ustring& arg)
+lookup_thread(const Glib::ustring& arg)
 {
-  lookup_one_sync (arg);
+  lookup_one_sync(arg);
 }
 
 static std::vector<std::thread*>
-start_threaded_lookups (char **argv, int argc)
+start_threaded_lookups(char** argv, int argc)
 {
   std::vector<std::thread*> result;
   for (auto i = 0; i < argc; i++)
@@ -217,313 +209,294 @@ start_threaded_lookups (char **argv, int argc)
 }
 
 static void
-lookup_by_addr_callback (Glib::RefPtr<Gio::AsyncResult> result,
-                         const Glib::ustring& phys)
+lookup_by_addr_callback(Glib::RefPtr<Gio::AsyncResult> result, const Glib::ustring& phys)
 {
-    try
-    {
-        print_resolved_name (phys, resolver->lookup_by_address_finish (result));
-    }
-    catch (const Gio::ResolverError& err)
-    {
-        std::cerr << err.what () << std::endl;
-        done_lookup ();
-    }
+  try
+  {
+    print_resolved_name(phys, resolver->lookup_by_address_finish(result));
+  }
+  catch (const Gio::ResolverError& err)
+  {
+    std::cerr << err.what() << std::endl;
+    done_lookup();
+  }
 }
 
 static void
-lookup_by_name_callback (Glib::RefPtr<Gio::AsyncResult> result,
-                         const Glib::ustring& name)
+lookup_by_name_callback(Glib::RefPtr<Gio::AsyncResult> result, const Glib::ustring& name)
 {
-    try
-    {
-        print_resolved_addresses (name, resolver->lookup_by_name_finish (result));
-    }
-    catch (const Gio::ResolverError& err)
-    {
-        std::cerr << err.what () << std::endl;
-    }
+  try
+  {
+    print_resolved_addresses(name, resolver->lookup_by_name_finish(result));
+  }
+  catch (const Gio::ResolverError& err)
+  {
+    std::cerr << err.what() << std::endl;
+  }
 }
 
 static void
-lookup_service_callback (Glib::RefPtr<Gio::AsyncResult> result,
-                         const Glib::ustring& service)
+lookup_service_callback(Glib::RefPtr<Gio::AsyncResult> result, const Glib::ustring& service)
 {
   try
   {
-      print_resolved_service (service,
-                              resolver->lookup_service_finish (result));
+    print_resolved_service(service, resolver->lookup_service_finish(result));
   }
   catch (const Gio::ResolverError& err)
   {
-      std::cerr << err.what () << std::endl;
+    std::cerr << err.what() << std::endl;
   }
 }
 
 static void
-start_async_lookups (char **argv, int argc)
+start_async_lookups(char** argv, int argc)
 {
-    for (auto i = 0; i < argc; i++)
+  for (auto i = 0; i < argc; i++)
+  {
+    Glib::ustring arg(argv[i]);
+    if (arg.find('/') != std::string::npos)
     {
-        Glib::ustring arg (argv[i]);
-        if (arg.find ('/') != std::string::npos)
-        {
-            /* service/protocol/domain */
-            auto parts = split_service_parts (arg);
-            if (parts.size () != 3) {
-                usage ();
-                return;
-            }
-
-            resolver->lookup_service_async (parts[0], parts[1], parts[2],
-                                            sigc::bind (sigc::ptr_fun
-                                                        (lookup_service_callback),
-                                                        Glib::ustring (argv[i])),
-                                            cancellable
-                                            );
-        }
-        else if (Gio::hostname_is_ip_address (argv[i]))
-        {
-            auto addr = Gio::InetAddress::create (argv[i]);
-
-            resolver->lookup_by_address_async (addr,
-                                               sigc::bind (sigc::ptr_fun
-                                                           (lookup_by_addr_callback),
-                                                           argv[i]),
-                                               cancellable);
-        }
-        else
-        {
-            resolver->lookup_by_name_async (argv[i],
-                                            sigc::bind (sigc::ptr_fun
-                                                        (lookup_by_name_callback),
-                                                        argv[i]),
-                                            cancellable);
-        }
-
-        /* Stress-test the reloading code */
-        //g_signal_emit_by_name (resolver, "reload");
-    }
-}
-
-static void
-print_connectable_sockaddr (Glib::RefPtr<Gio::SocketAddress> sockaddr)
-{
-    Glib::ustring phys;
-    auto isa =
-        Glib::RefPtr<Gio::InetSocketAddress>::cast_dynamic (sockaddr);
+      /* service/protocol/domain */
+      auto parts = split_service_parts(arg);
+      if (parts.size() != 3)
+      {
+        usage();
+        return;
+      }
 
-    if (!isa)
+      resolver->lookup_service_async(parts[0], parts[1], parts[2],
+        sigc::bind(sigc::ptr_fun(lookup_service_callback), Glib::ustring(argv[i])), cancellable);
+    }
+    else if (Gio::hostname_is_ip_address(argv[i]))
     {
-        std::cerr <<
-            Glib::ustring::compose ("Error: Unexpected sockaddr type '%1'\n",
-                                    g_type_name_from_instance ((GTypeInstance *)sockaddr->gobj ()));
+      auto addr = Gio::InetAddress::create(argv[i]);
+
+      resolver->lookup_by_address_async(
+        addr, sigc::bind(sigc::ptr_fun(lookup_by_addr_callback), argv[i]), cancellable);
     }
     else
     {
-        phys = isa->get_address ()->to_string ();
-        std::cout << Glib::ustring::compose ("Address: %1%2%3:%4\n",
-                phys.find (':') != std::string::npos ? "[" : "",
-                phys,
-                phys.find (':') != std::string::npos ? "]" : "",
-                isa->get_port ());
+      resolver->lookup_by_name_async(
+        argv[i], sigc::bind(sigc::ptr_fun(lookup_by_name_callback), argv[i]), cancellable);
     }
+
+    /* Stress-test the reloading code */
+    // g_signal_emit_by_name (resolver, "reload");
+  }
+}
+
+static void
+print_connectable_sockaddr(Glib::RefPtr<Gio::SocketAddress> sockaddr)
+{
+  Glib::ustring phys;
+  auto isa = Glib::RefPtr<Gio::InetSocketAddress>::cast_dynamic(sockaddr);
+
+  if (!isa)
+  {
+    std::cerr << Glib::ustring::compose("Error: Unexpected sockaddr type '%1'\n",
+      g_type_name_from_instance((GTypeInstance*)sockaddr->gobj()));
+  }
+  else
+  {
+    phys = isa->get_address()->to_string();
+    std::cout << Glib::ustring::compose("Address: %1%2%3:%4\n",
+      phys.find(':') != std::string::npos ? "[" : "", phys,
+      phys.find(':') != std::string::npos ? "]" : "", isa->get_port());
+  }
 }
 
 static void
-do_sync_connectable (Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator)
+do_sync_connectable(Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator)
 {
-    Glib::RefPtr<Gio::SocketAddress> sockaddr;
+  Glib::RefPtr<Gio::SocketAddress> sockaddr;
 
-    while ((sockaddr = enumerator->next (cancellable)))
-        print_connectable_sockaddr (sockaddr);
+  while ((sockaddr = enumerator->next(cancellable)))
+    print_connectable_sockaddr(sockaddr);
 
-    done_lookup ();
+  done_lookup();
 }
 
-static void do_async_connectable (Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator);
+static void do_async_connectable(Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator);
 
 static void
-got_next_async (Glib::RefPtr<Gio::AsyncResult> result,
-                Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator)
+got_next_async(
+  Glib::RefPtr<Gio::AsyncResult> result, Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator)
 {
-    try
+  try
+  {
+    const auto sockaddr = enumerator->next_finish(result);
+    if (sockaddr)
     {
-        const auto sockaddr = enumerator->next_finish (result);
-        if (sockaddr)
-        {
-            print_connectable_sockaddr (sockaddr);
-            do_async_connectable (enumerator);
-        }
-        else
-        {
-            done_lookup ();
-        }
+      print_connectable_sockaddr(sockaddr);
+      do_async_connectable(enumerator);
     }
-    catch (const Gio::ResolverError& err)
+    else
     {
-        std::cerr << err.what () << std::endl;
+      done_lookup();
     }
+  }
+  catch (const Gio::ResolverError& err)
+  {
+    std::cerr << err.what() << std::endl;
+  }
 }
 
 Glib::RefPtr<Gio::SocketAddressEnumerator> global_enumerator;
 static void
-do_async_connectable (Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator)
+do_async_connectable(Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator)
 {
-    enumerator->next_async (cancellable,
-                            sigc::bind (sigc::ptr_fun (got_next_async),
-                                        enumerator));
+  enumerator->next_async(cancellable, sigc::bind(sigc::ptr_fun(got_next_async), enumerator));
 }
 
 Glib::RefPtr<Gio::SocketConnectable> global_connectable;
 
 static void
-do_connectable (const std::string& arg, gboolean synchronous)
+do_connectable(const std::string& arg, gboolean synchronous)
 {
-    std::vector<Glib::ustring> parts;
-    Glib::RefPtr<Gio::SocketConnectable> connectable;
+  std::vector<Glib::ustring> parts;
+  Glib::RefPtr<Gio::SocketConnectable> connectable;
 
-    if (arg.find ('/') != std::string::npos)
+  if (arg.find('/') != std::string::npos)
+  {
+    /* service/protocol/domain */
+    parts = split_service_parts(arg);
+    if (parts.size() != 3)
     {
-        /* service/protocol/domain */
-        parts = split_service_parts (arg);
-        if (parts.size () != 3) {
-            usage ();
-            return;
-        }
-
-        connectable = Gio::NetworkService::create (parts[0], parts[1], parts[2]);
+      usage();
+      return;
     }
-    else
+
+    connectable = Gio::NetworkService::create(parts[0], parts[1], parts[2]);
+  }
+  else
+  {
+    std::string host, port_str;
+    guint16 port;
+
+    const auto pos = arg.find(':');
+    if (pos != std::string::npos)
     {
-        std::string host, port_str;
-        guint16 port;
-
-        const auto pos = arg.find (':');
-        if (pos != std::string::npos)
-        {
-            host = arg.substr (0, pos);
-            port_str = arg.substr(pos);
-            port = std::stoul (port_str);
-        }
-        else
-            port = 0;
-
-        if (Gio::hostname_is_ip_address (host))
-        {
-            const auto addr = Gio::InetAddress::create (host);
-            connectable = Gio::InetSocketAddress::create (addr, port);
-        }
-        else
-            connectable = Gio::NetworkAddress::create (arg, port);
+      host = arg.substr(0, pos);
+      port_str = arg.substr(pos);
+      port = std::stoul(port_str);
     }
+    else
+      port = 0;
 
-    const auto enumerator = connectable->enumerate ();
-    if (synchronous)
-        do_sync_connectable (enumerator);
+    if (Gio::hostname_is_ip_address(host))
+    {
+      const auto addr = Gio::InetAddress::create(host);
+      connectable = Gio::InetSocketAddress::create(addr, port);
+    }
     else
-        do_async_connectable (enumerator);
+      connectable = Gio::NetworkAddress::create(arg, port);
+  }
+
+  const auto enumerator = connectable->enumerate();
+  if (synchronous)
+    do_sync_connectable(enumerator);
+  else
+    do_async_connectable(enumerator);
 }
 
 #ifdef G_OS_UNIX
 static volatile int cancel_fd;
 
 static void
-interrupted (int /*sig*/)
+interrupted(int /*sig*/)
 {
   const int save_errno = errno;
   while (write(cancel_fd, "", 1) < 0 && errno == EINTR)
-  {}
+  {
+  }
   errno = save_errno;
 }
 
 static bool
-async_cancel (Glib::IOCondition /*cond*/, Glib::RefPtr<Gio::Cancellable> the_cancellable)
+async_cancel(Glib::IOCondition /*cond*/, Glib::RefPtr<Gio::Cancellable> the_cancellable)
 {
-    the_cancellable->cancel ();
-    return false;
+  the_cancellable->cancel();
+  return false;
 }
 #endif
 
 int
-main (int argc, char **argv)
+main(int argc, char** argv)
 {
-    auto synchronous = false;
-    auto use_connectable = false;
+  auto synchronous = false;
+  auto use_connectable = false;
 #ifdef G_OS_UNIX
-    Glib::RefPtr<Glib::IOChannel> chan;
-    sigc::connection watch_conn;
+  Glib::RefPtr<Glib::IOChannel> chan;
+  sigc::connection watch_conn;
 #endif
 
-    // TODO: Use Glib::OptionContext.
-    while (argc >= 2 && argv[1][0] == '-')
-    {
-        if (!strcmp (argv[1], "-s"))
-            synchronous = true;
-        else if (!strcmp (argv[1], "-c"))
-            use_connectable = true;
-        else
-            usage ();
-
-        argv++;
-        argc--;
-    }
+  // TODO: Use Glib::OptionContext.
+  while (argc >= 2 && argv[1][0] == '-')
+  {
+    if (!strcmp(argv[1], "-s"))
+      synchronous = true;
+    else if (!strcmp(argv[1], "-c"))
+      use_connectable = true;
+    else
+      usage();
+
+    argv++;
+    argc--;
+  }
 
-    Gio::init ();
+  Gio::init();
 
-    if (argc < 2 || (argc > 2 && use_connectable))
-        usage ();
+  if (argc < 2 || (argc > 2 && use_connectable))
+    usage();
 
-    resolver = Gio::Resolver::get_default ();
+  resolver = Gio::Resolver::get_default();
 
-    cancellable = Gio::Cancellable::create ();
+  cancellable = Gio::Cancellable::create();
 
 #ifdef G_OS_UNIX
-    /* Set up cancellation; we want to cancel if the user ^C's the
-     * program, but we can't cancel directly from an interrupt.
-     */
-    int cancel_fds[2];
+  /* Set up cancellation; we want to cancel if the user ^C's the
+   * program, but we can't cancel directly from an interrupt.
+   */
+  int cancel_fds[2];
 
-    if (pipe (cancel_fds) < 0)
-    {
-        perror ("pipe");
-        exit (1);
-    }
-    cancel_fd = cancel_fds[1];
-    signal (SIGINT, interrupted);
+  if (pipe(cancel_fds) < 0)
+  {
+    perror("pipe");
+    exit(1);
+  }
+  cancel_fd = cancel_fds[1];
+  signal(SIGINT, interrupted);
 
-    chan = Glib::IOChannel::create_from_fd (cancel_fds[0]);
-    const auto source = chan->create_watch (Glib::IO_IN);
-    watch_conn = source->connect (sigc::bind (sigc::ptr_fun (async_cancel), cancellable));
+  chan = Glib::IOChannel::create_from_fd(cancel_fds[0]);
+  const auto source = chan->create_watch(Glib::IO_IN);
+  watch_conn = source->connect(sigc::bind(sigc::ptr_fun(async_cancel), cancellable));
 #endif
 
-    nlookups = argc - 1;
-    loop = Glib::MainLoop::create (true);
+  nlookups = argc - 1;
+  loop = Glib::MainLoop::create(true);
 
-    std::vector<std::thread*> threads;
-    if (use_connectable)
-        do_connectable (argv[1], synchronous);
+  std::vector<std::thread*> threads;
+  if (use_connectable)
+    do_connectable(argv[1], synchronous);
+  else
+  {
+    if (synchronous)
+      threads = start_threaded_lookups(argv + 1, argc - 1);
     else
-    {
-        if (synchronous)
-            threads = start_threaded_lookups (argv + 1, argc - 1);
-        else
-            start_async_lookups (argv + 1, argc - 1);
-    }
+      start_async_lookups(argv + 1, argc - 1);
+  }
 
-    loop->run ();
+  loop->run();
 
-    //Join and delete each thread:
-    std::for_each(threads.begin(), threads.end(),
-      [] (std::thread* thread)
-      {
-        thread->join();
-        delete thread;
-      });
+  // Join and delete each thread:
+  std::for_each(threads.begin(), threads.end(), [](std::thread* thread) {
+    thread->join();
+    delete thread;
+  });
 
 #ifdef G_OS_UNIX
-    watch_conn.disconnect ();
+  watch_conn.disconnect();
 #endif
 
-    return 0;
+  return 0;
 }
diff --git a/examples/network/socket-client.cc b/examples/network/socket-client.cc
index 3fdb30d5..c364d9b2 100644
--- a/examples/network/socket-client.cc
+++ b/examples/network/socket-client.cc
@@ -1,12 +1,12 @@
+#include <chrono>
+#include <condition_variable>
 #include <cstring>
 #include <giomm.h>
 #include <glibmm.h>
-#include <thread>
-#include <mutex>
-#include <condition_variable>
-#include <chrono>
-#include <memory>
 #include <iostream>
+#include <memory>
+#include <mutex>
+#include <thread>
 
 namespace
 {
@@ -26,8 +26,7 @@ std::condition_variable cond_thread;
 class ClientOptionGroup : public Glib::OptionGroup
 {
 public:
-  ClientOptionGroup()
-  : Glib::OptionGroup("client_group", "", "")
+  ClientOptionGroup() : Glib::OptionGroup("client_group", "", "")
   {
     Glib::OptionEntry entry;
     entry.set_long_name("cancel");
@@ -60,68 +59,65 @@ public:
     entry.set_description("Use IPv6 address family");
     add_entry(entry, use_ipv6);
   }
-};  
+};
 
 Glib::ustring
-socket_address_to_string (const Glib::RefPtr<Gio::SocketAddress>& address)
+socket_address_to_string(const Glib::RefPtr<Gio::SocketAddress>& address)
 {
-    Glib::RefPtr<Gio::InetAddress> inet_address;
-    Glib::ustring str, res;
-    int port;
-
-    auto isockaddr =
-        Glib::RefPtr<Gio::InetSocketAddress>::cast_dynamic (address);
-    if (!isockaddr)
-        return Glib::ustring ();
-    inet_address = isockaddr->get_address ();
-    str = inet_address->to_string ();
-    port = isockaddr->get_port ();
-    res = Glib::ustring::compose ("%1:%2", str, port);
-    return res;
+  Glib::RefPtr<Gio::InetAddress> inet_address;
+  Glib::ustring str, res;
+  int port;
+
+  auto isockaddr = Glib::RefPtr<Gio::InetSocketAddress>::cast_dynamic(address);
+  if (!isockaddr)
+    return Glib::ustring();
+  inet_address = isockaddr->get_address();
+  str = inet_address->to_string();
+  port = isockaddr->get_port();
+  res = Glib::ustring::compose("%1:%2", str, port);
+  return res;
 }
 
-static bool
-source_ready(Glib::IOCondition /*condition*/)
+static bool source_ready(Glib::IOCondition /*condition*/)
 {
-  loop->quit ();
+  loop->quit();
   return false;
 }
 
 static void
-ensure_condition (const Glib::RefPtr<Gio::Socket>& socket,
-                  const Glib::ustring& where,
-                  const Glib::RefPtr<Gio::Cancellable>& cancellable,
-                  Glib::IOCondition condition)
+ensure_condition(const Glib::RefPtr<Gio::Socket>& socket, const Glib::ustring& where,
+  const Glib::RefPtr<Gio::Cancellable>& cancellable, Glib::IOCondition condition)
 {
-    if (!non_blocking)
-        return;
+  if (!non_blocking)
+    return;
 
-    if (use_source)
+  if (use_source)
+  {
+    auto source = socket->create_source(condition, cancellable);
+    source->connect(sigc::ptr_fun(&source_ready));
+    source->attach();
+    loop->run();
+  }
+  else
+  {
+    try
     {
-      auto source = socket->create_source(condition, cancellable);
-      source->connect(sigc::ptr_fun(&source_ready));
-      source->attach();
-      loop->run();
+      socket->condition_wait(condition, cancellable);
     }
-    else
+    catch (const Gio::Error& error)
     {
-        try {
-            socket->condition_wait (condition, cancellable);
-        } catch (const Gio::Error& error)
-        {
-            std::cerr << Glib::ustring::compose("condition wait error for %1: %2\n",
-                        where, error.what ());
-            exit (1);
-        }
+      std::cerr << Glib::ustring::compose("condition wait error for %1: %2\n", where, error.what());
+      exit(1);
     }
+  }
 }
 
 static void
-cancel_thread (Glib::RefPtr<Gio::Cancellable> cancellable)
+cancel_thread(Glib::RefPtr<Gio::Cancellable> cancellable)
 {
   std::unique_lock<std::mutex> lock(mutex_thread);
-  if (!cond_thread.wait_for(lock, std::chrono::seconds(cancel_timeout),
-      [](){ return stop_thread; }))
+  if (!cond_thread.wait_for(
+        lock, std::chrono::seconds(cancel_timeout), []() { return stop_thread; }))
   {
     // !stop_thread, i.e. timeout
     std::cout << "Cancelling\n";
@@ -144,207 +140,211 @@ public:
 } // end anonymous namespace
 
 int
-main (int argc,
-      char *argv[])
+main(int argc, char* argv[])
 {
-    Glib::RefPtr<Gio::Socket> socket;
-    Glib::RefPtr<Gio::SocketAddress> src_address;
-    Glib::RefPtr<Gio::SocketAddress> address;
-    Gio::SocketType socket_type;
-    Gio::SocketFamily socket_family;
-    Glib::RefPtr<Gio::Cancellable> cancellable;
-    Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator;
-    Glib::RefPtr<Gio::SocketConnectable> connectable;
-
-    Gio::init ();
-
-    Glib::OptionContext option_context(" <hostname>[:port] - Test Gio::Socket client stuff");
-    option_context.set_summary("Default port: 7777\n"
-    "For a local test with socket-server:\n"
-    "  ./socket-client [option...] localhost\n"
-    "or, if that fails\n"
-    "  ./socket-client [option...] 127.0.0.1  (IPv4)\n"
-    "  ./socket-client [option...] ::1        (IPv6)");
-    ClientOptionGroup option_group;
-    option_context.set_main_group(option_group);
+  Glib::RefPtr<Gio::Socket> socket;
+  Glib::RefPtr<Gio::SocketAddress> src_address;
+  Glib::RefPtr<Gio::SocketAddress> address;
+  Gio::SocketType socket_type;
+  Gio::SocketFamily socket_family;
+  Glib::RefPtr<Gio::Cancellable> cancellable;
+  Glib::RefPtr<Gio::SocketAddressEnumerator> enumerator;
+  Glib::RefPtr<Gio::SocketConnectable> connectable;
+
+  Gio::init();
+
+  Glib::OptionContext option_context(" <hostname>[:port] - Test Gio::Socket client stuff");
+  option_context.set_summary("Default port: 7777\n"
+                             "For a local test with socket-server:\n"
+                             "  ./socket-client [option...] localhost\n"
+                             "or, if that fails\n"
+                             "  ./socket-client [option...] 127.0.0.1  (IPv4)\n"
+                             "  ./socket-client [option...] ::1        (IPv6)");
+  ClientOptionGroup option_group;
+  option_context.set_main_group(option_group);
+  try
+  {
+    option_context.parse(argc, argv);
+  }
+  catch (const Glib::Error& error)
+  {
+    std::cerr << Glib::ustring::compose("%1: %2\n", argv[0], error.what());
+    return 1;
+  }
+
+  if (argc != 2)
+  {
+    const auto error_message = "Need to specify hostname";
+    std::cerr << Glib::ustring::compose("%1: %2\n", argv[0], error_message);
+    return 1;
+  }
+
+  std::unique_ptr<std::thread, JoinAndDelete> thread;
+  if (cancel_timeout)
+  {
+    cancellable = Gio::Cancellable::create();
+    thread.reset(new std::thread(&cancel_thread, cancellable));
+  }
+
+  loop = Glib::MainLoop::create();
+
+  socket_type = use_udp ? Gio::SOCKET_TYPE_DATAGRAM : Gio::SOCKET_TYPE_STREAM;
+  socket_family = use_ipv6 ? Gio::SOCKET_FAMILY_IPV6 : Gio::SOCKET_FAMILY_IPV4;
+
+  try
+  {
+    socket = Gio::Socket::create(socket_family, socket_type, Gio::SOCKET_PROTOCOL_DEFAULT);
+  }
+  catch (const Gio::Error& error)
+  {
+    std::cerr << Glib::ustring::compose("%1: %2\n", argv[0], error.what());
+    return 1;
+  }
+
+  try
+  {
+    connectable = Gio::NetworkAddress::parse(argv[1], 7777);
+  }
+  catch (const Gio::Error& error)
+  {
+    std::cerr << Glib::ustring::compose("%1: %2\n", argv[0], error.what());
+    return 1;
+  }
+
+  enumerator = connectable->enumerate();
+  while (true)
+  {
     try
     {
-      option_context.parse(argc, argv);
+      address = enumerator->next(cancellable);
+      if (!address)
+      {
+        std::cerr << Glib::ustring::compose("%1: No more addresses to try\n", argv[0]);
+        return 1;
+      }
     }
-    catch (const Glib::Error& error)
+    catch (const Gio::Error& error)
     {
-      std::cerr << Glib::ustring::compose ("%1: %2\n", argv[0], error.what());
+      std::cerr << Glib::ustring::compose("%1: %2\n", argv[0], error.what());
       return 1;
     }
 
-    if (argc != 2)
+    try
     {
-        const auto error_message = "Need to specify hostname";
-        std::cerr << Glib::ustring::compose ("%1: %2\n", argv[0], error_message);
-        return 1;
+      socket->connect(address, cancellable);
+      break;
     }
-
-    std::unique_ptr<std::thread, JoinAndDelete> thread;
-    if (cancel_timeout)
+    catch (const Gio::Error& error)
     {
-        cancellable = Gio::Cancellable::create ();
-        thread.reset(new std::thread(&cancel_thread, cancellable));
+      std::cerr << Glib::ustring::compose("%1: Connection to %2 failed: %3, trying next\n", argv[0],
+        socket_address_to_string(address), error.what());
     }
+  }
 
-    loop = Glib::MainLoop::create ();
+  std::cout << Glib::ustring::compose("Connected to %1\n", socket_address_to_string(address));
 
-    socket_type = use_udp ? Gio::SOCKET_TYPE_DATAGRAM : Gio::SOCKET_TYPE_STREAM;
-    socket_family = use_ipv6 ? Gio::SOCKET_FAMILY_IPV6 : Gio::SOCKET_FAMILY_IPV4;
+  /* TODO: Test non-blocking connect */
+  if (non_blocking)
+    socket->set_blocking(false);
 
-    try {
-        socket = Gio::Socket::create (socket_family, socket_type, Gio::SOCKET_PROTOCOL_DEFAULT);
-    } catch (const Gio::Error& error)
-    {
-        std::cerr << Glib::ustring::compose ("%1: %2\n", argv[0], error.what ());
-        return 1;
-    }
+  try
+  {
+    src_address = socket->get_local_address();
+  }
+  catch (const Gio::Error& error)
+  {
+    std::cerr << Glib::ustring::compose("Error getting local address: %1\n", error.what());
+    return 1;
+  }
+  std::cout << Glib::ustring::compose("local address: %1\n", socket_address_to_string(src_address));
 
-    try {
-        connectable = Gio::NetworkAddress::parse (argv[1], 7777);
-    } catch (const Gio::Error& error)
-    {
-        std::cerr << Glib::ustring::compose ("%1: %2\n", argv[0], error.what ());
-        return 1;
-    }
+  while (true)
+  {
+    gchar buffer[4096] = {};
+    gssize size;
+    gsize to_send;
+
+    if (!std::cin.getline(buffer, sizeof buffer - 1))
+      break;
 
-    enumerator = connectable->enumerate ();
-    while (true)
+    to_send = strlen(buffer);
+    buffer[to_send++] = '\n';
+    buffer[to_send] = '\0';
+    while (to_send > 0)
     {
-        try {
-            address = enumerator->next (cancellable);
-            if (!address) {
-                std::cerr << Glib::ustring::compose ("%1: No more addresses to try\n", argv[0]);
-                return 1;
-            }
-        } catch (const Gio::Error& error)
+      ensure_condition(socket, "send", cancellable, Glib::IO_OUT);
+      try
+      {
+        if (use_udp)
+          size = socket->send_to(address, buffer, to_send, cancellable);
+        else
+          size = socket->send(buffer, to_send, cancellable);
+      }
+      catch (const Gio::Error& error)
+      {
+        if (error.code() == Gio::Error::WOULD_BLOCK)
         {
-            std::cerr << Glib::ustring::compose ("%1: %2\n", argv[0], error.what ());
-            return 1;
+          std::cout << "socket send would block, handling\n";
+          continue;
         }
-
-        try {
-            socket->connect (address, cancellable);
-            break;
-        } catch (const Gio::Error& error)
+        else
         {
-            std::cerr << Glib::ustring::compose ("%1: Connection to %2 failed: %3, trying next\n",
-                                                 argv[0], socket_address_to_string (address),
-                                                 error.what ());
+          std::cerr << Glib::ustring::compose("Error sending to socket: %1\n", error.what());
+          return 1;
         }
-    }
+      }
 
-    std::cout << Glib::ustring::compose ("Connected to %1\n",
-                                         socket_address_to_string (address));
+      std::cout << Glib::ustring::compose("sent %1 bytes of data\n", size);
 
-    /* TODO: Test non-blocking connect */
-    if (non_blocking)
-        socket->set_blocking (false);
-
-    try {
-        src_address = socket->get_local_address ();
-    } catch (const Gio::Error& error)
-    {
-        std::cerr << Glib::ustring::compose ("Error getting local address: %1\n",
-                    error.what ());
+      if (size == 0)
+      {
+        std::cerr << "Unexpected short write\n";
         return 1;
+      }
+
+      to_send -= size;
     }
-    std::cout << Glib::ustring::compose ("local address: %1\n",
-                                         socket_address_to_string (src_address));
 
-    while (true)
+    ensure_condition(socket, "receive", cancellable, Glib::IO_IN);
+    try
     {
-        gchar buffer[4096] = { };
-        gssize size;
-        gsize to_send;
-
-        if (!std::cin.getline (buffer, sizeof buffer - 1))
-            break;
-
-        to_send = strlen (buffer);
-        buffer[to_send++] = '\n';
-        buffer[to_send] = '\0';
-        while (to_send > 0)
-        {
-            ensure_condition (socket, "send", cancellable, Glib::IO_OUT);
-            try {
-                if (use_udp)
-                    size = socket->send_to (address, buffer, to_send,
-                                            cancellable);
-                else
-                    size = socket->send (buffer, to_send, cancellable);
-
-            } catch (const Gio::Error& error)
-            {
-                if (error.code () == Gio::Error::WOULD_BLOCK)
-                {
-                    std::cout << "socket send would block, handling\n";
-                    continue;
-                }
-                else
-                {
-                    std::cerr << Glib::ustring::compose ("Error sending to socket: %1\n",
-                                                         error.what ());
-                    return 1;
-                }
-            }
-
-            std::cout << Glib::ustring::compose ("sent %1 bytes of data\n", size);
-
-            if (size == 0)
-            {
-                std::cerr << "Unexpected short write\n";
-                return 1;
-            }
-
-            to_send -= size;
-        }
-
-        ensure_condition (socket, "receive", cancellable, Glib::IO_IN);
-        try {
-            if (use_udp)
-                size = socket->receive_from (src_address, buffer, sizeof buffer,
-                                             cancellable);
-            else
-                size = socket->receive (buffer, sizeof buffer, cancellable);
-
-        } catch (const Gio::Error& error)
-        {
-            std::cerr << Glib::ustring::compose ("Error receiving from socket: %1\n",
-                                                 error.what ());
-            return 1;
-        }
-
-        if (size == 0)
-            break;
+      if (use_udp)
+        size = socket->receive_from(src_address, buffer, sizeof buffer, cancellable);
+      else
+        size = socket->receive(buffer, sizeof buffer, cancellable);
+    }
+    catch (const Gio::Error& error)
+    {
+      std::cerr << Glib::ustring::compose("Error receiving from socket: %1\n", error.what());
+      return 1;
+    }
 
-        std::cout << Glib::ustring::compose ("received %1 bytes of data", size);
-        if (use_udp)
-            std::cout << Glib::ustring::compose (" from %1", socket_address_to_string (src_address));
-        std::cout << std::endl;
+    if (size == 0)
+      break;
 
-        if (verbose)
-            g_print ("-------------------------\n"
-                     "%.*s"
-                     "-------------------------\n",
-                     (int)size, buffer);
+    std::cout << Glib::ustring::compose("received %1 bytes of data", size);
+    if (use_udp)
+      std::cout << Glib::ustring::compose(" from %1", socket_address_to_string(src_address));
+    std::cout << std::endl;
 
-    }
+    if (verbose)
+      g_print("-------------------------\n"
+              "%.*s"
+              "-------------------------\n",
+        (int)size, buffer);
+  }
 
-    std::cout << "closing socket\n";
+  std::cout << "closing socket\n";
 
-    try {
-        socket->close ();
-    } catch (const Gio::Error& error)
-    {
-        std::cerr << Glib::ustring::compose ("Error closing master socket: %1\n",
-                                             error.what ());
-        return 1;
-    }
+  try
+  {
+    socket->close();
+  }
+  catch (const Gio::Error& error)
+  {
+    std::cerr << Glib::ustring::compose("Error closing master socket: %1\n", error.what());
+    return 1;
+  }
 
-    return 0;
+  return 0;
 }
diff --git a/examples/network/socket-server.cc b/examples/network/socket-server.cc
index 835a6b73..fb9d6eaa 100644
--- a/examples/network/socket-server.cc
+++ b/examples/network/socket-server.cc
@@ -1,11 +1,11 @@
+#include <chrono>
+#include <condition_variable>
 #include <giomm.h>
 #include <glibmm.h>
-#include <thread>
-#include <mutex>
-#include <condition_variable>
-#include <chrono>
-#include <memory>
 #include <iostream>
+#include <memory>
+#include <mutex>
+#include <thread>
 
 namespace
 {
@@ -27,8 +27,7 @@ std::condition_variable cond_thread;
 class ServerOptionGroup : public Glib::OptionGroup
 {
 public:
-  ServerOptionGroup()
-  : Glib::OptionGroup("server_group", "", "")
+  ServerOptionGroup() : Glib::OptionGroup("server_group", "", "")
   {
     Glib::OptionEntry entry;
     entry.set_long_name("port");
@@ -71,63 +70,60 @@ public:
     entry.set_description("Use IPv6 address family");
     add_entry(entry, use_ipv6);
   }
-};  
+};
 
 Glib::ustring
-socket_address_to_string (const Glib::RefPtr<Gio::SocketAddress>& address)
+socket_address_to_string(const Glib::RefPtr<Gio::SocketAddress>& address)
 {
-  auto isockaddr =
-      Glib::RefPtr<Gio::InetSocketAddress>::cast_dynamic (address);
+  auto isockaddr = Glib::RefPtr<Gio::InetSocketAddress>::cast_dynamic(address);
   if (!isockaddr)
-      return Glib::ustring ();
+    return Glib::ustring();
 
-  auto inet_address = isockaddr->get_address ();
-  auto str = inet_address->to_string ();
-  auto the_port = isockaddr->get_port ();
-  auto res = Glib::ustring::compose ("%1:%2", str, the_port);
+  auto inet_address = isockaddr->get_address();
+  auto str = inet_address->to_string();
+  auto the_port = isockaddr->get_port();
+  auto res = Glib::ustring::compose("%1:%2", str, the_port);
   return res;
 }
 
-static bool
-source_ready(Glib::IOCondition /*condition*/)
+static bool source_ready(Glib::IOCondition /*condition*/)
 {
-  loop->quit ();
+  loop->quit();
   return false;
 }
 
 static void
-ensure_condition (const Glib::RefPtr<Gio::Socket>& socket,
-                  const Glib::ustring& where,
-                  const Glib::RefPtr<Gio::Cancellable>& cancellable,
-                  Glib::IOCondition condition)
+ensure_condition(const Glib::RefPtr<Gio::Socket>& socket, const Glib::ustring& where,
+  const Glib::RefPtr<Gio::Cancellable>& cancellable, Glib::IOCondition condition)
 {
-    if (!non_blocking)
-        return;
+  if (!non_blocking)
+    return;
 
-    if (use_source)
+  if (use_source)
+  {
+    Gio::signal_socket().connect(sigc::ptr_fun(&source_ready), socket, condition);
+    loop->run();
+  }
+  else
+  {
+    try
     {
-      Gio::signal_socket().connect(sigc::ptr_fun(&source_ready), socket, condition);
-      loop->run();
+      socket->condition_wait(condition, cancellable);
     }
-    else
+    catch (const Gio::Error& error)
     {
-        try {
-            socket->condition_wait (condition, cancellable);
-        } catch (const Gio::Error& error)
-        {
-            std::cerr << Glib::ustring::compose("condition wait error for %1: %2\n",
-                        where, error.what ());
-            exit (1);
-        }
+      std::cerr << Glib::ustring::compose("condition wait error for %1: %2\n", where, error.what());
+      exit(1);
     }
+  }
 }
 
 static void
-cancel_thread (Glib::RefPtr<Gio::Cancellable> cancellable)
+cancel_thread(Glib::RefPtr<Gio::Cancellable> cancellable)
 {
   std::unique_lock<std::mutex> lock(mutex_thread);
-  if (!cond_thread.wait_for(lock, std::chrono::seconds(cancel_timeout),
-      [](){ return stop_thread; }))
+  if (!cond_thread.wait_for(
+        lock, std::chrono::seconds(cancel_timeout), []() { return stop_thread; }))
   {
     // !stop_thread, i.e. timeout
     std::cout << "Cancelling\n";
@@ -150,202 +146,207 @@ public:
 } // end anonymous namespace
 
 int
-main (int argc,
-      char *argv[])
+main(int argc, char* argv[])
 {
-    Glib::RefPtr<Gio::Socket> socket, new_socket, recv_socket;
-    Glib::RefPtr<Gio::SocketAddress> address;
-    Glib::RefPtr<Gio::Cancellable> cancellable;
+  Glib::RefPtr<Gio::Socket> socket, new_socket, recv_socket;
+  Glib::RefPtr<Gio::SocketAddress> address;
+  Glib::RefPtr<Gio::Cancellable> cancellable;
+
+  Gio::init();
+
+  Glib::OptionContext option_context(" - Test Gio::Socket server stuff");
+  ServerOptionGroup option_group;
+  option_context.set_main_group(option_group);
+  try
+  {
+    option_context.parse(argc, argv);
+  }
+  catch (const Glib::Error& error)
+  {
+    std::cerr << Glib::ustring::compose("%1: %2\n", argv[0], error.what());
+    return 1;
+  }
 
-    Gio::init ();
+  std::unique_ptr<std::thread, JoinAndDelete> thread;
+  if (cancel_timeout)
+  {
+    cancellable = Gio::Cancellable::create();
+    thread.reset(new std::thread(&cancel_thread, cancellable));
+  }
+
+  loop = Glib::MainLoop::create();
+
+  auto socket_type = use_udp ? Gio::SOCKET_TYPE_DATAGRAM : Gio::SOCKET_TYPE_STREAM;
+  auto socket_family = use_ipv6 ? Gio::SOCKET_FAMILY_IPV6 : Gio::SOCKET_FAMILY_IPV4;
+
+  try
+  {
+    socket = Gio::Socket::create(socket_family, socket_type, Gio::SOCKET_PROTOCOL_DEFAULT);
+  }
+  catch (const Gio::Error& error)
+  {
+    std::cerr << Glib::ustring::compose("%1: %2\n", argv[0], error.what());
+    return 1;
+  }
+
+  if (non_blocking)
+    socket->set_blocking(false);
+
+  auto src_address =
+    Gio::InetSocketAddress::create(Gio::InetAddress::create_any(socket_family), port);
+  try
+  {
+    socket->bind(src_address, !dont_reuse_address);
+  }
+  catch (const Gio::Error& error)
+  {
+    std::cerr << Glib::ustring::compose("Can't bind socket: %1\n", error.what());
+    return 1;
+  }
 
-    Glib::OptionContext option_context(" - Test Gio::Socket server stuff");
-    ServerOptionGroup option_group;
-    option_context.set_main_group(option_group);
+  if (!use_udp)
+  {
     try
     {
-      option_context.parse(argc, argv);
+      socket->listen();
     }
-    catch (const Glib::Error& error)
+    catch (const Gio::Error& error)
     {
-      std::cerr << Glib::ustring::compose ("%1: %2\n", argv[0], error.what());
+      std::cerr << Glib::ustring::compose("Can't listen on socket: %1\n", error.what());
       return 1;
     }
 
-    std::unique_ptr<std::thread, JoinAndDelete> thread;
-    if (cancel_timeout)
+    std::cout << Glib::ustring::compose("listening on port %1...\n", port);
+
+    ensure_condition(socket, "accept", cancellable, Glib::IO_IN);
+    try
     {
-        cancellable = Gio::Cancellable::create ();
-        thread.reset(new std::thread(&cancel_thread, cancellable));
+      new_socket = socket->accept(cancellable);
     }
-
-    loop = Glib::MainLoop::create ();
-
-    auto socket_type = use_udp ? Gio::SOCKET_TYPE_DATAGRAM : Gio::SOCKET_TYPE_STREAM;
-    auto socket_family = use_ipv6 ? Gio::SOCKET_FAMILY_IPV6 : Gio::SOCKET_FAMILY_IPV4;
-
-    try {
-        socket = Gio::Socket::create (socket_family, socket_type, Gio::SOCKET_PROTOCOL_DEFAULT);
-    } catch (const Gio::Error& error)
+    catch (const Gio::Error& error)
     {
-        std::cerr << Glib::ustring::compose ("%1: %2\n", argv[0], error.what ());
-        return 1;
+      std::cerr << Glib::ustring::compose("Error accepting socket: %1\n", error.what());
+      return 1;
     }
 
     if (non_blocking)
-        socket->set_blocking (false);
-
-    auto src_address = Gio::InetSocketAddress::create (Gio::InetAddress::create_any (socket_family), port);
-    try {
-        socket->bind (src_address, !dont_reuse_address);
-    } catch (const Gio::Error& error) {
-        std::cerr << Glib::ustring::compose ("Can't bind socket: %1\n",
-                                             error.what ());
-        return 1;
-    }
+      new_socket->set_blocking(false);
 
-    if (!use_udp)
+    try
     {
-        try {
-            socket->listen ();
-        } catch (const Gio::Error& error)
-        {
-            std::cerr << Glib::ustring::compose ("Can't listen on socket: %1\n",
-                                                 error.what ());
-            return 1;
-        }
-
-        std::cout << Glib::ustring::compose ("listening on port %1...\n", port);
-
-        ensure_condition (socket, "accept", cancellable, Glib::IO_IN);
-        try {
-            new_socket = socket->accept (cancellable);
-        } catch (const Gio::Error& error)
-        {
-            std::cerr << Glib::ustring::compose ("Error accepting socket: %1\n",
-                                                 error.what ());
-            return 1;
-        }
+      address = new_socket->get_remote_address();
+    }
+    catch (const Gio::Error& error)
+    {
+      std::cerr << Glib::ustring::compose("Error getting remote address: %1\n", error.what());
+      return 1;
+    }
 
-        if (non_blocking)
-            new_socket->set_blocking (false);
+    std::cout << Glib::ustring::compose(
+      "got a new connection from %1\n", socket_address_to_string(address));
 
-        try {
-        address = new_socket->get_remote_address ();
-        } catch (const Gio::Error& error)
-        {
-            std::cerr << Glib::ustring::compose ("Error getting remote address: %1\n",
-                                                 error.what ());
-            return 1;
-        }
+    recv_socket = new_socket;
+  }
+  else
+  {
+    recv_socket = socket;
+  }
 
-        std::cout << Glib::ustring::compose ("got a new connection from %1\n",
-                                             socket_address_to_string (address));
+  while (true)
+  {
+    gchar buffer[4096] = {};
+    gssize size;
 
-        recv_socket = new_socket;
+    ensure_condition(recv_socket, "receive", cancellable, Glib::IO_IN);
+    try
+    {
+      if (use_udp)
+        size = recv_socket->receive_from(address, buffer, sizeof buffer, cancellable);
+      else
+        size = recv_socket->receive(buffer, sizeof buffer, cancellable);
     }
-    else
+    catch (const Gio::Error& error)
     {
-        recv_socket = socket;
+      std::cerr << Glib::ustring::compose("Error receiving from socket: %1\n", error.what());
+      return 1;
     }
 
+    if (size == 0)
+      break;
 
-    while (true)
-    {
-        gchar buffer[4096] = { };
-        gssize size;
-
-        ensure_condition (recv_socket, "receive", cancellable, Glib::IO_IN);
-        try {
-            if (use_udp)
-                size = recv_socket->receive_from (address,
-                                                  buffer, sizeof buffer,
-                                                  cancellable);
-            else
-                size = recv_socket->receive (buffer, sizeof buffer,
-                                             cancellable);
-        } catch (const Gio::Error& error)
-        {
-            std::cerr << Glib::ustring::compose ("Error receiving from socket: %1\n",
-                                                 error.what ());
-            return 1;
-        }
+    std::cout << Glib::ustring::compose("received %1 bytes of data", size);
+    if (use_udp)
+      std::cout << Glib::ustring::compose(" from %1", socket_address_to_string(address));
+    std::cout << std::endl;
 
-        if (size == 0)
-            break;
+    if (verbose)
+      g_print("-------------------------\n"
+              "%.*s\n"
+              "-------------------------\n",
+        (int)size, buffer);
 
-        std::cout << Glib::ustring::compose ("received %1 bytes of data", size);
+    auto to_send = size;
+
+    while (to_send > 0)
+    {
+      ensure_condition(recv_socket, "send", cancellable, Glib::IO_OUT);
+      try
+      {
         if (use_udp)
-            std::cout << Glib::ustring::compose (" from %1", socket_address_to_string (address));
-        std::cout << std::endl;
+          size = recv_socket->send_to(address, buffer, to_send, cancellable);
+        else
+          size = recv_socket->send(buffer, to_send, cancellable);
+      }
+      catch (const Gio::Error& error)
+      {
+        if (error.code() == Gio::Error::WOULD_BLOCK)
+        {
+          std::cout << "socket send would block, handling\n";
+          continue;
+        }
+        else
+        {
+          std::cerr << Glib::ustring::compose("Error sending to socket: %1\n", error.what());
+          return 1;
+        }
+      }
 
-        if (verbose)
-            g_print ("-------------------------\n"
-                     "%.*s\n"
-                     "-------------------------\n",
-                     (int)size, buffer);
+      std::cout << Glib::ustring::compose("sent %1 bytes of data\n", size);
 
-        auto to_send = size;
+      if (size == 0)
+      {
+        std::cerr << "Unexpected short write\n";
+        return 1;
+      }
 
-        while (to_send > 0)
-        {
-            ensure_condition (recv_socket, "send", cancellable, Glib::IO_OUT);
-            try {
-                if (use_udp)
-                    size = recv_socket->send_to (address,
-                                                 buffer, to_send, cancellable);
-                else
-                    size = recv_socket->send (buffer, to_send,
-                                              cancellable);
-            } catch (const Gio::Error& error)
-            {
-                if (error.code () == Gio::Error::WOULD_BLOCK)
-                {
-                    std::cout << "socket send would block, handling\n";
-                    continue;
-                }
-                else
-                {
-                    std::cerr << Glib::ustring::compose ("Error sending to socket: %1\n",
-                                                         error.what ());
-                    return 1;
-                }
-            }
-
-            std::cout << Glib::ustring::compose ("sent %1 bytes of data\n", size);
-
-            if (size == 0)
-            {
-                std::cerr << "Unexpected short write\n";
-                return 1;
-            }
-
-            to_send -= size;
-        }
+      to_send -= size;
     }
+  }
 
-    std::cout << "connection closed\n";
+  std::cout << "connection closed\n";
 
-    if (new_socket)
+  if (new_socket)
+  {
+    try
     {
-        try {
-            new_socket->close ();
-        } catch (const Gio::Error& error)
-        {
-            std::cerr << Glib::ustring::compose ("Error closing connection socket: %1\n",
-                                                 error.what ());
-            return 1;
-        }
+      new_socket->close();
     }
-
-    try {
-        socket->close ();
-    } catch (const Gio::Error& error)
+    catch (const Gio::Error& error)
     {
-        std::cerr << Glib::ustring::compose ("Error closing master socket: %1\n",
-                                             error.what ());
-        return 1;
+      std::cerr << Glib::ustring::compose("Error closing connection socket: %1\n", error.what());
+      return 1;
     }
+  }
+
+  try
+  {
+    socket->close();
+  }
+  catch (const Gio::Error& error)
+  {
+    std::cerr << Glib::ustring::compose("Error closing master socket: %1\n", error.what());
+    return 1;
+  }
 
-    return 0;
+  return 0;
 }