${DBUS_DIR}/dbus-message-factory.c
${DBUS_DIR}/dbus-message-util.c
${DBUS_DIR}/dbus-shell.c
- ${DBUS_DIR}/dbus-socket-set.c
- ${DBUS_DIR}/dbus-socket-set-poll.c
+ ${DBUS_DIR}/dbus-pollable-set.c
+ ${DBUS_DIR}/dbus-pollable-set-poll.c
${DBUS_DIR}/dbus-string-util.c
${DBUS_DIR}/dbus-sysdeps-util.c
)
${DBUS_DIR}/dbus-mainloop.h
${DBUS_DIR}/dbus-message-factory.h
${DBUS_DIR}/dbus-shell.h
- ${DBUS_DIR}/dbus-socket-set.h
+ ${DBUS_DIR}/dbus-pollable-set.h
${DBUS_DIR}/dbus-spawn.h
${DBUS_DIR}/dbus-test.h
${DBUS_DIR}/dbus-test-wrappers.h
if(DBUS_HAVE_LINUX_EPOLL)
set(DBUS_UTIL_SOURCES
${DBUS_UTIL_SOURCES}
- ${DBUS_DIR}/dbus-socket-set-epoll.c
+ ${DBUS_DIR}/dbus-pollable-set-epoll.c
)
endif()
endif
if DBUS_HAVE_LINUX_EPOLL
-DBUS_UTIL_arch_sources += dbus-socket-set-epoll.c
+DBUS_UTIL_arch_sources += dbus-pollable-set-epoll.c
endif
dbusinclude_HEADERS= \
dbus-shell.c \
dbus-shell.h \
$(DBUS_UTIL_arch_sources) \
- dbus-socket-set.h \
- dbus-socket-set.c \
- dbus-socket-set-poll.c \
+ dbus-pollable-set.h \
+ dbus-pollable-set.c \
+ dbus-pollable-set-poll.c \
dbus-spawn.h \
dbus-string-util.c \
dbus-sysdeps-util.c \
#include <dbus/dbus-hash.h>
#include <dbus/dbus-list.h>
-#include <dbus/dbus-socket-set.h>
+#include <dbus/dbus-pollable-set.h>
#include <dbus/dbus-timeout.h>
#include <dbus/dbus-watch.h>
int refcount;
/** DBusPollable => dbus_malloc'd DBusList ** of references to DBusWatch */
DBusHashTable *watches;
- DBusSocketSet *socket_set;
+ DBusPollableSet *pollable_set;
DBusList *timeouts;
int callback_list_serial;
int watch_count;
loop->watches = _dbus_hash_table_new (DBUS_HASH_POLLABLE, NULL,
free_watch_table_entry);
- loop->socket_set = _dbus_socket_set_new (0);
+ loop->pollable_set = _dbus_pollable_set_new (0);
- if (loop->watches == NULL || loop->socket_set == NULL)
+ if (loop->watches == NULL || loop->pollable_set == NULL)
{
if (loop->watches != NULL)
_dbus_hash_table_unref (loop->watches);
- if (loop->socket_set != NULL)
- _dbus_socket_set_free (loop->socket_set);
+ if (loop->pollable_set != NULL)
+ _dbus_pollable_set_free (loop->pollable_set);
dbus_free (loop);
return NULL;
}
_dbus_hash_table_unref (loop->watches);
- _dbus_socket_set_free (loop->socket_set);
+ _dbus_pollable_set_free (loop->pollable_set);
dbus_free (loop);
}
}
}
if (interested)
- _dbus_socket_set_enable (loop->socket_set, fd, flags);
+ _dbus_pollable_set_enable (loop->pollable_set, fd, flags);
else
- _dbus_socket_set_disable (loop->socket_set, fd);
+ _dbus_pollable_set_disable (loop->pollable_set, fd);
}
dbus_bool_t
if (_dbus_list_length_is_one (watches))
{
- if (!_dbus_socket_set_add (loop->socket_set, fd,
+ if (!_dbus_pollable_set_add (loop->pollable_set, fd,
dbus_watch_get_flags (watch),
dbus_watch_get_enabled (watch)))
{
* entry, and stop reserving space for it in the socket set */
if (gc_watch_table_entry (loop, watches, fd))
{
- _dbus_socket_set_remove (loop->socket_set, fd);
+ _dbus_pollable_set_remove (loop->pollable_set, fd);
}
return;
{
#define N_STACK_DESCRIPTORS 64
dbus_bool_t retval;
- DBusSocketEvent ready_fds[N_STACK_DESCRIPTORS];
+ DBusPollableEvent ready_fds[N_STACK_DESCRIPTORS];
int i;
DBusList *link;
int n_ready;
_dbus_verbose (" polling on %d descriptors timeout %ld\n", _DBUS_N_ELEMENTS (ready_fds), timeout);
#endif
- n_ready = _dbus_socket_set_poll (loop->socket_set, ready_fds,
- _DBUS_N_ELEMENTS (ready_fds), timeout);
+ n_ready = _dbus_pollable_set_poll (loop->pollable_set, ready_fds,
+ _DBUS_N_ELEMENTS (ready_fds), timeout);
/* re-enable any watches we skipped this time */
if (loop->oom_watch_pending)
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-/* dbus-socket-set-epoll.c - a socket set implemented via Linux epoll(4)
+/* dbus-pollable-set-epoll.c - a pollable set implemented via Linux epoll(4)
*
* Copyright © 2011 Nokia Corporation
*
*/
#include <config.h>
-#include "dbus-socket-set.h"
+#include "dbus-pollable-set.h"
#include <dbus/dbus-internals.h>
#include <dbus/dbus-sysdeps.h>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct {
- DBusSocketSet parent;
+ DBusPollableSet parent;
int epfd;
-} DBusSocketSetEpoll;
+} DBusPollableSetEpoll;
-static inline DBusSocketSetEpoll *
-socket_set_epoll_cast (DBusSocketSet *set)
+static inline DBusPollableSetEpoll *
+socket_set_epoll_cast (DBusPollableSet *set)
{
- _dbus_assert (set->cls == &_dbus_socket_set_epoll_class);
- return (DBusSocketSetEpoll *) set;
+ _dbus_assert (set->cls == &_dbus_pollable_set_epoll_class);
+ return (DBusPollableSetEpoll *) set;
}
/* this is safe to call on a partially-allocated socket set */
static void
-socket_set_epoll_free (DBusSocketSet *set)
+socket_set_epoll_free (DBusPollableSet *set)
{
- DBusSocketSetEpoll *self = socket_set_epoll_cast (set);
+ DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
if (self == NULL)
return;
dbus_free (self);
}
-DBusSocketSet *
-_dbus_socket_set_epoll_new (void)
+DBusPollableSet *
+_dbus_pollable_set_epoll_new (void)
{
- DBusSocketSetEpoll *self;
+ DBusPollableSetEpoll *self;
- self = dbus_new0 (DBusSocketSetEpoll, 1);
+ self = dbus_new0 (DBusPollableSetEpoll, 1);
if (self == NULL)
return NULL;
- self->parent.cls = &_dbus_socket_set_epoll_class;
+ self->parent.cls = &_dbus_pollable_set_epoll_class;
self->epfd = epoll_create1 (EPOLL_CLOEXEC);
if (self->epfd == -1)
{
- socket_set_epoll_free ((DBusSocketSet *) self);
+ socket_set_epoll_free ((DBusPollableSet *) self);
return NULL;
}
- return (DBusSocketSet *) self;
+ return (DBusPollableSet *) self;
}
static uint32_t
}
static dbus_bool_t
-socket_set_epoll_add (DBusSocketSet *set,
- DBusPollable fd,
- unsigned int flags,
- dbus_bool_t enabled)
+socket_set_epoll_add (DBusPollableSet *set,
+ DBusPollable fd,
+ unsigned int flags,
+ dbus_bool_t enabled)
{
- DBusSocketSetEpoll *self = socket_set_epoll_cast (set);
+ DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
struct epoll_event event;
int err;
}
static void
-socket_set_epoll_enable (DBusSocketSet *set,
- DBusPollable fd,
- unsigned int flags)
+socket_set_epoll_enable (DBusPollableSet *set,
+ DBusPollable fd,
+ unsigned int flags)
{
- DBusSocketSetEpoll *self = socket_set_epoll_cast (set);
+ DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
struct epoll_event event;
int err;
}
static void
-socket_set_epoll_disable (DBusSocketSet *set,
- DBusPollable fd)
+socket_set_epoll_disable (DBusPollableSet *set,
+ DBusPollable fd)
{
- DBusSocketSetEpoll *self = socket_set_epoll_cast (set);
+ DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
struct epoll_event event;
int err;
}
static void
-socket_set_epoll_remove (DBusSocketSet *set,
- DBusPollable fd)
+socket_set_epoll_remove (DBusPollableSet *set,
+ DBusPollable fd)
{
- DBusSocketSetEpoll *self = socket_set_epoll_cast (set);
+ DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
int err;
/* Kernels < 2.6.9 require a non-NULL struct pointer, even though its
* contents are ignored */
#define N_STACK_DESCRIPTORS 64
static int
-socket_set_epoll_poll (DBusSocketSet *set,
- DBusSocketEvent *revents,
- int max_events,
- int timeout_ms)
+socket_set_epoll_poll (DBusPollableSet *set,
+ DBusPollableEvent *revents,
+ int max_events,
+ int timeout_ms)
{
- DBusSocketSetEpoll *self = socket_set_epoll_cast (set);
+ DBusPollableSetEpoll *self = socket_set_epoll_cast (set);
struct epoll_event events[N_STACK_DESCRIPTORS];
int n_ready;
int i;
return n_ready;
}
-DBusSocketSetClass _dbus_socket_set_epoll_class = {
+DBusPollableSetClass _dbus_pollable_set_epoll_class = {
socket_set_epoll_free,
socket_set_epoll_add,
socket_set_epoll_remove,
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-/* dbus-socket-set-poll.c - a socket set implemented via _dbus_poll
+/* dbus-pollable-set-poll.c - a pollable set implemented via _dbus_poll
*
* Copyright © 2011 Nokia Corporation
*
*/
#include <config.h>
-#include "dbus-socket-set.h"
+#include "dbus-pollable-set.h"
#include <dbus/dbus-internals.h>
#include <dbus/dbus-list.h>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct {
- DBusSocketSet parent;
- DBusPollFD *fds;
- int n_fds;
- int n_reserved;
- int n_allocated;
-} DBusSocketSetPoll;
+ DBusPollableSet parent;
+ DBusPollFD *fds;
+ int n_fds;
+ int n_reserved;
+ int n_allocated;
+} DBusPollableSetPoll;
#define REALLOC_INCREMENT 8
#define MINIMUM_SIZE 8
#define DEFAULT_SIZE_HINT MINIMUM_SIZE
#endif
-static inline DBusSocketSetPoll *
-socket_set_poll_cast (DBusSocketSet *set)
+static inline DBusPollableSetPoll *
+socket_set_poll_cast (DBusPollableSet *set)
{
- _dbus_assert (set->cls == &_dbus_socket_set_poll_class);
- return (DBusSocketSetPoll *) set;
+ _dbus_assert (set->cls == &_dbus_pollable_set_poll_class);
+ return (DBusPollableSetPoll *) set;
}
/* this is safe to call on a partially-allocated socket set */
static void
-socket_set_poll_free (DBusSocketSet *set)
+socket_set_poll_free (DBusPollableSet *set)
{
- DBusSocketSetPoll *self = socket_set_poll_cast (set);
+ DBusPollableSetPoll *self = socket_set_poll_cast (set);
dbus_free (self->fds);
dbus_free (self);
_dbus_verbose ("freed socket set %p\n", self);
}
-DBusSocketSet *
-_dbus_socket_set_poll_new (int size_hint)
+DBusPollableSet *
+_dbus_pollable_set_poll_new (int size_hint)
{
- DBusSocketSetPoll *ret;
+ DBusPollableSetPoll *ret;
if (size_hint <= 0)
size_hint = DEFAULT_SIZE_HINT;
- ret = dbus_new0 (DBusSocketSetPoll, 1);
+ ret = dbus_new0 (DBusPollableSetPoll, 1);
if (ret == NULL)
return NULL;
- ret->parent.cls = &_dbus_socket_set_poll_class;
+ ret->parent.cls = &_dbus_pollable_set_poll_class;
ret->n_fds = 0;
ret->n_allocated = size_hint;
{
/* socket_set_poll_free specifically supports half-constructed
* socket sets */
- socket_set_poll_free ((DBusSocketSet *) ret);
+ socket_set_poll_free ((DBusPollableSet *) ret);
return NULL;
}
_dbus_verbose ("new socket set at %p\n", ret);
- return (DBusSocketSet *) ret;
+ return (DBusPollableSet *) ret;
}
static short
}
static dbus_bool_t
-socket_set_poll_add (DBusSocketSet *set,
- DBusPollable fd,
- unsigned int flags,
- dbus_bool_t enabled)
+socket_set_poll_add (DBusPollableSet *set,
+ DBusPollable fd,
+ unsigned int flags,
+ dbus_bool_t enabled)
{
- DBusSocketSetPoll *self = socket_set_poll_cast (set);
+ DBusPollableSetPoll *self = socket_set_poll_cast (set);
#ifndef DBUS_DISABLE_ASSERT
int i;
}
static void
-socket_set_poll_enable (DBusSocketSet *set,
- DBusPollable fd,
- unsigned int flags)
+socket_set_poll_enable (DBusPollableSet *set,
+ DBusPollable fd,
+ unsigned int flags)
{
- DBusSocketSetPoll *self = socket_set_poll_cast (set);
+ DBusPollableSetPoll *self = socket_set_poll_cast (set);
int i;
for (i = 0; i < self->n_fds; i++)
}
static void
-socket_set_poll_disable (DBusSocketSet *set,
+socket_set_poll_disable (DBusPollableSet *set,
DBusPollable fd)
{
- DBusSocketSetPoll *self = socket_set_poll_cast (set);
+ DBusPollableSetPoll *self = socket_set_poll_cast (set);
int i;
for (i = 0; i < self->n_fds; i++)
}
static void
-socket_set_poll_remove (DBusSocketSet *set,
- DBusPollable fd)
+socket_set_poll_remove (DBusPollableSet *set,
+ DBusPollable fd)
{
- DBusSocketSetPoll *self = socket_set_poll_cast (set);
+ DBusPollableSetPoll *self = socket_set_poll_cast (set);
socket_set_poll_disable (set, fd);
self->n_reserved--;
/** This is basically Linux's epoll_wait(2) implemented in terms of poll(2);
* it returns results into a caller-supplied buffer so we can be reentrant. */
static int
-socket_set_poll_poll (DBusSocketSet *set,
- DBusSocketEvent *revents,
- int max_events,
- int timeout_ms)
+socket_set_poll_poll (DBusPollableSet *set,
+ DBusPollableEvent *revents,
+ int max_events,
+ int timeout_ms)
{
- DBusSocketSetPoll *self = socket_set_poll_cast (set);
+ DBusPollableSetPoll *self = socket_set_poll_cast (set);
int i;
int n_events;
int n_ready;
return n_events;
}
-DBusSocketSetClass _dbus_socket_set_poll_class = {
+DBusPollableSetClass _dbus_pollable_set_poll_class = {
socket_set_poll_free,
socket_set_poll_add,
socket_set_poll_remove,
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
- * dbus-socket-set.c - used to bolt file descriptors onto a bus
+ * dbus-pollable-set.c - a set of pollable objects (file descriptors, sockets or handles)
*
* Copyright © 2011 Nokia Corporation
*
*/
#include <config.h>
-#include <dbus/dbus-socket-set.h>
+#include <dbus/dbus-pollable-set.h>
-DBusSocketSet *
-_dbus_socket_set_new (int size_hint)
+DBusPollableSet *
+_dbus_pollable_set_new (int size_hint)
{
- DBusSocketSet *ret;
+ DBusPollableSet *ret;
#ifdef DBUS_HAVE_LINUX_EPOLL
- ret = _dbus_socket_set_epoll_new ();
+ ret = _dbus_pollable_set_epoll_new ();
if (ret != NULL)
return ret;
#endif
- ret = _dbus_socket_set_poll_new (size_hint);
+ ret = _dbus_pollable_set_poll_new (size_hint);
if (ret != NULL)
return ret;
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * dbus-pollable-set.h - a set of pollable objects (file descriptors, sockets or handles)
+ *
+ * Copyright © 2011 Nokia Corporation
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ *
+ */
+
+#ifndef DBUS_POLLABLE_SET_H
+#define DBUS_POLLABLE_SET_H
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+#include <dbus/dbus.h>
+#include <dbus/dbus-sysdeps.h>
+
+typedef struct {
+ DBusPollable fd;
+ unsigned int flags;
+} DBusPollableEvent;
+
+typedef struct DBusPollableSet DBusPollableSet;
+
+typedef struct DBusPollableSetClass DBusPollableSetClass;
+struct DBusPollableSetClass {
+ void (*free) (DBusPollableSet *self);
+ dbus_bool_t (*add) (DBusPollableSet *self,
+ DBusPollable fd,
+ unsigned int flags,
+ dbus_bool_t enabled);
+ void (*remove) (DBusPollableSet *self,
+ DBusPollable fd);
+ void (*enable) (DBusPollableSet *self,
+ DBusPollable fd,
+ unsigned int flags);
+ void (*disable) (DBusPollableSet *self,
+ DBusPollable fd);
+ int (*poll) (DBusPollableSet *self,
+ DBusPollableEvent *revents,
+ int max_events,
+ int timeout_ms);
+};
+
+struct DBusPollableSet {
+ DBusPollableSetClass *cls;
+};
+
+DBusPollableSet *_dbus_pollable_set_new (int size_hint);
+
+static inline void
+_dbus_pollable_set_free (DBusPollableSet *self)
+{
+ (self->cls->free) (self);
+}
+
+static inline dbus_bool_t
+_dbus_pollable_set_add (DBusPollableSet *self,
+ DBusPollable fd,
+ unsigned int flags,
+ dbus_bool_t enabled)
+{
+ return (self->cls->add) (self, fd, flags, enabled);
+}
+
+static inline void
+_dbus_pollable_set_remove (DBusPollableSet *self,
+ DBusPollable fd)
+{
+ (self->cls->remove) (self, fd);
+}
+
+static inline void
+_dbus_pollable_set_enable (DBusPollableSet *self,
+ DBusPollable fd,
+ unsigned int flags)
+{
+ (self->cls->enable) (self, fd, flags);
+}
+
+static inline void
+_dbus_pollable_set_disable (DBusPollableSet *self,
+ DBusPollable fd)
+{
+ (self->cls->disable) (self, fd);
+}
+
+
+static inline int
+_dbus_pollable_set_poll (DBusPollableSet *self,
+ DBusPollableEvent *revents,
+ int max_events,
+ int timeout_ms)
+{
+ return (self->cls->poll) (self, revents, max_events, timeout_ms);
+}
+
+/* concrete implementations, not necessarily built on all platforms */
+
+extern DBusPollableSetClass _dbus_pollable_set_poll_class;
+extern DBusPollableSetClass _dbus_pollable_set_epoll_class;
+
+DBusPollableSet *_dbus_pollable_set_poll_new (int size_hint);
+DBusPollableSet *_dbus_pollable_set_epoll_new (void);
+
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS */
+#endif /* multiple-inclusion guard */
+++ /dev/null
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-/*
- * dbus-socket-set.h - used to bolt file descriptors onto a bus
- *
- * Copyright © 2011 Nokia Corporation
- *
- * Licensed under the Academic Free License version 2.1
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301 USA
- *
- */
-
-#ifndef DBUS_SOCKET_SET_H
-#define DBUS_SOCKET_SET_H
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-#include <dbus/dbus.h>
-#include <dbus/dbus-sysdeps.h>
-
-typedef struct {
- DBusPollable fd;
- unsigned int flags;
-} DBusSocketEvent;
-
-typedef struct DBusSocketSet DBusSocketSet;
-
-typedef struct DBusSocketSetClass DBusSocketSetClass;
-struct DBusSocketSetClass {
- void (*free) (DBusSocketSet *self);
- dbus_bool_t (*add) (DBusSocketSet *self,
- DBusPollable fd,
- unsigned int flags,
- dbus_bool_t enabled);
- void (*remove) (DBusSocketSet *self,
- DBusPollable fd);
- void (*enable) (DBusSocketSet *self,
- DBusPollable fd,
- unsigned int flags);
- void (*disable) (DBusSocketSet *self,
- DBusPollable fd);
- int (*poll) (DBusSocketSet *self,
- DBusSocketEvent *revents,
- int max_events,
- int timeout_ms);
-};
-
-struct DBusSocketSet {
- DBusSocketSetClass *cls;
-};
-
-DBusSocketSet *_dbus_socket_set_new (int size_hint);
-
-static inline void
-_dbus_socket_set_free (DBusSocketSet *self)
-{
- (self->cls->free) (self);
-}
-
-static inline dbus_bool_t
-_dbus_socket_set_add (DBusSocketSet *self,
- DBusPollable fd,
- unsigned int flags,
- dbus_bool_t enabled)
-{
- return (self->cls->add) (self, fd, flags, enabled);
-}
-
-static inline void
-_dbus_socket_set_remove (DBusSocketSet *self,
- DBusPollable fd)
-{
- (self->cls->remove) (self, fd);
-}
-
-static inline void
-_dbus_socket_set_enable (DBusSocketSet *self,
- DBusPollable fd,
- unsigned int flags)
-{
- (self->cls->enable) (self, fd, flags);
-}
-
-static inline void
-_dbus_socket_set_disable (DBusSocketSet *self,
- DBusPollable fd)
-{
- (self->cls->disable) (self, fd);
-}
-
-
-static inline int
-_dbus_socket_set_poll (DBusSocketSet *self,
- DBusSocketEvent *revents,
- int max_events,
- int timeout_ms)
-{
- return (self->cls->poll) (self, revents, max_events, timeout_ms);
-}
-
-/* concrete implementations, not necessarily built on all platforms */
-
-extern DBusSocketSetClass _dbus_socket_set_poll_class;
-extern DBusSocketSetClass _dbus_socket_set_epoll_class;
-
-DBusSocketSet *_dbus_socket_set_poll_new (int size_hint);
-DBusSocketSet *_dbus_socket_set_epoll_new (void);
-
-#endif /* !DOXYGEN_SHOULD_SKIP_THIS */
-#endif /* multiple-inclusion guard */
projects / thirdparty / dbus.git / commitdiff
