#include <libsigrokdecode/libsigrokdecode.h>
-#include <boost/foreach.hpp>
-#include <boost/thread/thread.hpp>
-
#include <stdexcept>
#include <QDebug>
#include <pv/sigsession.h>
#include <pv/view/logicsignal.h>
-using boost::lock_guard;
-using boost::mutex;
+using std::lock_guard;
+using std::mutex;
using boost::optional;
-using boost::shared_ptr;
-using boost::unique_lock;
+using std::unique_lock;
using std::deque;
using std::make_pair;
using std::max;
using std::list;
using std::map;
using std::pair;
+using std::shared_ptr;
using std::vector;
using namespace pv::data::decode;
DecoderStack::~DecoderStack()
{
if (_decode_thread.joinable()) {
- _decode_thread.interrupt();
+ _interrupt = true;
_decode_thread.join();
}
}
-const std::list< boost::shared_ptr<decode::Decoder> >&
+const std::list< std::shared_ptr<decode::Decoder> >&
DecoderStack::stack() const
{
return _stack;
}
-void DecoderStack::push(boost::shared_ptr<decode::Decoder> decoder)
+void DecoderStack::push(std::shared_ptr<decode::Decoder> decoder)
{
assert(decoder);
_stack.push_back(decoder);
vector<Row> rows;
- BOOST_FOREACH (const shared_ptr<decode::Decoder> &dec, _stack)
+ for (const shared_ptr<decode::Decoder> &dec : _stack)
{
assert(dec);
if (!dec->shown())
shared_ptr<pv::data::Logic> data;
if (_decode_thread.joinable()) {
- _decode_thread.interrupt();
+ _interrupt = true;
_decode_thread.join();
}
clear();
// Check that all decoders have the required channels
- BOOST_FOREACH(const shared_ptr<decode::Decoder> &dec, _stack)
+ for (const shared_ptr<decode::Decoder> &dec : _stack)
if (!dec->have_required_probes()) {
_error_message = tr("One or more required channels "
"have not been specified");
}
// Add classes
- BOOST_FOREACH (const shared_ptr<decode::Decoder> &dec, _stack)
+ for (const shared_ptr<decode::Decoder> &dec : _stack)
{
assert(dec);
const srd_decoder *const decc = dec->decoder();
// We get the logic data of the first channel in the list.
// This works because we are currently assuming all
// LogicSignals have the same data/snapshot
- BOOST_FOREACH (const shared_ptr<decode::Decoder> &dec, _stack)
+ for (const shared_ptr<decode::Decoder> &dec : _stack)
if (dec && !dec->channels().empty() &&
((logic_signal = (*dec->channels().begin()).second)) &&
((data = logic_signal->logic_data())))
if (_samplerate == 0.0)
_samplerate = 1.0;
- _decode_thread = boost::thread(&DecoderStack::decode_proc, this);
+ _interrupt = false;
+ _decode_thread = std::thread(&DecoderStack::decode_proc, this);
}
uint64_t DecoderStack::get_max_sample_count() const
optional<int64_t> DecoderStack::wait_for_data() const
{
unique_lock<mutex> input_lock(_input_mutex);
- while(!boost::this_thread::interruption_requested() &&
- !_frame_complete && _samples_decoded >= _sample_count)
+ while(!_interrupt && !_frame_complete &&
+ _samples_decoded >= _sample_count)
_input_cond.wait(input_lock);
- return boost::make_optional(
- !boost::this_thread::interruption_requested() &&
+ return boost::make_optional(!_interrupt &&
(_samples_decoded < _sample_count || !_frame_complete),
_sample_count);
}
const unsigned int chunk_sample_count =
DecodeChunkLength / _snapshot->unit_size();
- for (int64_t i = 0;
- !boost::this_thread::interruption_requested() &&
- i < sample_count;
+ for (int64_t i = 0; !_interrupt && i < sample_count;
i += chunk_sample_count)
{
lock_guard<mutex> decode_lock(_global_decode_mutex);
// Create the decoders
const unsigned int unit_size = _snapshot->unit_size();
- BOOST_FOREACH(const shared_ptr<decode::Decoder> &dec, _stack)
+ for (const shared_ptr<decode::Decoder> &dec : _stack)
{
srd_decoder_inst *const di = dec->create_decoder_inst(session, unit_size);