Minor Doxygen comment cosmetics.

[pulseview.git] / pv / session.cpp

diff --git a/pv/session.cpp b/pv/session.cpp
index 66d80f1a4bde58b649cc571d1194431824f6f516..00eb7ad0142716e6eac7aaf4749f694ecd9cdfe5 100644 (file)
--- a/pv/session.cpp
+++ b/pv/session.cpp
@@ -434,26 +434,76 @@ void Session::set_default_device()
        set_device((iter == devices.end()) ? devices.front() : *iter);
 }
 
+/**
+ * Convert generic options to data types that are specific to InputFormat.
+ *
+ * @param[in] user_spec Vector of tokenized words, string format.
+ * @param[in] fmt_opts Input format's options, result of InputFormat::options().
+ *
+ * @return Map of options suitable for InputFormat::create_input().
+ */
+map<string, Glib::VariantBase>
+Session::input_format_options(vector<string> user_spec,
+               map<string, shared_ptr<Option>> fmt_opts)
+{
+       map<string, Glib::VariantBase> result;
+
+       for (auto entry : user_spec) {
+               /*
+                * Split key=value specs. Accept entries without separator
+                * (for simplified boolean specifications).
+                */
+               string key, val;
+               size_t pos = entry.find("=");
+               if (pos == std::string::npos) {
+                       key = entry;
+                       val = "";
+               } else {
+                       key = entry.substr(0, pos);
+                       val = entry.substr(pos + 1);
+               }
+
+               /*
+                * Skip user specifications that are not a member of the
+                * format's set of supported options. Have the text input
+                * spec converted to the required input format specific
+                * data type.
+                */
+               auto found = fmt_opts.find(key);
+               if (found == fmt_opts.end())
+                       continue;
+               shared_ptr<Option> opt = found->second;
+               result[key] = opt->parse_string(val);
+       }
+
+       return result;
+}
+
 void Session::load_init_file(const string &file_name, const string &format)
 {
        shared_ptr<InputFormat> input_format;
+       map<string, Glib::VariantBase> input_opts;
 
        if (!format.empty()) {
                const map<string, shared_ptr<InputFormat> > formats =
                        device_manager_.context()->input_formats();
+               auto user_opts = pv::util::split_string(format, ":");
+               string user_name = user_opts.front();
+               user_opts.erase(user_opts.begin());
                const auto iter = find_if(formats.begin(), formats.end(),
                        [&](const pair<string, shared_ptr<InputFormat> > f) {
-                               return f.first == format; });
+                               return f.first == user_name; });
                if (iter == formats.end()) {
                        main_bar_->session_error(tr("Error"),
                                tr("Unexpected input format: %s").arg(QString::fromStdString(format)));
                        return;
                }
-
                input_format = (*iter).second;
+               input_opts = input_format_options(user_opts,
+                       input_format->options());
        }
 
-       load_file(QString::fromStdString(file_name), input_format);
+       load_file(QString::fromStdString(file_name), input_format, input_opts);
 }
 
 void Session::load_file(QString file_name,
@@ -734,22 +784,22 @@ void Session::update_signals()
 
        // Make the signals list
        for (shared_ptr<views::ViewBase> viewbase : views_) {
-               views::TraceView::View *trace_view =
-                       qobject_cast<views::TraceView::View*>(viewbase.get());
+               views::trace::View *trace_view =
+                       qobject_cast<views::trace::View*>(viewbase.get());
 
                if (trace_view) {
-                       unordered_set< shared_ptr<views::TraceView::Signal> >
+                       unordered_set< shared_ptr<views::trace::Signal> >
                                prev_sigs(trace_view->signals());
                        trace_view->clear_signals();
 
                        for (auto channel : sr_dev->channels()) {
                                shared_ptr<data::SignalBase> signalbase;
-                               shared_ptr<views::TraceView::Signal> signal;
+                               shared_ptr<views::trace::Signal> signal;
 
                                // Find the channel in the old signals
                                const auto iter = find_if(
                                        prev_sigs.cbegin(), prev_sigs.cend(),
-                                       [&](const shared_ptr<views::TraceView::Signal> &s) {
+                                       [&](const shared_ptr<views::trace::Signal> &s) {
                                                return s->base()->channel() == channel;
                                        });
                                if (iter != prev_sigs.end()) {
@@ -777,8 +827,8 @@ void Session::update_signals()
                                                                signalbase.get(), SLOT(on_capture_state_changed(int)));
                                                }
 
-                                               signal = shared_ptr<views::TraceView::Signal>(
-                                                       new views::TraceView::LogicSignal(*this,
+                                               signal = shared_ptr<views::trace::Signal>(
+                                                       new views::trace::LogicSignal(*this,
                                                                device_, signalbase));
                                                trace_view->add_signal(signal);
                                                break;
@@ -798,8 +848,8 @@ void Session::update_signals()
                                                                signalbase.get(), SLOT(on_capture_state_changed(int)));
                                                }
 
-                                               signal = shared_ptr<views::TraceView::Signal>(
-                                                       new views::TraceView::AnalogSignal(
+                                               signal = shared_ptr<views::trace::Signal>(
+                                                       new views::trace::AnalogSignal(
                                                                *this, signalbase));
                                                trace_view->add_signal(signal);
                                                break;