event: Add trivial functions

4 files changed, 119 insertions, 0 deletions

diff --git a/src/sdeventplus/event.cpp b/src/sdeventplus/event.cpp
index f65750e..96d4190 100644
--- a/src/sdeventplus/event.cpp
+++ b/src/sdeventplus/event.cpp
@@ -54,6 +54,50 @@ const internal::SdEvent* Event::getSdEvent() const
     return sdevent;
 }
 
+int Event::prepare() const
+{
+    int r = sdevent->sd_event_prepare(event.get());
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_prepare");
+    }
+    return r;
+}
+
+int Event::wait(MaybeTimeout timeout) const
+{
+    // An unsigned -1 timeout value means infinity in sd_event
+    uint64_t timeout_usec = timeout ? timeout->count() : -1;
+    int r = sdevent->sd_event_wait(event.get(), timeout_usec);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_wait");
+    }
+    return r;
+}
+
+int Event::dispatch() const
+{
+    int r = sdevent->sd_event_dispatch(event.get());
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_dispatch");
+    }
+    return r;
+}
+
+int Event::run(MaybeTimeout timeout) const
+{
+    // An unsigned -1 timeout value means infinity in sd_event
+    uint64_t timeout_usec = timeout ? timeout->count() : -1;
+    int r = sdevent->sd_event_run(event.get(), timeout_usec);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_run");
+    }
+    return r;
+}
+
 int Event::loop() const
 {
     int r = sdevent->sd_event_loop(event.get());
@@ -64,6 +108,27 @@ int Event::loop() const
     return r;
 }
 
+int Event::exit(int code) const
+{
+    int r = sdevent->sd_event_exit(event.get(), code);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_exit");
+    }
+    return r;
+}
+
+int Event::get_exit_code() const
+{
+    int code;
+    int r = sdevent->sd_event_get_exit_code(event.get(), &code);
+    if (r < 0)
+    {
+        throw SdEventError(-r, "sd_event_get_exit_code");
+    }
+    return code;
+}
+
 int Event::get_watchdog() const
 {
     int r = sdevent->sd_event_get_watchdog(event.get());
diff --git a/src/sdeventplus/event.hpp b/src/sdeventplus/event.hpp
index b979cfc..b8ffb97 100644
--- a/src/sdeventplus/event.hpp
+++ b/src/sdeventplus/event.hpp
@@ -1,7 +1,9 @@
 #pragma once
 
+#include <experimental/optional>
 #include <sdeventplus/internal/sdevent.hpp>
 #include <sdeventplus/internal/sdref.hpp>
+#include <sdeventplus/internal/utils.hpp>
 #include <systemd/sd-event.h>
 
 namespace sdeventplus
@@ -10,6 +12,9 @@ namespace sdeventplus
 class Event
 {
   public:
+    using Timeout = SdEventDuration;
+    using MaybeTimeout = std::experimental::optional<Timeout>;
+
     Event(sd_event* event,
           const internal::SdEvent* sdevent = &internal::sdevent_impl);
     Event(sd_event* event, std::false_type,
@@ -23,7 +28,14 @@ class Event
     sd_event* get() const;
     const internal::SdEvent* getSdEvent() const;
 
+    int prepare() const;
+    int wait(MaybeTimeout timeout) const;
+    int dispatch() const;
+    int run(MaybeTimeout timeout) const;
     int loop() const;
+    int exit(int code) const;
+
+    int get_exit_code() const;
     int get_watchdog() const;
     int set_watchdog(int b) const;
 
diff --git a/src/sdeventplus/internal/sdevent.hpp b/src/sdeventplus/internal/sdevent.hpp
index 4baff05..be8e0a8 100644
--- a/src/sdeventplus/internal/sdevent.hpp
+++ b/src/sdeventplus/internal/sdevent.hpp
@@ -17,11 +17,17 @@ class SdEvent
     virtual sd_event* sd_event_ref(sd_event* event) const = 0;
     virtual sd_event* sd_event_unref(sd_event* event) const = 0;
 
+    virtual int sd_event_prepare(sd_event* event) const = 0;
+    virtual int sd_event_wait(sd_event* event, uint64_t usec) const = 0;
+    virtual int sd_event_dispatch(sd_event* event) const = 0;
+    virtual int sd_event_run(sd_event* event, uint64_t usec) const = 0;
     virtual int sd_event_loop(sd_event* event) const = 0;
+    virtual int sd_event_exit(sd_event* event, int code) const = 0;
 
     virtual int sd_event_now(sd_event* event, clockid_t clock,
                              uint64_t* usec) const = 0;
 
+    virtual int sd_event_get_exit_code(sd_event* event, int* code) const = 0;
     virtual int sd_event_get_watchdog(sd_event* event) const = 0;
     virtual int sd_event_set_watchdog(sd_event* event, int b) const = 0;
 
@@ -73,17 +79,47 @@ class SdEventImpl : public SdEvent
         return ::sd_event_unref(event);
     }
 
+    int sd_event_prepare(sd_event* event) const override
+    {
+        return ::sd_event_prepare(event);
+    }
+
+    int sd_event_wait(sd_event* event, uint64_t usec) const override
+    {
+        return ::sd_event_wait(event, usec);
+    }
+
+    int sd_event_dispatch(sd_event* event) const override
+    {
+        return ::sd_event_dispatch(event);
+    }
+
+    int sd_event_run(sd_event* event, uint64_t usec) const override
+    {
+        return ::sd_event_run(event, usec);
+    }
+
     int sd_event_loop(sd_event* event) const override
     {
         return ::sd_event_loop(event);
     }
 
+    int sd_event_exit(sd_event* event, int code) const override
+    {
+        return ::sd_event_exit(event, code);
+    }
+
     int sd_event_now(sd_event* event, clockid_t clock,
                      uint64_t* usec) const override
     {
         return ::sd_event_now(event, clock, usec);
     }
 
+    int sd_event_get_exit_code(sd_event* event, int* code) const override
+    {
+        return ::sd_event_get_exit_code(event, code);
+    }
+
     int sd_event_get_watchdog(sd_event* event) const override
     {
         return ::sd_event_get_watchdog(event);
diff --git a/src/sdeventplus/test/sdevent.hpp b/src/sdeventplus/test/sdevent.hpp
index 5f0e400..fd05b30 100644
--- a/src/sdeventplus/test/sdevent.hpp
+++ b/src/sdeventplus/test/sdevent.hpp
@@ -17,10 +17,16 @@ class SdEventMock : public internal::SdEvent
     MOCK_CONST_METHOD1(sd_event_ref, sd_event*(sd_event*));
     MOCK_CONST_METHOD1(sd_event_unref, sd_event*(sd_event*));
 
+    MOCK_CONST_METHOD1(sd_event_prepare, int(sd_event*));
+    MOCK_CONST_METHOD2(sd_event_wait, int(sd_event*, uint64_t));
+    MOCK_CONST_METHOD1(sd_event_dispatch, int(sd_event*));
+    MOCK_CONST_METHOD2(sd_event_run, int(sd_event*, uint64_t));
     MOCK_CONST_METHOD1(sd_event_loop, int(sd_event*));
+    MOCK_CONST_METHOD2(sd_event_exit, int(sd_event*, int));
 
     MOCK_CONST_METHOD3(sd_event_now, int(sd_event*, clockid_t, uint64_t*));
 
+    MOCK_CONST_METHOD2(sd_event_get_exit_code, int(sd_event*, int*));
     MOCK_CONST_METHOD1(sd_event_get_watchdog, int(sd_event*));
     MOCK_CONST_METHOD2(sd_event_set_watchdog, int(sd_event*, int b));