X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=bindings%2Fcxx%2Fclasses.cpp;h=bed6bed8529edb170c1cfe5c8a22fd6a2d2a1816;hb=9fa5b426ec7c0a77eb9401f3dd10ad463a8d1ac7;hp=42ef6e7d4019fde915a1d9f6f56e3567cbd908f6;hpb=35114c3394679a4da54b930328409b3223507bad;p=libsigrok.git diff --git a/bindings/cxx/classes.cpp b/bindings/cxx/classes.cpp index 42ef6e7d..bed6bed8 100644 --- a/bindings/cxx/classes.cpp +++ b/bindings/cxx/classes.cpp @@ -214,6 +214,13 @@ shared_ptr Context::create_session() new Session(shared_from_this()), Session::Deleter()); } +shared_ptr Context::create_user_device( + string vendor, string model, string version) +{ + return shared_ptr( + new UserDevice(vendor, model, version), UserDevice::Deleter()); +} + shared_ptr Context::load_session(string filename) { return shared_ptr( @@ -256,8 +263,6 @@ Driver::Driver(struct sr_dev_driver *structure) : Driver::~Driver() { - for (auto device : _devices) - delete device; } string Driver::name() @@ -280,11 +285,6 @@ vector> Driver::scan( _initialized = true; } - /* Clear all existing instances. */ - for (auto device : _devices) - delete device; - _devices.clear(); - /* Translate scan options to GSList of struct sr_config pointers. */ GSList *option_list = NULL; for (auto entry : options) @@ -303,20 +303,20 @@ vector> Driver::scan( /* Free option list. */ g_slist_free_full(option_list, g_free); + /* Create device objects. */ + vector> result; for (GSList *device = device_list; device; device = device->next) { auto sdi = (struct sr_dev_inst *) device->data; - _devices.push_back(new HardwareDevice(this, sdi)); + result.push_back(shared_ptr( + new HardwareDevice(shared_from_this(), sdi), + HardwareDevice::Deleter())); } /* Free GSList returned from scan. */ g_slist_free(device_list); - /* Create list of shared pointers to device instances for return. */ - vector> result; - for (auto device : _devices) - result.push_back(device->get_shared_pointer(_parent)); return result; } @@ -359,22 +359,32 @@ Glib::VariantContainerBase Configurable::config_list(const ConfigKey *key) return Glib::VariantContainerBase(data); } -vector Configurable::config_keys(const ConfigKey *key) +map> Configurable::config_keys(const ConfigKey *key) { GVariant *gvar_opts; gsize num_opts; - const int32_t *opts; - vector result; + const uint32_t *opts; + map> result; check(sr_config_list( config_driver, config_sdi, config_channel_group, key->id(), &gvar_opts)); - opts = (const int32_t *) g_variant_get_fixed_array( - gvar_opts, &num_opts, sizeof(int32_t)); + opts = (const uint32_t *) g_variant_get_fixed_array( + gvar_opts, &num_opts, sizeof(uint32_t)); for (gsize i = 0; i < num_opts; i++) - result.push_back(ConfigKey::get(opts[i])); + { + auto key = ConfigKey::get(opts[i] & SR_CONF_MASK); + set capabilities; + if (opts[i] & SR_CONF_GET) + capabilities.insert(GET); + if (opts[i] & SR_CONF_SET) + capabilities.insert(SET); + if (opts[i] & SR_CONF_LIST) + capabilities.insert(LIST); + result[key] = capabilities; + } g_variant_unref(gvar_opts); @@ -386,18 +396,18 @@ bool Configurable::config_check(const ConfigKey *key, { GVariant *gvar_opts; gsize num_opts; - const int32_t *opts; + const uint32_t *opts; if (sr_config_list(config_driver, config_sdi, config_channel_group, index_key->id(), &gvar_opts) != SR_OK) return false; - opts = (const int32_t *) g_variant_get_fixed_array( - gvar_opts, &num_opts, sizeof(int32_t)); + opts = (const uint32_t *) g_variant_get_fixed_array( + gvar_opts, &num_opts, sizeof(uint32_t)); for (gsize i = 0; i < num_opts; i++) { - if (opts[i] == key->id()) + if ((opts[i] & SR_CONF_MASK) == (uint32_t) key->id()) { g_variant_unref(gvar_opts); return true; @@ -410,16 +420,16 @@ bool Configurable::config_check(const ConfigKey *key, } Device::Device(struct sr_dev_inst *structure) : - Configurable(structure->driver, structure, NULL), + Configurable(sr_dev_inst_driver_get(structure), structure, NULL), _structure(structure) { - for (GSList *entry = structure->channels; entry; entry = entry->next) + for (GSList *entry = sr_dev_inst_channels_get(structure); entry; entry = entry->next) { auto channel = (struct sr_channel *) entry->data; _channels[channel] = new Channel(channel); } - for (GSList *entry = structure->channel_groups; entry; entry = entry->next) + for (GSList *entry = sr_dev_inst_channel_groups_get(structure); entry; entry = entry->next) { auto group = (struct sr_channel_group *) entry->data; _channel_groups[group->name] = new ChannelGroup(this, group); @@ -434,39 +444,35 @@ Device::~Device() delete entry.second; } -string Device::description() +string Device::vendor() { - ostringstream s; - - vector parts = - {vendor(), model(), version()}; - - for (string part : parts) - if (part.length() > 0) - s << part; + return valid_string(sr_dev_inst_vendor_get(_structure)); +} - return s.str(); +string Device::model() +{ + return valid_string(sr_dev_inst_model_get(_structure)); } -string Device::vendor() +string Device::version() { - return valid_string(_structure->vendor); + return valid_string(sr_dev_inst_version_get(_structure)); } -string Device::model() +string Device::serial_number() { - return valid_string(_structure->model); + return valid_string(sr_dev_inst_sernum_get(_structure)); } -string Device::version() +string Device::connection_id() { - return valid_string(_structure->version); + return valid_string(sr_dev_inst_connid_get(_structure)); } vector> Device::channels() { vector> result; - for (auto channel = _structure->channels; channel; channel = channel->next) + for (auto channel = sr_dev_inst_channels_get(_structure); channel; channel = channel->next) result.push_back( _channels[(struct sr_channel *) channel->data]->get_shared_pointer( get_shared_from_this())); @@ -501,8 +507,9 @@ void Device::close() check(sr_dev_close(_structure)); } -HardwareDevice::HardwareDevice(Driver *driver, struct sr_dev_inst *structure) : - ParentOwned(structure), +HardwareDevice::HardwareDevice(shared_ptr driver, + struct sr_dev_inst *structure) : + UserOwned(structure), Device(structure), _driver(driver) { @@ -519,7 +526,35 @@ shared_ptr HardwareDevice::get_shared_from_this() shared_ptr HardwareDevice::driver() { - return _driver->get_shared_pointer(_parent); + return _driver; +} + +UserDevice::UserDevice(string vendor, string model, string version) : + UserOwned(sr_dev_inst_user_new( + vendor.c_str(), model.c_str(), version.c_str())), + Device(UserOwned::_structure) +{ +} + +UserDevice::~UserDevice() +{ +} + +shared_ptr UserDevice::get_shared_from_this() +{ + return static_pointer_cast(shared_from_this()); +} + +shared_ptr UserDevice::add_channel(unsigned int index, + const ChannelType *type, string name) +{ + check(sr_dev_inst_channel_add(Device::_structure, + index, type->id(), name.c_str())); + struct sr_channel *structure = (struct sr_channel *) + g_slist_last(sr_dev_inst_channels_get(Device::_structure))->data; + Channel *channel = new Channel(structure); + _channels[structure] = channel; + return get_channel(structure); } Channel::Channel(struct sr_channel *structure) : @@ -566,7 +601,7 @@ unsigned int Channel::index() ChannelGroup::ChannelGroup(Device *device, struct sr_channel_group *structure) : ParentOwned(structure), - Configurable(device->_structure->driver, device->_structure, structure) + Configurable(sr_dev_inst_driver_get(device->_structure), device->_structure, structure) { for (GSList *entry = structure->channels; entry; entry = entry->next) _channels.push_back(device->_channels[(struct sr_channel *)entry->data]); @@ -702,7 +737,7 @@ DatafeedCallbackData::DatafeedCallbackData(Session *session, void DatafeedCallbackData::run(const struct sr_dev_inst *sdi, const struct sr_datafeed_packet *pkt) { - auto device = _session->_devices[sdi]; + auto device = _session->get_device(sdi); auto packet = shared_ptr(new Packet(device, pkt), Packet::Deleter()); _callback(device, packet); } @@ -783,6 +818,7 @@ Session::Session(shared_ptr context) : Session::Session(shared_ptr context, string filename) : UserOwned(_structure), _context(context), + _filename(filename), _saving(false) { check(sr_session_load(filename.c_str(), &_structure)); @@ -791,9 +827,7 @@ Session::Session(shared_ptr context, string filename) : for (GSList *dev = dev_list; dev; dev = dev->next) { auto sdi = (struct sr_dev_inst *) dev->data; - auto device = new SessionDevice(sdi); - _devices[sdi] = shared_ptr(device, - SessionDevice::Deleter()); + _owned_devices[sdi] = new SessionDevice(sdi); } _context->_session = this; } @@ -807,12 +841,26 @@ Session::~Session() for (auto entry : _source_callbacks) delete entry.second; + + for (auto entry : _owned_devices) + delete entry.second; +} + +shared_ptr Session::get_device(const struct sr_dev_inst *sdi) +{ + if (_owned_devices.count(sdi)) + return static_pointer_cast( + _owned_devices[sdi]->get_shared_pointer(this)); + else if (_other_devices.count(sdi)) + return _other_devices[sdi]; + else + throw Error(SR_ERR_BUG); } void Session::add_device(shared_ptr device) { check(sr_session_dev_add(_structure, device->_structure)); - _devices[device->_structure] = device; + _other_devices[device->_structure] = device; } vector> Session::devices() @@ -823,14 +871,14 @@ vector> Session::devices() for (GSList *dev = dev_list; dev; dev = dev->next) { auto sdi = (struct sr_dev_inst *) dev->data; - result.push_back(_devices[sdi]); + result.push_back(get_device(sdi)); } return result; } void Session::remove_devices() { - _devices.clear(); + _other_devices.clear(); check(sr_session_dev_remove_all(_structure)); } @@ -884,7 +932,7 @@ void Session::append(shared_ptr packet) { GVariant *samplerate; - check(sr_config_get(packet->_device->_structure->driver, + check(sr_config_get(sr_dev_inst_driver_get(packet->_device->_structure), packet->_device->_structure, NULL, SR_CONF_SAMPLERATE, &samplerate)); @@ -1030,6 +1078,11 @@ void Session::set_trigger(shared_ptr trigger) _trigger = trigger; } +string Session::filename() +{ + return _filename; +} + Packet::Packet(shared_ptr device, const struct sr_datafeed_packet *structure) : UserOwned(structure), @@ -1295,11 +1348,16 @@ void Input::send(string data) check(ret); } +void Input::end() +{ + check(sr_input_end(_structure)); +} + Input::~Input() { if (_device) delete _device; - check(sr_input_free(_structure)); + sr_input_free(_structure); } InputDevice::InputDevice(shared_ptr input,