Use SignalBase instead of LogicSignal for decoders

[pulseview.git] / pv / session.cpp

diff --git a/pv/session.cpp b/pv/session.cpp
index ba43ac21fb9c64d0d1b2711949fb417e4493c890..99dca2157e96641ed0fdbf7dd3100749dd35f963 100644 (file)
--- a/pv/session.cpp
+++ b/pv/session.cpp
@@ -39,6 +39,7 @@
 #include "data/decoderstack.hpp"
 #include "data/logic.hpp"
 #include "data/logicsegment.hpp"
+#include "data/signalbase.hpp"
 #include "data/decode/decoder.hpp"
 
 #include "devices/hardwaredevice.hpp"
@@ -161,7 +162,15 @@ void Session::set_device(shared_ptr<devices::Device> device)
        signals_changed();
 
        device_ = std::move(device);
-       device_->open();
+
+       try {
+               device_->open();
+       } catch (const QString &e) {
+               device_.reset();
+               device_selected();
+               throw;
+       }
+
        device_->session()->add_datafeed_callback([=]
                (shared_ptr<sigrok::Device> device, shared_ptr<Packet> packet) {
                        data_feed_in(device, packet);
@@ -223,8 +232,7 @@ void Session::start_capture(function<void (const QString)> error_handler)
 
        // Begin the session
        sampling_thread_ = std::thread(
-               &Session::sample_thread_proc, this, device_,
-                       error_handler);
+               &Session::sample_thread_proc, this, error_handler);
 }
 
 void Session::stop_capture()
@@ -267,7 +275,7 @@ const unordered_set< shared_ptr<view::Signal> > Session::signals() const
 #ifdef ENABLE_DECODE
 bool Session::add_decoder(srd_decoder *const dec)
 {
-       map<const srd_channel*, shared_ptr<view::LogicSignal> > channels;
+       map<const srd_channel*, shared_ptr<data::SignalBase> > channels;
        shared_ptr<data::DecoderStack> decoder_stack;
 
        try {
@@ -286,13 +294,12 @@ bool Session::add_decoder(srd_decoder *const dec)
 
                // Auto select the initial channels
                for (const srd_channel *pdch : all_channels)
-                       for (shared_ptr<view::Signal> s : signals_) {
-                               shared_ptr<view::LogicSignal> l =
-                                       dynamic_pointer_cast<view::LogicSignal>(s);
-                               if (l && QString::fromUtf8(pdch->name).
-                                       toLower().contains(
-                                       l->name().toLower()))
-                                       channels[pdch] = l;
+                       for (shared_ptr<data::SignalBase> b : signalbases_) {
+                               if (b->type() == ChannelType::LOGIC) {
+                                       if (QString::fromUtf8(pdch->name).toLower().
+                                               contains(b->name().toLower()))
+                                               channels[pdch] = b;
+                               }
                        }
 
                assert(decoder_stack);
@@ -301,8 +308,11 @@ bool Session::add_decoder(srd_decoder *const dec)
                decoder_stack->stack().front()->set_channels(channels);
 
                // Create the decode signal
+               shared_ptr<data::SignalBase> signalbase =
+                       shared_ptr<data::SignalBase>(new data::SignalBase(nullptr));
+
                shared_ptr<view::DecodeTrace> d(
-                       new view::DecodeTrace(*this, decoder_stack,
+                       new view::DecodeTrace(*this, signalbase, decoder_stack,
                                decode_traces_.size()));
                decode_traces_.push_back(d);
        } catch (std::runtime_error e) {
@@ -394,41 +404,42 @@ void Session::update_signals()
                signals_.clear();
 
                for (auto channel : sr_dev->channels()) {
+                       shared_ptr<data::SignalBase> signalbase;
                        shared_ptr<view::Signal> signal;
 
                        // Find the channel in the old signals
                        const auto iter = std::find_if(
                                prev_sigs.cbegin(), prev_sigs.cend(),
                                [&](const shared_ptr<view::Signal> &s) {
-                                       return s->channel() == channel;
+                                       return s->base()->channel() == channel;
                                });
                        if (iter != prev_sigs.end()) {
                                // Copy the signal from the old set to the new
                                signal = *iter;
-                               auto logic_signal = dynamic_pointer_cast<
-                                       view::LogicSignal>(signal);
-                               if (logic_signal)
-                                       logic_signal->set_logic_data(
-                                               logic_data_);
                        } else {
                                // Create a new signal
+                               signalbase = shared_ptr<data::SignalBase>(
+                                       new data::SignalBase(channel));
+
                                switch(channel->type()->id()) {
                                case SR_CHANNEL_LOGIC:
+                                       signalbase->set_data(logic_data_);
                                        signal = shared_ptr<view::Signal>(
                                                new view::LogicSignal(*this,
-                                                       device_, channel,
-                                                       logic_data_));
+                                                       device_, signalbase));
                                        all_signal_data_.insert(logic_data_);
+                                       signalbases_.insert(signalbase);
                                        break;
 
                                case SR_CHANNEL_ANALOG:
                                {
-                                       shared_ptr<data::Analog> data(
-                                               new data::Analog());
+                                       shared_ptr<data::Analog> data(new data::Analog());
+                                       signalbase->set_data(data);
                                        signal = shared_ptr<view::Signal>(
                                                new view::AnalogSignal(
-                                                       *this, channel, data));
+                                                       *this, signalbase));
                                        all_signal_data_.insert(data);
+                                       signalbases_.insert(signalbase);
                                        break;
                                }
 
@@ -446,22 +457,19 @@ void Session::update_signals()
        signals_changed();
 }
 
-shared_ptr<view::Signal> Session::signal_from_channel(
-       shared_ptr<Channel> channel) const
+shared_ptr<data::SignalBase> Session::signalbase_from_channel(
+       shared_ptr<sigrok::Channel> channel) const
 {
-       lock_guard<boost::shared_mutex> lock(signals_mutex_);
-       for (shared_ptr<view::Signal> sig : signals_) {
+       for (shared_ptr<data::SignalBase> sig : signalbases_) {
                assert(sig);
                if (sig->channel() == channel)
                        return sig;
        }
-       return shared_ptr<view::Signal>();
+       return shared_ptr<data::SignalBase>();
 }
 
-void Session::sample_thread_proc(shared_ptr<devices::Device> device,
-       function<void (const QString)> error_handler)
+void Session::sample_thread_proc(function<void (const QString)> error_handler)
 {
-       assert(device);
        assert(error_handler);
 
        if (!device_)
@@ -620,12 +628,10 @@ void Session::feed_in_analog(shared_ptr<Analog> analog)
                        cur_analog_segments_[channel] = segment;
 
                        // Find the analog data associated with the channel
-                       shared_ptr<view::AnalogSignal> sig =
-                               dynamic_pointer_cast<view::AnalogSignal>(
-                                       signal_from_channel(channel));
-                       assert(sig);
+                       shared_ptr<data::SignalBase> base = signalbase_from_channel(channel);
+                       assert(base);
 
-                       shared_ptr<data::Analog> data(sig->analog_data());
+                       shared_ptr<data::Analog> data(base->analog_data());
                        assert(data);
 
                        // Push the segment into the analog data.