X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=bindings%2Fcxx%2Fclasses.cpp;h=63de4b0aecb03c29ec548994d85723225c69bdad;hb=58e21229dd553446fd389f75c6f595da9567f886;hp=25ac45b6235d166eeb735b50e7b49ac399969e45;hpb=5e1fb33469841b194e606752b865fa0d08b99067;p=libsigrok.git diff --git a/bindings/cxx/classes.cpp b/bindings/cxx/classes.cpp index 25ac45b6..63de4b0a 100644 --- a/bindings/cxx/classes.cpp +++ b/bindings/cxx/classes.cpp @@ -39,16 +39,13 @@ static void check(int result) } /** Helper function to obtain valid strings from possibly null input. */ -static const char *valid_string(const char *input) +static inline const char *valid_string(const char *input) { - if (input != NULL) - return input; - else - return ""; + return (input) ? input : ""; } /** Helper function to convert between map and GHashTable */ -static GHashTable *map_to_hash_variant(map input) +static GHashTable *map_to_hash_variant(const map &input) { auto output = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref); @@ -56,7 +53,7 @@ static GHashTable *map_to_hash_variant(map input) g_hash_table_insert(output, g_strdup(entry.first.c_str()), entry.second.gobj_copy()); - return output; + return output; } Error::Error(int result) : result(result) @@ -72,6 +69,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(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(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(cb_data); + return reader->read(res, buf, count); + } catch (const Error &err) { + return err.result; + } catch (...) { + return SR_ERR; + } +} + shared_ptr Context::create() { return shared_ptr(new Context(), Context::Deleter()); @@ -79,7 +120,7 @@ shared_ptr Context::create() Context::Context() : UserOwned(_structure), - _session(NULL) + _session(nullptr) { check(sr_init(&_structure)); @@ -169,20 +210,14 @@ void Context::set_log_level(const LogLevel *level) static int call_log_callback(void *cb_data, int loglevel, const char *format, va_list args) { - va_list args_copy; - va_copy(args_copy, args); - int length = vsnprintf(NULL, 0, format, args_copy); - va_end(args_copy); - char *buf = (char *) g_malloc(length + 1); - vsprintf(buf, format, args); - string message(buf, length); - g_free(buf); + const unique_ptr + message {g_strdup_vprintf(format, args), &g_free}; LogCallbackFunction callback = *((LogCallbackFunction *) cb_data); try { - callback(LogLevel::get(loglevel), message); + callback(LogLevel::get(loglevel), message.get()); } catch (Error e) { @@ -194,15 +229,28 @@ static int call_log_callback(void *cb_data, int loglevel, const char *format, va void Context::set_log_callback(LogCallbackFunction callback) { - _log_callback = callback; + _log_callback = move(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 Context::create_session() { @@ -230,7 +278,7 @@ shared_ptr Context::create_header_packet(Glib::TimeVal start_time) } shared_ptr Context::create_meta_packet( - map config) + const map &config) { auto meta = g_new0(struct sr_datafeed_meta, 1); for (auto input : config) @@ -263,17 +311,21 @@ shared_ptr Context::create_logic_packet( } shared_ptr Context::create_analog_packet( - vector > channels, + const vector > &channels, float *data_pointer, unsigned int num_samples, const Quantity *mq, - const Unit *unit, vector mqflags) + const Unit *unit, const vector &mqflags) { auto analog = g_new0(struct sr_datafeed_analog, 1); + auto meaning = g_new0(struct sr_analog_meaning, 1); + + analog->meaning = meaning; + for (auto channel : channels) - analog->channels = g_slist_append(analog->channels, channel->_structure); + meaning->channels = g_slist_append(meaning->channels, channel->_structure); analog->num_samples = num_samples; - analog->mq = mq->id(); - analog->unit = unit->id(); - analog->mqflags = QuantityFlag::mask_from_flags(mqflags); + meaning->mq = (sr_mq)mq->id(); + meaning->unit = (sr_unit)unit->id(); + meaning->mqflags = (sr_mqflag)QuantityFlag::mask_from_flags(mqflags); analog->data = data_pointer; auto packet = g_new(struct sr_datafeed_packet, 1); packet->type = SR_DF_ANALOG; @@ -284,13 +336,13 @@ shared_ptr Context::create_analog_packet( shared_ptr Context::load_session(string filename) { return shared_ptr( - new Session(shared_from_this(), filename), Session::Deleter()); + new Session(shared_from_this(), move(filename)), Session::Deleter()); } shared_ptr Context::create_trigger(string name) { return shared_ptr( - new Trigger(shared_from_this(), name), Trigger::Deleter()); + new Trigger(shared_from_this(), move(name)), Trigger::Deleter()); } shared_ptr Context::open_file(string filename) @@ -316,7 +368,7 @@ shared_ptr Context::open_stream(string header) map Context::serials(shared_ptr driver) { - GSList *serial_list = sr_serial_list(driver ? driver->_structure : NULL); + GSList *serial_list = sr_serial_list(driver ? driver->_structure : nullptr); map serials; for (GSList *serial = serial_list; serial; serial = serial->next) { @@ -330,7 +382,7 @@ map Context::serials(shared_ptr driver) Driver::Driver(struct sr_dev_driver *structure) : ParentOwned(structure), - Configurable(structure, NULL, NULL), + Configurable(structure, nullptr, nullptr), _initialized(false) { } @@ -350,7 +402,7 @@ string Driver::long_name() } vector> Driver::scan( - map options) + const map &options) { /* Initialise the driver if not yet done. */ if (!_initialized) @@ -360,7 +412,7 @@ vector> Driver::scan( } /* Translate scan options to GSList of struct sr_config pointers. */ - GSList *option_list = NULL; + GSList *option_list = nullptr; for (auto entry : options) { auto key = entry.first; @@ -417,11 +469,11 @@ Glib::VariantBase Configurable::config_get(const ConfigKey *key) return Glib::VariantBase(data); } -void Configurable::config_set(const ConfigKey *key, Glib::VariantBase value) +void Configurable::config_set(const ConfigKey *key, const Glib::VariantBase &value) { check(sr_config_set( config_sdi, config_channel_group, - key->id(), value.gobj())); + key->id(), const_cast(value.gobj()))); } Glib::VariantContainerBase Configurable::config_list(const ConfigKey *key) @@ -494,7 +546,7 @@ bool Configurable::config_check(const ConfigKey *key, } Device::Device(struct sr_dev_inst *structure) : - Configurable(sr_dev_inst_driver_get(structure), structure, NULL), + Configurable(sr_dev_inst_driver_get(structure), structure, nullptr), _structure(structure) { for (GSList *entry = sr_dev_inst_channels_get(structure); entry; entry = entry->next) @@ -585,7 +637,7 @@ HardwareDevice::HardwareDevice(shared_ptr driver, struct sr_dev_inst *structure) : UserOwned(structure), Device(structure), - _driver(driver) + _driver(move(driver)) { } @@ -699,7 +751,7 @@ vector> ChannelGroup::channels() Trigger::Trigger(shared_ptr context, string name) : UserOwned(sr_trigger_new(name.c_str())), - _context(context) + _context(move(context)) { for (auto stage = _structure->stages; stage; stage = stage->next) _stages.push_back( @@ -765,19 +817,19 @@ void TriggerStage::add_match(shared_ptr channel, channel->_structure, type->id(), value)); _matches.push_back(new TriggerMatch( (struct sr_trigger_match *) g_slist_last( - _structure->matches)->data, channel)); + _structure->matches)->data, move(channel))); } void TriggerStage::add_match(shared_ptr channel, const TriggerMatchType *type) { - add_match(channel, type, NAN); + add_match(move(channel), type, NAN); } TriggerMatch::TriggerMatch(struct sr_trigger_match *structure, shared_ptr channel) : ParentOwned(structure), - _channel(channel) + _channel(move(channel)) { } @@ -802,7 +854,7 @@ float TriggerMatch::value() DatafeedCallbackData::DatafeedCallbackData(Session *session, DatafeedCallbackFunction callback) : - _callback(callback), + _callback(move(callback)), _session(session) { } @@ -812,56 +864,7 @@ void DatafeedCallbackData::run(const struct sr_dev_inst *sdi, { auto device = _session->get_device(sdi); auto packet = shared_ptr(new Packet(device, pkt), Packet::Deleter()); - _callback(device, packet); -} - -SourceCallbackData::SourceCallbackData(shared_ptr source) : - _source(source) -{ -} - -bool SourceCallbackData::run(int revents) -{ - return _source->_callback((Glib::IOCondition) revents); -} - -shared_ptr EventSource::create(int fd, Glib::IOCondition events, - int timeout, SourceCallbackFunction callback) -{ - auto result = new EventSource(timeout, callback); - result->_type = EventSource::SOURCE_FD; - result->_fd = fd; - result->_events = events; - return shared_ptr(result, EventSource::Deleter()); -} - -shared_ptr EventSource::create(Glib::PollFD pollfd, int timeout, - SourceCallbackFunction callback) -{ - auto result = new EventSource(timeout, callback); - result->_type = EventSource::SOURCE_POLLFD; - result->_pollfd = pollfd; - return shared_ptr(result, EventSource::Deleter()); -} - -shared_ptr EventSource::create(Glib::RefPtr channel, - Glib::IOCondition events, int timeout, SourceCallbackFunction callback) -{ - auto result = new EventSource(timeout, callback); - result->_type = EventSource::SOURCE_IOCHANNEL; - result->_channel = channel; - result->_events = events; - return shared_ptr(result, EventSource::Deleter()); -} - -EventSource::EventSource(int timeout, SourceCallbackFunction callback) : - _timeout(timeout), - _callback(callback) -{ -} - -EventSource::~EventSource() -{ + _callback(move(device), move(packet)); } SessionDevice::SessionDevice(struct sr_dev_inst *structure) : @@ -881,18 +884,18 @@ shared_ptr SessionDevice::get_shared_from_this() Session::Session(shared_ptr context) : UserOwned(_structure), - _context(context) + _context(move(context)) { - check(sr_session_new(context->_structure, &_structure)); + check(sr_session_new(_context->_structure, &_structure)); _context->_session = this; } Session::Session(shared_ptr context, string filename) : UserOwned(_structure), - _context(context), - _filename(filename) + _context(move(context)), + _filename(move(filename)) { - check(sr_session_load(context->_structure, filename.c_str(), &_structure)); + check(sr_session_load(_context->_structure, _filename.c_str(), &_structure)); GSList *dev_list; check(sr_session_dev_list(_structure, &dev_list)); for (GSList *dev = dev_list; dev; dev = dev->next) @@ -910,9 +913,6 @@ Session::~Session() for (auto callback : _datafeed_callbacks) delete callback; - for (auto entry : _source_callbacks) - delete entry.second; - for (auto entry : _owned_devices) delete entry.second; } @@ -930,8 +930,9 @@ shared_ptr Session::get_device(const struct sr_dev_inst *sdi) void Session::add_device(shared_ptr device) { - check(sr_session_dev_add(_structure, device->_structure)); - _other_devices[device->_structure] = device; + const auto dev_struct = device->_structure; + check(sr_session_dev_add(_structure, dev_struct)); + _other_devices[dev_struct] = move(device); } vector> Session::devices() @@ -968,6 +969,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(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) { @@ -977,13 +1003,13 @@ static void datafeed_callback(const struct sr_dev_inst *sdi, void Session::add_datafeed_callback(DatafeedCallbackFunction callback) { - auto cb_data = new DatafeedCallbackData(this, callback); + auto cb_data = new DatafeedCallbackData(this, move(callback)); check(sr_session_datafeed_callback_add(_structure, datafeed_callback, cb_data)); _datafeed_callbacks.push_back(cb_data); } -void Session::remove_datafeed_callbacks(void) +void Session::remove_datafeed_callbacks() { check(sr_session_datafeed_callback_remove_all(_structure)); for (auto callback : _datafeed_callbacks) @@ -991,66 +1017,6 @@ void Session::remove_datafeed_callbacks(void) _datafeed_callbacks.clear(); } -static int source_callback(int fd, int revents, void *cb_data) -{ - (void) fd; - auto callback = (SourceCallbackData *) cb_data; - return callback->run(revents); -} - -void Session::add_source(shared_ptr source) -{ - if (_source_callbacks.count(source) == 1) - throw Error(SR_ERR_ARG); - - auto cb_data = new SourceCallbackData(source); - - switch (source->_type) - { - case EventSource::SOURCE_FD: - check(sr_session_source_add(_structure, source->_fd, source->_events, - source->_timeout, source_callback, cb_data)); - break; - case EventSource::SOURCE_POLLFD: - check(sr_session_source_add_pollfd(_structure, - source->_pollfd.gobj(), source->_timeout, source_callback, - cb_data)); - break; - case EventSource::SOURCE_IOCHANNEL: - check(sr_session_source_add_channel(_structure, - source->_channel->gobj(), source->_events, source->_timeout, - source_callback, cb_data)); - break; - } - - _source_callbacks[source] = cb_data; -} - -void Session::remove_source(shared_ptr source) -{ - if (_source_callbacks.count(source) == 0) - throw Error(SR_ERR_ARG); - - switch (source->_type) - { - case EventSource::SOURCE_FD: - check(sr_session_source_remove(_structure, source->_fd)); - break; - case EventSource::SOURCE_POLLFD: - check(sr_session_source_remove_pollfd(_structure, - source->_pollfd.gobj())); - break; - case EventSource::SOURCE_IOCHANNEL: - check(sr_session_source_remove_channel(_structure, - source->_channel->gobj())); - break; - } - - delete _source_callbacks[source]; - - _source_callbacks.erase(source); -} - shared_ptr Session::trigger() { return _trigger; @@ -1060,10 +1026,10 @@ void Session::set_trigger(shared_ptr trigger) { if (!trigger) // Set NULL trigger, i.e. remove any trigger from the session. - check(sr_session_trigger_set(_structure, NULL)); + check(sr_session_trigger_set(_structure, nullptr)); else check(sr_session_trigger_set(_structure, trigger->_structure)); - _trigger = trigger; + _trigger = move(trigger); } string Session::filename() @@ -1079,7 +1045,7 @@ shared_ptr Session::context() Packet::Packet(shared_ptr device, const struct sr_datafeed_packet *structure) : UserOwned(structure), - _device(device) + _device(move(device)) { switch (structure->type) { @@ -1238,7 +1204,7 @@ shared_ptr Analog::get_shared_pointer(Packet *_parent) ParentOwned::get_shared_pointer(_parent)); } -float *Analog::data_pointer() +void *Analog::data_pointer() { return _structure->data; } @@ -1251,7 +1217,7 @@ unsigned int Analog::num_samples() vector> Analog::channels() { vector> result; - for (auto l = _structure->channels; l; l = l->next) + for (auto l = _structure->meaning->channels; l; l = l->next) result.push_back(_parent->_device->get_channel( (struct sr_channel *)l->data)); return result; @@ -1259,17 +1225,17 @@ vector> Analog::channels() const Quantity *Analog::mq() { - return Quantity::get(_structure->mq); + return Quantity::get(_structure->meaning->mq); } const Unit *Analog::unit() { - return Unit::get(_structure->unit); + return Unit::get(_structure->meaning->unit); } vector Analog::mq_flags() { - return QuantityFlag::flags_from_mask(_structure->mqflags); + return QuantityFlag::flags_from_mask(_structure->meaning->mqflags); } InputFormat::InputFormat(const struct sr_input_module *structure) : @@ -1316,7 +1282,7 @@ map> InputFormat::options() } shared_ptr InputFormat::create_input( - map options) + const map &options) { auto input = sr_input_new(_structure, map_to_hash_variant(options)); if (!input) @@ -1327,7 +1293,7 @@ shared_ptr InputFormat::create_input( Input::Input(shared_ptr context, const struct sr_input *structure) : UserOwned(structure), - _context(context), + _context(move(context)), _device(nullptr) { } @@ -1369,7 +1335,7 @@ InputDevice::InputDevice(shared_ptr input, struct sr_dev_inst *structure) : ParentOwned(structure), Device(structure), - _input(input) + _input(move(input)) { } @@ -1385,7 +1351,7 @@ shared_ptr InputDevice::get_shared_from_this() Option::Option(const struct sr_option *structure, shared_ptr structure_array) : UserOwned(structure), - _structure_array(structure_array) + _structure_array(move(structure_array)) { } @@ -1465,18 +1431,18 @@ map> OutputFormat::options() } shared_ptr OutputFormat::create_output( - shared_ptr device, map options) + shared_ptr device, const map &options) { return shared_ptr( - new Output(shared_from_this(), device, options), + new Output(shared_from_this(), move(device), options), Output::Deleter()); } shared_ptr OutputFormat::create_output(string filename, - shared_ptr device, map options) + shared_ptr device, const map &options) { return shared_ptr( - new Output(filename, shared_from_this(), device, options), + new Output(move(filename), shared_from_this(), move(device), options), Output::Deleter()); } @@ -1486,21 +1452,21 @@ bool OutputFormat::test_flag(const OutputFlag *flag) } Output::Output(shared_ptr format, - shared_ptr device, map options) : + shared_ptr device, const map &options) : UserOwned(sr_output_new(format->_structure, - map_to_hash_variant(options), device->_structure, NULL)), - _format(format), - _device(device), + map_to_hash_variant(options), device->_structure, nullptr)), + _format(move(format)), + _device(move(device)), _options(options) { } Output::Output(string filename, shared_ptr format, - shared_ptr device, map options) : + shared_ptr device, const map &options) : UserOwned(sr_output_new(format->_structure, map_to_hash_variant(options), device->_structure, filename.c_str())), - _format(format), - _device(device), + _format(move(format)), + _device(move(device)), _options(options) { }