C++: Add bindings for session stop notification

[libsigrok.git] / bindings / cxx / classes.cpp

diff --git a/bindings/cxx/classes.cpp b/bindings/cxx/classes.cpp
index 25ac45b6235d166eeb735b50e7b49ac399969e45..f40a6dc571d27aebf124427cf62cf6763096aea4 100644 (file)
--- a/bindings/cxx/classes.cpp
+++ b/bindings/cxx/classes.cpp
@@ -72,6 +72,50 @@ Error::~Error() throw()
 {
 }
 
+ResourceReader::~ResourceReader()
+{
+}
+
+SR_PRIV int ResourceReader::open_callback(struct sr_resource *res,
+               const char *name, void *cb_data)
+{
+       try {
+               auto *const reader = static_cast<ResourceReader*>(cb_data);
+               reader->open(res, name);
+       } catch (const Error &err) {
+               return err.result;
+       } catch (...) {
+               return SR_ERR;
+       }
+       return SR_OK;
+}
+
+SR_PRIV int ResourceReader::close_callback(struct sr_resource *res, void *cb_data)
+{
+       try {
+               auto *const reader = static_cast<ResourceReader*>(cb_data);
+               reader->close(res);
+       } catch (const Error &err) {
+               return err.result;
+       } catch (...) {
+               return SR_ERR;
+       }
+       return SR_OK;
+}
+
+SR_PRIV ssize_t ResourceReader::read_callback(const struct sr_resource *res,
+               void *buf, size_t count, void *cb_data)
+{
+       try {
+               auto *const reader = static_cast<ResourceReader*>(cb_data);
+               return reader->read(res, buf, count);
+       } catch (const Error &err) {
+               return err.result;
+       } catch (...) {
+               return SR_ERR;
+       }
+}
+
 shared_ptr<Context> Context::create()
 {
        return shared_ptr<Context>(new Context(), Context::Deleter());
@@ -196,13 +240,26 @@ void Context::set_log_callback(LogCallbackFunction callback)
 {
        _log_callback = callback;
        check(sr_log_callback_set(call_log_callback, &_log_callback));
-} 
+}
 
 void Context::set_log_callback_default()
 {
        check(sr_log_callback_set_default());
        _log_callback = nullptr;
-} 
+}
+
+void Context::set_resource_reader(ResourceReader *reader)
+{
+       if (reader) {
+               check(sr_resource_set_hooks(_structure,
+                               &ResourceReader::open_callback,
+                               &ResourceReader::close_callback,
+                               &ResourceReader::read_callback, reader));
+       } else {
+               check(sr_resource_set_hooks(_structure,
+                               nullptr, nullptr, nullptr, nullptr));
+       }
+}
 
 shared_ptr<Session> Context::create_session()
 {
@@ -968,6 +1025,31 @@ void Session::stop()
        check(sr_session_stop(_structure));
 }
 
+bool Session::is_running() const
+{
+       const int ret = sr_session_is_running(_structure);
+       if (ret < 0)
+               throw Error{ret};
+       return (ret != 0);
+}
+
+static void session_stopped_callback(void *data)
+{
+       auto *const callback = static_cast<SessionStoppedCallback*>(data);
+       (*callback)();
+}
+
+void Session::set_stopped_callback(SessionStoppedCallback callback)
+{
+       _stopped_callback = move(callback);
+       if (_stopped_callback)
+               check(sr_session_stopped_callback_set(_structure,
+                               &session_stopped_callback, &_stopped_callback));
+       else
+               check(sr_session_stopped_callback_set(_structure,
+                               nullptr, nullptr));
+}
+
 static void datafeed_callback(const struct sr_dev_inst *sdi,
        const struct sr_datafeed_packet *pkt, void *cb_data)
 {