#ifndef LIBSIGROKCXX_HPP
#define LIBSIGROKCXX_HPP
-#include "libsigrok/libsigrok.h"
+#include <libsigrok/libsigrok.h>
#include <glibmm.h>
#include <stdexcept>
class SR_API Device;
class SR_API HardwareDevice;
class SR_API Channel;
-class SR_API EventSource;
class SR_API Session;
class SR_API ConfigKey;
class SR_API InputFormat;
class SR_API OutputFormat;
+class SR_API OutputFlag;
class SR_API LogLevel;
class SR_API ChannelGroup;
class SR_API Trigger;
class SR_API Error: public exception
{
public:
- Error(int result);
- ~Error() throw();
+ explicit Error(int result);
+ ~Error() noexcept;
const int result;
- const char *what() const throw();
+ const char *what() const noexcept;
};
/* Base template for classes whose resources are owned by a parent object. */
if (!(shared = _weak_this.lock()))
{
- shared = shared_ptr<Class>((Class *) this, reset_parent);
+ shared = shared_ptr<Class>(static_cast<Class *>(this), reset_parent);
_weak_this = shared;
}
Struct *_structure;
- ParentOwned<Class, Parent, Struct>(Struct *structure) :
+ explicit ParentOwned(Struct *structure) :
_structure(structure)
{
}
protected:
Struct *_structure;
- UserOwned<Class, Struct>(Struct *structure) :
+ explicit UserOwned(Struct *structure) :
_structure(structure)
{
}
/** Type of log callback */
typedef function<void(const LogLevel *, string message)> LogCallbackFunction;
+/** Resource reader delegate. */
+class SR_API ResourceReader
+{
+public:
+ ResourceReader() {}
+ virtual ~ResourceReader();
+private:
+ /** Resource open hook. */
+ virtual void open(struct sr_resource *res, string name) = 0;
+ /** Resource close hook. */
+ virtual void close(struct sr_resource *res) = 0;
+ /** Resource read hook. */
+ virtual size_t read(const struct sr_resource *res, void *buf, size_t count) = 0;
+
+ static SR_PRIV int open_callback(struct sr_resource *res,
+ const char *name, void *cb_data) noexcept;
+ static SR_PRIV int close_callback(struct sr_resource *res,
+ void *cb_data) noexcept;
+ static SR_PRIV ssize_t read_callback(const struct sr_resource *res,
+ void *buf, size_t count, void *cb_data) noexcept;
+ friend class Context;
+};
+
/** The global libsigrok context */
class SR_API Context : public UserOwned<Context, struct sr_context>
{
/** Create new context */
static shared_ptr<Context> create();
/** libsigrok package version. */
- string package_version();
+ static string package_version();
/** libsigrok library version. */
- string lib_version();
+ static string lib_version();
/** Available hardware drivers, indexed by name. */
map<string, shared_ptr<Driver> > drivers();
/** Available input formats, indexed by name. */
/** Available output formats, indexed by name. */
map<string, shared_ptr<OutputFormat> > output_formats();
/** Current log level. */
- const LogLevel *log_level();
+ const LogLevel *log_level() const;
/** Set the log level.
* @param level LogLevel to use. */
void set_log_level(const LogLevel *level);
- /** Current log domain. */
- string log_domain();
- /** Set the log domain.
- * @param value Log domain prefix string. */
- void set_log_domain(string value);
/** Set the log callback.
* @param callback Callback of the form callback(LogLevel, string). */
void set_log_callback(LogCallbackFunction callback);
/** Set the log callback to the default handler. */
void set_log_callback_default();
+ /** Install a delegate for reading resource files.
+ * @param reader The resource reader delegate, or nullptr to unset. */
+ void set_resource_reader(ResourceReader *reader);
/** Create a new session. */
shared_ptr<Session> create_session();
/** Create a new user device. */
shared_ptr<Packet> create_header_packet(Glib::TimeVal start_time);
/** Create a meta packet. */
shared_ptr<Packet> create_meta_packet(
- map<const ConfigKey *, Glib::VariantBase> config);
+ const map<const ConfigKey *, Glib::VariantBase> &config);
/** Create a logic packet. */
shared_ptr<Packet> create_logic_packet(
void *data_pointer, size_t data_length, unsigned int unit_size);
/** Create an analog packet. */
shared_ptr<Packet> create_analog_packet(
- vector<shared_ptr<Channel> > channels,
+ const vector<shared_ptr<Channel> > &channels,
float *data_pointer, unsigned int num_samples, const Quantity *mq,
- const Unit *unit, vector<const QuantityFlag *> mqflags);
+ const Unit *unit, const vector<const QuantityFlag *> &mqflags);
/** Load a saved session.
* @param filename File name string. */
shared_ptr<Session> load_session(string filename);
/** Open an input stream based on header data.
* @param header Initial data from stream. */
shared_ptr<Input> open_stream(string header);
- map<string, string> serials(shared_ptr<Driver> driver);
+ map<string, string> serials(shared_ptr<Driver> driver) const;
protected:
map<string, Driver *> _drivers;
map<string, InputFormat *> _input_formats;
public:
/** Read configuration for the given key.
* @param key ConfigKey to read. */
- Glib::VariantBase config_get(const ConfigKey *key);
+ Glib::VariantBase config_get(const ConfigKey *key) const;
/** Set configuration for the given key to a specified value.
* @param key ConfigKey to set.
* @param value Value to set. */
- void config_set(const ConfigKey *key, Glib::VariantBase value);
+ void config_set(const ConfigKey *key, const Glib::VariantBase &value);
/** Enumerate available values for the given configuration key.
* @param key ConfigKey to enumerate values for. */
- Glib::VariantContainerBase config_list(const ConfigKey *key);
+ Glib::VariantContainerBase config_list(const ConfigKey *key) const;
/** Enumerate available keys, according to a given index key. */
map<const ConfigKey *, set<Capability> > config_keys(const ConfigKey *key);
/** Check for a key in the list from a given index key. */
- bool config_check(const ConfigKey *key, const ConfigKey *index_key);
+ bool config_check(const ConfigKey *key, const ConfigKey *index_key) const;
protected:
Configurable(
struct sr_dev_driver *driver,
{
public:
/** Name of this driver. */
- string name();
+ string name() const;
/** Long name for this driver. */
- string long_name();
+ string long_name() const;
/** Scan for devices and return a list of devices found.
* @param options Mapping of (ConfigKey, value) pairs. */
vector<shared_ptr<HardwareDevice> > scan(
- map<const ConfigKey *, Glib::VariantBase> options =
- map<const ConfigKey *, Glib::VariantBase>());
+ const map<const ConfigKey *, Glib::VariantBase> &options = {});
protected:
bool _initialized;
vector<HardwareDevice *> _devices;
- Driver(struct sr_dev_driver *structure);
+ explicit Driver(struct sr_dev_driver *structure);
~Driver();
friend class Context;
friend class HardwareDevice;
{
public:
/** Vendor name for this device. */
- string vendor();
+ string vendor() const;
/** Model name for this device. */
- string model();
+ string model() const;
/** Version string for this device. */
- string version();
+ string version() const;
/** Serial number for this device. */
- string serial_number();
+ string serial_number() const;
/** Connection ID for this device. */
- string connection_id();
+ string connection_id() const;
/** List of the channels available on this device. */
vector<shared_ptr<Channel> > channels();
/** Channel groups available on this device, indexed by name. */
/** Close device. */
void close();
protected:
- Device(struct sr_dev_inst *structure);
+ explicit Device(struct sr_dev_inst *structure);
~Device();
virtual shared_ptr<Device> get_shared_from_this() = 0;
shared_ptr<Channel> get_channel(struct sr_channel *ptr);
{
public:
/** Current name of this channel. */
- string name();
+ string name() const;
/** Set the name of this channel. *
* @param name Name string to set. */
void set_name(string name);
/** Type of this channel. */
- const ChannelType *type();
+ const ChannelType *type() const;
/** Enabled status of this channel. */
- bool enabled();
+ bool enabled() const;
/** Set the enabled status of this channel.
* @param value Boolean value to set. */
void set_enabled(bool value);
/** Get the index number of this channel. */
- unsigned int index();
+ unsigned int index() const;
protected:
- Channel(struct sr_channel *structure);
+ explicit Channel(struct sr_channel *structure);
~Channel();
const ChannelType * const _type;
friend class Device;
{
public:
/** Name of this channel group. */
- string name();
+ string name() const;
/** List of the channels in this group. */
vector<shared_ptr<Channel> > channels();
protected:
{
public:
/** Name of this trigger configuration. */
- string name();
+ string name() const;
/** List of the stages in this trigger. */
vector<shared_ptr<TriggerStage> > stages();
/** Add a new stage to this trigger. */
{
public:
/** Index number of this stage. */
- int number();
+ int number() const;
/** List of match conditions on this stage. */
vector<shared_ptr<TriggerMatch> > matches();
/** Add a new match condition to this stage.
void add_match(shared_ptr<Channel> channel, const TriggerMatchType *type, float value);
protected:
vector<TriggerMatch *> _matches;
- TriggerStage(struct sr_trigger_stage *structure);
+ explicit TriggerStage(struct sr_trigger_stage *structure);
~TriggerStage();
friend class Trigger;
};
/** Channel this condition matches on. */
shared_ptr<Channel> channel();
/** Type of match. */
- const TriggerMatchType *type();
+ const TriggerMatchType *type() const;
/** Threshold value. */
- float value();
+ float value() const;
protected:
TriggerMatch(struct sr_trigger_match *structure, shared_ptr<Channel> channel);
~TriggerMatch();
friend class TriggerStage;
};
+/** Type of session stopped callback */
+typedef function<void()> SessionStoppedCallback;
+
/** Type of datafeed callback */
typedef function<void(shared_ptr<Device>, shared_ptr<Packet>)>
DatafeedCallbackFunction;
friend class Session;
};
-/** Type of source callback */
-typedef function<bool(Glib::IOCondition)>
- SourceCallbackFunction;
-
-/* Data required for C callback function to call a C++ source callback */
-class SR_PRIV SourceCallbackData
-{
-public:
- bool run(int revents);
-protected:
- SourceCallbackData(shared_ptr<EventSource> source);
- shared_ptr<EventSource> _source;
- friend class Session;
-};
-
-/** An I/O event source */
-class SR_API EventSource
-{
-public:
- /** Create an event source from a file descriptor.
- * @param fd File descriptor.
- * @param events GLib IOCondition event mask.
- * @param timeout Timeout in milliseconds.
- * @param callback Callback of the form callback(events) */
- static shared_ptr<EventSource> create(int fd, Glib::IOCondition events,
- int timeout, SourceCallbackFunction callback);
- /** Create an event source from a GLib PollFD
- * @param pollfd GLib PollFD
- * @param timeout Timeout in milliseconds.
- * @param callback Callback of the form callback(events) */
- static shared_ptr<EventSource> create(Glib::PollFD pollfd, int timeout,
- SourceCallbackFunction callback);
- /** Create an event source from a GLib IOChannel
- * @param channel GLib IOChannel.
- * @param events GLib IOCondition event mask.
- * @param timeout Timeout in milliseconds.
- * @param callback Callback of the form callback(events) */
- static shared_ptr<EventSource> create(
- Glib::RefPtr<Glib::IOChannel> channel, Glib::IOCondition events,
- int timeout, SourceCallbackFunction callback);
-protected:
- EventSource(int timeout, SourceCallbackFunction callback);
- ~EventSource();
- enum source_type {
- SOURCE_FD,
- SOURCE_POLLFD,
- SOURCE_IOCHANNEL
- } _type;
- int _fd;
- Glib::PollFD _pollfd;
- Glib::RefPtr<Glib::IOChannel> _channel;
- Glib::IOCondition _events;
- int _timeout;
- SourceCallbackFunction _callback;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(EventSource *source) { delete source; }
- };
- friend class Deleter;
- friend class Session;
- friend class SourceCallbackData;
-};
-
/** A virtual device associated with a stored session */
class SR_API SessionDevice :
public ParentOwned<SessionDevice, Session, struct sr_dev_inst>,
public Device
{
protected:
- SessionDevice(struct sr_dev_inst *sdi);
+ explicit SessionDevice(struct sr_dev_inst *sdi);
~SessionDevice();
shared_ptr<Device> get_shared_from_this();
/** Deleter needed to allow shared_ptr use with protected destructor. */
void add_datafeed_callback(DatafeedCallbackFunction callback);
/** Remove all datafeed callbacks from this session. */
void remove_datafeed_callbacks();
- /** Add an I/O event source.
- * @param source EventSource to add. */
- void add_source(shared_ptr<EventSource> source);
- /** Remove an event source.
- * @param source EventSource to remove. */
- void remove_source(shared_ptr<EventSource> source);
/** Start the session. */
void start();
/** Run the session event loop. */
void run();
/** Stop the session. */
void stop();
- /** Begin saving session to a file.
- * @param filename File name string. */
- void begin_save(string filename);
- /** Append a packet to the session file being saved.
- * @param packet Packet to append. */
- void append(shared_ptr<Packet> packet);
- /** Append raw logic data to the session file being saved. */
- void append(void *data, size_t length, unsigned int unit_size);
+ /** Return whether the session is running. */
+ bool is_running() const;
+ /** Set callback to be invoked on session stop. */
+ void set_stopped_callback(SessionStoppedCallback callback);
/** Get current trigger setting. */
shared_ptr<Trigger> trigger();
/** Get the context. */
* @param trigger Trigger object to use. */
void set_trigger(shared_ptr<Trigger> trigger);
/** Get filename this session was loaded from. */
- string filename();
+ string filename() const;
protected:
- Session(shared_ptr<Context> context);
+ explicit Session(shared_ptr<Context> context);
Session(shared_ptr<Context> context, string filename);
~Session();
shared_ptr<Device> get_device(const struct sr_dev_inst *sdi);
map<const struct sr_dev_inst *, SessionDevice *> _owned_devices;
map<const struct sr_dev_inst *, shared_ptr<Device> > _other_devices;
vector<DatafeedCallbackData *> _datafeed_callbacks;
- map<shared_ptr<EventSource>, SourceCallbackData *> _source_callbacks;
+ SessionStoppedCallback _stopped_callback;
string _filename;
- bool _saving;
- bool _save_initialized;
- string _save_filename;
- uint64_t _save_samplerate;
shared_ptr<Trigger> _trigger;
friend class Deleter;
friend class Context;
{
public:
/** Type of this packet. */
- const PacketType *type();
+ const PacketType *type() const;
/** Payload of this packet. */
shared_ptr<PacketPayload> payload();
protected:
{
public:
/* Feed version number. */
- int feed_version();
+ int feed_version() const;
/* Start time of this session. */
- Glib::TimeVal start_time();
+ Glib::TimeVal start_time() const;
protected:
- Header(const struct sr_datafeed_header *structure);
+ explicit Header(const struct sr_datafeed_header *structure);
~Header();
shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
friend class Packet;
{
public:
/* Mapping of (ConfigKey, value) pairs. */
- map<const ConfigKey *, Glib::VariantBase> config();
+ map<const ConfigKey *, Glib::VariantBase> config() const;
protected:
- Meta(const struct sr_datafeed_meta *structure);
+ explicit Meta(const struct sr_datafeed_meta *structure);
~Meta();
shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
map<const ConfigKey *, Glib::VariantBase> _config;
/* Pointer to data. */
void *data_pointer();
/* Data length in bytes. */
- size_t data_length();
+ size_t data_length() const;
/* Size of each sample in bytes. */
- unsigned int unit_size();
+ unsigned int unit_size() const;
protected:
- Logic(const struct sr_datafeed_logic *structure);
+ explicit Logic(const struct sr_datafeed_logic *structure);
~Logic();
shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
friend class Packet;
{
public:
/** Pointer to data. */
- float *data_pointer();
+ void *data_pointer();
/** Number of samples in this packet. */
- unsigned int num_samples();
+ unsigned int num_samples() const;
/** Channels for which this packet contains data. */
vector<shared_ptr<Channel> > channels();
/** Measured quantity of the samples in this packet. */
- const Quantity *mq();
+ const Quantity *mq() const;
/** Unit of the samples in this packet. */
- const Unit *unit();
+ const Unit *unit() const;
/** Measurement flags associated with the samples in this packet. */
- vector<const QuantityFlag *> mq_flags();
+ vector<const QuantityFlag *> mq_flags() const;
protected:
- Analog(const struct sr_datafeed_analog *structure);
+ explicit Analog(const struct sr_datafeed_analog *structure);
~Analog();
shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
friend class Packet;
{
public:
/** Name of this input format. */
- string name();
+ string name() const;
/** Description of this input format. */
- string description();
+ string description() const;
+ /** A list of preferred file name extensions for this file format.
+ * @note This list is a recommendation only. */
+ vector<string> extensions() const;
/** Options supported by this input format. */
map<string, shared_ptr<Option> > options();
/** Create an input using this input format.
* @param options Mapping of (option name, value) pairs. */
- shared_ptr<Input> create_input(map<string, Glib::VariantBase> options =
- map<string, Glib::VariantBase>());
+ shared_ptr<Input> create_input(const map<string, Glib::VariantBase> &options = {});
protected:
- InputFormat(const struct sr_input_module *structure);
+ explicit InputFormat(const struct sr_input_module *structure);
~InputFormat();
friend class Context;
friend class InputDevice;
/** Virtual device associated with this input. */
shared_ptr<InputDevice> device();
/** Send next stream data.
- * @param data Next stream data. */
- void send(string data);
+ * @param data Next stream data.
+ * @param length Length of data. */
+ void send(void *data, size_t length);
/** Signal end of input data. */
void end();
protected:
{
public:
/** Short name of this option suitable for command line usage. */
- string id();
+ string id() const;
/** Short name of this option suitable for GUI usage. */
- string name();
+ string name() const;
/** Description of this option in a sentence. */
- string description();
+ string description() const;
/** Default value for this option. */
- Glib::VariantBase default_value();
+ Glib::VariantBase default_value() const;
/** Possible values for this option, if a limited set. */
- vector<Glib::VariantBase> values();
+ vector<Glib::VariantBase> values() const;
protected:
Option(const struct sr_option *structure,
shared_ptr<const struct sr_option *> structure_array);
{
public:
/** Name of this output format. */
- string name();
+ string name() const;
/** Description of this output format. */
- string description();
+ string description() const;
+ /** A list of preferred file name extensions for this file format.
+ * @note This list is a recommendation only. */
+ vector<string> extensions() const;
/** Options supported by this output format. */
map<string, shared_ptr<Option> > options();
/** Create an output using this format.
* @param device Device to output for.
* @param options Mapping of (option name, value) pairs. */
- shared_ptr<Output> create_output(shared_ptr<Device> device,
- map<string, Glib::VariantBase> options =
- map<string, Glib::VariantBase>());
-protected:
- OutputFormat(const struct sr_output_module *structure);
+ shared_ptr<Output> create_output(
+ shared_ptr<Device> device,
+ const map<string, Glib::VariantBase> &options = {});
+ /** Create an output using this format.
+ * @param filename Name of destination file.
+ * @param device Device to output for.
+ * @param options Mapping of (option name, value) pairs. */
+ shared_ptr<Output> create_output(string filename,
+ shared_ptr<Device> device,
+ const map<string, Glib::VariantBase> &options = {});
+ /**
+ * Checks whether a given flag is set.
+ * @param flag Flag to check
+ * @return true if flag is set for this module
+ * @see sr_output_flags
+ */
+ bool test_flag(const OutputFlag *flag) const;
+protected:
+ explicit OutputFormat(const struct sr_output_module *structure);
~OutputFormat();
friend class Context;
friend class Output;
protected:
Output(shared_ptr<OutputFormat> format, shared_ptr<Device> device);
Output(shared_ptr<OutputFormat> format,
- shared_ptr<Device> device, map<string, Glib::VariantBase> options);
+ shared_ptr<Device> device, const map<string, Glib::VariantBase> &options);
+ Output(string filename, shared_ptr<OutputFormat> format,
+ shared_ptr<Device> device, const map<string, Glib::VariantBase> &options);
~Output();
const shared_ptr<OutputFormat> _format;
const shared_ptr<Device> _device;
/** Get value associated with a given integer constant. */
static const Class *get(int id)
{
- auto key = static_cast<Enum>(id);
- if (_values.find(key) == _values.end())
+ const auto pos = _values.find(static_cast<Enum>(id));
+ if (pos == _values.end())
throw Error(SR_ERR_ARG);
- return _values.at(key);
+ return pos->second;
}
/** Get possible values. */
static std::vector<const Class *> values()
const string _name;
};
-#include "enums.hpp"
+#include <libsigrokcxx/enums.hpp>
}