SigSession: Converted _signals_mutex into a boost::shared_mutex

[pulseview.git] / pv / sigsession.cpp

diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp
index 1d424c000bf3972a8c697534af02522a05d99591..11c89e092572e61119a6f96bec53a8e1a30dc775 100644 (file)
--- a/pv/sigsession.cpp
+++ b/pv/sigsession.cpp
@@ -47,12 +47,16 @@
 
 #include <libsigrok/libsigrok.hpp>
 
+using boost::shared_lock;
+using boost::shared_mutex;
+using boost::unique_lock;
+
 using std::dynamic_pointer_cast;
 using std::function;
 using std::lock_guard;
-using std::mutex;
 using std::list;
 using std::map;
+using std::mutex;
 using std::set;
 using std::shared_ptr;
 using std::string;
@@ -78,17 +82,11 @@ using Glib::VariantBase;
 using Glib::Variant;
 
 namespace pv {
-
-// TODO: This should not be necessary
-shared_ptr<Session> SigSession::_sr_session = nullptr;
-
 SigSession::SigSession(DeviceManager &device_manager) :
        _device_manager(device_manager),
+       _session(device_manager.context()->create_session()),
        _capture_state(Stopped)
 {
-       // TODO: This should not be necessary
-       _sr_session = device_manager.context()->create_session();
-
        set_default_device();
 }
 
@@ -98,7 +96,22 @@ SigSession::~SigSession()
        stop_capture();
 }
 
-shared_ptr<Device> SigSession::get_device() const
+DeviceManager& SigSession::device_manager()
+{
+       return _device_manager;
+}
+
+const DeviceManager& SigSession::device_manager() const
+{
+       return _device_manager;
+}
+
+const shared_ptr<sigrok::Session>& SigSession::session() const
+{
+       return _session;
+}
+
+shared_ptr<Device> SigSession::device() const
 {
        return _device;
 }
@@ -114,15 +127,15 @@ void SigSession::set_device(shared_ptr<Device> device)
        auto prev_session_device = dynamic_pointer_cast<SessionDevice>(_device);
 
        if (_device) {
-               _sr_session->remove_datafeed_callbacks();
+               _session->remove_datafeed_callbacks();
                if (!prev_session_device) {
                        _device->close();
-                       _sr_session->remove_devices();
+                       _session->remove_devices();
                }
        }
 
        if (session_device)
-               _sr_session = session_device->parent();
+               _session = session_device->parent();
 
        _device = device;
        _decode_traces.clear();
@@ -130,11 +143,11 @@ void SigSession::set_device(shared_ptr<Device> device)
        if (device) {
                if (!session_device)
                {
-                       _sr_session = _device_manager.context()->create_session();
+                       _session = _device_manager.context()->create_session();
                        device->open();
-                       _sr_session->add_device(device);
+                       _session->add_device(device);
                }
-               _sr_session->add_datafeed_callback([=]
+               _session->add_datafeed_callback([=]
                        (shared_ptr<Device> device, shared_ptr<Packet> packet) {
                                data_feed_in(device, packet);
                        });
@@ -144,10 +157,10 @@ void SigSession::set_device(shared_ptr<Device> device)
 
 void SigSession::set_file(const string &name)
 {
-       _sr_session = _device_manager.context()->load_session(name);
-       _device = _sr_session->devices()[0];
+       _session = _device_manager.context()->load_session(name);
+       _device = _session->devices()[0];
        _decode_traces.clear();
-       _sr_session->add_datafeed_callback([=]
+       _session->add_datafeed_callback([=]
                (shared_ptr<Device> device, shared_ptr<Packet> packet) {
                        data_feed_in(device, packet);
                });
@@ -211,7 +224,7 @@ void SigSession::start_capture(function<void (const QString)> error_handler)
 void SigSession::stop_capture()
 {
        if (get_capture_state() != Stopped)
-               _sr_session->stop();
+               _session->stop();
 
        // Check that sampling stopped
        if (_sampling_thread.joinable())
@@ -220,7 +233,7 @@ void SigSession::stop_capture()
 
 set< shared_ptr<data::SignalData> > SigSession::get_data() const
 {
-       lock_guard<mutex> lock(_signals_mutex);
+       shared_lock<shared_mutex> lock(_signals_mutex);
        set< shared_ptr<data::SignalData> > data;
        for (const shared_ptr<view::Signal> sig : _signals) {
                assert(sig);
@@ -230,9 +243,13 @@ set< shared_ptr<data::SignalData> > SigSession::get_data() const
        return data;
 }
 
-vector< shared_ptr<view::Signal> > SigSession::get_signals() const
+boost::shared_mutex& SigSession::signals_mutex() const
+{
+       return _signals_mutex;
+}
+
+const vector< shared_ptr<view::Signal> >& SigSession::signals() const
 {
-       lock_guard<mutex> lock(_signals_mutex);
        return _signals;
 }
 
@@ -244,7 +261,7 @@ bool SigSession::add_decoder(srd_decoder *const dec)
 
        try
        {
-               lock_guard<mutex> lock(_signals_mutex);
+               lock_guard<boost::shared_mutex> lock(_signals_mutex);
 
                // Create the decoder
                decoder_stack = shared_ptr<data::DecoderStack>(
@@ -265,7 +282,7 @@ bool SigSession::add_decoder(srd_decoder *const dec)
                                        dynamic_pointer_cast<view::LogicSignal>(s);
                                if (l && QString::fromUtf8(pdch->name).
                                        toLower().contains(
-                                       l->get_name().toLower()))
+                                       l->name().toLower()))
                                        channels[pdch] = l;
                        }
 
@@ -295,7 +312,7 @@ bool SigSession::add_decoder(srd_decoder *const dec)
 
 vector< shared_ptr<view::DecodeTrace> > SigSession::get_decode_signals() const
 {
-       lock_guard<mutex> lock(_signals_mutex);
+       shared_lock<shared_mutex> lock(_signals_mutex);
        return _decode_traces;
 }
 
@@ -348,8 +365,8 @@ void SigSession::update_signals(shared_ptr<Device> device)
        }
 
        // Make the Signals list
-       do {
-               lock_guard<mutex> lock(_signals_mutex);
+       {
+               unique_lock<shared_mutex> lock(_signals_mutex);
 
                _signals.clear();
 
@@ -359,7 +376,8 @@ void SigSession::update_signals(shared_ptr<Device> device)
                        switch(channel->type()->id()) {
                        case SR_CHANNEL_LOGIC:
                                signal = shared_ptr<view::Signal>(
-                                       new view::LogicSignal(device, channel, _logic_data));
+                                       new view::LogicSignal(*this, device,
+                                               channel, _logic_data));
                                break;
 
                        case SR_CHANNEL_ANALOG:
@@ -367,7 +385,8 @@ void SigSession::update_signals(shared_ptr<Device> device)
                                shared_ptr<data::Analog> data(
                                        new data::Analog());
                                signal = shared_ptr<view::Signal>(
-                                       new view::AnalogSignal(channel, data));
+                                       new view::AnalogSignal(
+                                               *this, channel, data));
                                break;
                        }
 
@@ -380,7 +399,7 @@ void SigSession::update_signals(shared_ptr<Device> device)
                        _signals.push_back(signal);
                }
 
-       } while(0);
+       }
 
        signals_changed();
 }
@@ -388,7 +407,7 @@ void SigSession::update_signals(shared_ptr<Device> device)
 shared_ptr<view::Signal> SigSession::signal_from_channel(
        shared_ptr<Channel> channel) const
 {
-       lock_guard<mutex> lock(_signals_mutex);
+       lock_guard<boost::shared_mutex> lock(_signals_mutex);
        for (shared_ptr<view::Signal> sig : _signals) {
                assert(sig);
                if (sig->channel() == channel)
@@ -419,16 +438,16 @@ void SigSession::sample_thread_proc(shared_ptr<Device> device,
        read_sample_rate(device);
 
        try {
-               _sr_session->start();
+               _session->start();
        } catch(Error e) {
                error_handler(e.what());
                return;
        }
 
-       set_capture_state(_sr_session->trigger() ?
+       set_capture_state(_session->trigger() ?
                AwaitingTrigger : Running);
 
-       _sr_session->run();
+       _session->run();
        set_capture_state(Stopped);
 
        // Confirm that SR_DF_END was received