* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include "devicemanager.h"
-#include "sigsession.h"
+#include "devicemanager.hpp"
+#include "session.hpp"
#include <cassert>
#include <stdexcept>
namespace pv {
DeviceManager::DeviceManager(shared_ptr<Context> context) :
- _context(context)
+ context_(context)
{
for (auto entry : context->drivers())
driver_scan(entry.second, map<const ConfigKey *, VariantBase>());
shared_ptr<Context> DeviceManager::context()
{
- return _context;
+ return context_;
}
const list< shared_ptr<HardwareDevice> >& DeviceManager::devices() const
{
- return _devices;
+ return devices_;
}
list< shared_ptr<HardwareDevice> > DeviceManager::driver_scan(
// Remove any device instances from this driver from the device
// list. They will not be valid after the scan.
- remove_if(_devices.begin(), _devices.end(),
- [&](shared_ptr<HardwareDevice> device) {
- return device->driver() == driver; });
+ devices_.remove_if([&](shared_ptr<HardwareDevice> device) {
+ return device->driver() == driver; });
// Do the scan
auto devices = driver->scan(drvopts);
driver_devices.insert(driver_devices.end(), devices.begin(), devices.end());
- driver_devices.sort(compare_devices);
- // Add the scanned devices to the main list
- _devices.insert(_devices.end(), driver_devices.begin(),
+ // Add the scanned devices to the main list, set display names and sort.
+ devices_.insert(devices_.end(), driver_devices.begin(),
driver_devices.end());
- _devices.sort(compare_devices);
+
+ for (shared_ptr<Device> device : devices_)
+ display_names_[device] = build_display_name(device);
+
+ devices_.sort([&](shared_ptr<Device> a, shared_ptr<Device> b)
+ { return compare_devices(a, b); });
+
+ // As the display names depend on the complete devices_ list,
+ // we need to recompute them. However, there is no need to
+ // recomute all names of the devices_ list since only the
+ // devices that use the given driver can be affected.
+ for (shared_ptr<Device> device : driver_devices)
+ display_names_[device] = build_display_name(device);
+
+ driver_devices.sort([&](shared_ptr<Device> a, shared_ptr<Device> b)
+ { return compare_devices(a, b); });
return driver_devices;
}
last_resort_dev = NULL;
- for (shared_ptr<HardwareDevice> dev : _devices) {
+ for (shared_ptr<HardwareDevice> dev : devices_) {
assert(dev);
dev_info = get_device_info(dev);
return last_resort_dev;
}
-string DeviceManager::device_description(shared_ptr<Device> device)
+const string DeviceManager::build_display_name(shared_ptr<Device> device)
{
auto session_device = dynamic_pointer_cast<SessionDevice>(device);
+ auto hardware_device = dynamic_pointer_cast<HardwareDevice>(device);
if (session_device)
return boost::filesystem::path(
ostringstream s;
- vector<string> parts = {device->vendor(), device->model(),
- device->version(), device->serial_number()};
+ bool multiple_dev = false;
+
+ // If we can find another device with the same model/vendor then
+ // we have at least two such devices and need to distinguish them.
+ if (hardware_device)
+ multiple_dev = any_of(devices_.begin(), devices_.end(),
+ [&](shared_ptr<HardwareDevice> dev) {
+ return (dev->vendor() == hardware_device->vendor() &&
+ dev->model() == hardware_device->model()) &&
+ dev != hardware_device;
+ } );
+
+ vector<string> parts = {device->vendor(), device->model()};
+
+ if (multiple_dev) {
+ parts.push_back(device->version());
+ parts.push_back(device->serial_number());
+
+ if ((device->serial_number().length() == 0) &&
+ (device->connection_id().length() > 0))
+ parts.push_back("("+device->connection_id()+")");
+ }
for (size_t i = 0; i < parts.size(); i++)
{
}
}
- if (device->serial_number().length() == 0 &&
- device->connection_id().length() > 0)
- s << " " << device->connection_id();
-
return s.str();
}
-bool DeviceManager::compare_devices(shared_ptr<HardwareDevice> a,
- shared_ptr<HardwareDevice> b)
+const std::string DeviceManager::get_display_name(std::shared_ptr<sigrok::Device> dev)
+{
+ return display_names_[dev];
+}
+
+void DeviceManager::update_display_name(std::shared_ptr<sigrok::Device> dev)
+{
+ display_names_[dev] = build_display_name(dev);
+}
+
+bool DeviceManager::compare_devices(shared_ptr<Device> a,
+ shared_ptr<Device> b)
{
assert(a);
assert(b);
- return device_description(a).compare(device_description(b)) < 0;
+ return display_names_[a].compare(display_names_[b]) < 0;
}
} // namespace pv