#define LIBSIGROKCXX_HPP
#include <libsigrok/libsigrok.h>
+
+/* Suppress warnings due to glibmm's use of std::auto_ptr<> in a public
+ * header file. To be removed once glibmm is fixed. */
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
#include <glibmm.h>
+G_GNUC_END_IGNORE_DEPRECATIONS
#include <stdexcept>
#include <memory>
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 Capability;
class SR_API InputFormat;
class SR_API OutputFormat;
class SR_API OutputFlag;
class SR_API Quantity;
class SR_API Unit;
class SR_API QuantityFlag;
+class SR_API Rational;
class SR_API Input;
class SR_API InputDevice;
class SR_API Output;
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. */
-template <class Class, class Parent, typename Struct>
+template <class Class, class Parent>
class SR_API ParentOwned
{
+private:
+ /* Weak pointer for shared_from_this() implementation. */
+ weak_ptr<Class> _weak_this;
+
+ static void reset_parent(Class *object)
+ {
+ if (!object->_parent)
+ throw Error(SR_ERR_BUG);
+ object->_parent.reset();
+ }
+
protected:
/* Parent object which owns this child object's underlying structure.
references to both the parent and all its children are gone. */
shared_ptr<Parent> _parent;
- /* Weak pointer for shared_from_this() implementation. */
- weak_ptr<Class> _weak_this;
-
-public:
- /* Get parent object that owns this object. */
- shared_ptr<Parent> parent()
- {
- return _parent;
- }
+ ParentOwned() {}
/* Note, this implementation will create a new smart_ptr if none exists. */
shared_ptr<Class> shared_from_this()
{
- shared_ptr<Class> shared;
+ shared_ptr<Class> shared = _weak_this.lock();
- if (!(shared = _weak_this.lock()))
+ if (!shared)
{
- shared = shared_ptr<Class>((Class *) this, reset_parent);
+ shared.reset(static_cast<Class *>(this), &reset_parent);
_weak_this = shared;
}
return shared;
}
- shared_ptr<Class>
get_shared_pointer(shared_ptr<Parent> parent)
+ shared_ptr<Class>
share_owned_by(shared_ptr<Parent> parent)
{
if (!parent)
throw Error(SR_ERR_BUG);
return shared_from_this();
}
- shared_ptr<Class> get_shared_pointer(Parent *parent)
- {
- if (!parent)
- throw Error(SR_ERR_BUG);
- return get_shared_pointer(parent->shared_from_this());
- }
-protected:
- static void reset_parent(Class *object)
- {
- if (!object->_parent)
- throw Error(SR_ERR_BUG);
- object->_parent.reset();
- }
-
- Struct *_structure;
-
- ParentOwned<Class, Parent, Struct>(Struct *structure) :
- _structure(structure)
+public:
+ /* Get parent object that owns this object. */
+ shared_ptr<Parent> parent()
{
+ return _parent;
}
};
/* Base template for classes whose resources are owned by the user. */
-template <class Class, typename Struct>
+template <class Class>
class SR_API UserOwned : public enable_shared_from_this<Class>
{
-public:
+protected:
+ UserOwned() {}
+
shared_ptr<Class> shared_from_this()
{
auto shared = enable_shared_from_this<Class>::shared_from_this();
throw Error(SR_ERR_BUG);
return shared;
}
-protected:
- Struct *_structure;
-
- UserOwned<Class, Struct>(Struct *structure) :
- _structure(structure)
- {
- }
-
- /* Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Class *object) { delete object; }
- };
};
/** Type of log callback */
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);
+ const char *name, void *cb_data) noexcept;
static SR_PRIV int close_callback(struct sr_resource *res,
- void *cb_data);
- static SR_PRIV ssize_t read_callback(const struct sr_resource *res,
- void *buf, size_t count, void *cb_data);
+ void *cb_data) noexcept;
+ static SR_PRIV gssize 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>
+class SR_API Context : public UserOwned<Context>
{
public:
/** 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. */
map<string, shared_ptr<InputFormat> > input_formats();
+ /** Lookup the responsible input module for an input file. */
+ shared_ptr<InputFormat> input_format_match(string filename);
/** 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);
/** Create an analog packet. */
shared_ptr<Packet> create_analog_packet(
vector<shared_ptr<Channel> > channels,
- float *data_pointer, unsigned int num_samples, const Quantity *mq,
+ const float *data_pointer, unsigned int num_samples, const Quantity *mq,
const Unit *unit, vector<const QuantityFlag *> mqflags);
+ /** Create an end packet. */
+ shared_ptr<Packet> create_end_packet();
/** 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);
-protected:
- map<string, Driver *> _drivers;
- map<string, InputFormat *> _input_formats;
- map<string, OutputFormat *> _output_formats;
+ map<string, string> serials(shared_ptr<Driver> driver) const;
+private:
+ struct sr_context *_structure;
+ map<string, unique_ptr<Driver> > _drivers;
+ map<string, unique_ptr<InputFormat> > _input_formats;
+ map<string, unique_ptr<OutputFormat> > _output_formats;
Session *_session;
LogCallbackFunction _log_callback;
Context();
~Context();
- friend class Deleter;
friend class Session;
friend class Driver;
-};
-
-enum Capability {
- GET = SR_CONF_GET,
- SET = SR_CONF_SET,
- LIST = SR_CONF_LIST
+ friend struct std::default_delete<Context>;
};
/** An object that can be configured. */
class SR_API Configurable
{
public:
+ /** Supported configuration keys. */
+ set<const ConfigKey *> config_keys() const;
/** 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);
- /** 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);
+ Glib::VariantContainerBase config_list(const ConfigKey *key) const;
+ /** Enumerate configuration capabilities for the given configuration key.
+ * @param key ConfigKey to enumerate capabilities for. */
+ set<const Capability *> config_capabilities(const ConfigKey *key) const;
+ /** Check whether a configuration capability is supported for a given key.
+ * @param key ConfigKey to check.
+ * @param capability Capability to check for. */
+ bool config_check(const ConfigKey *key, const Capability *capability) const;
protected:
Configurable(
struct sr_dev_driver *driver,
};
/** A hardware driver provided by the library */
-class SR_API Driver :
- public ParentOwned<Driver, Context, struct sr_dev_driver>,
- public Configurable
+class SR_API Driver : public ParentOwned<Driver, Context>, public Configurable
{
public:
/** Name of this driver. */
- string name();
+ string name() const;
/** Long name for this driver. */
- string long_name();
+ string long_name() const;
+ /** Scan options supported by this driver. */
+ set<const ConfigKey *> scan_options() 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>());
-protected:
+ vector<shared_ptr<HardwareDevice> > scan(map<const ConfigKey *, Glib::VariantBase>
+ options = map<const ConfigKey *, Glib::VariantBase>());
+private:
+ struct sr_dev_driver *_structure;
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;
friend class ChannelGroup;
+ friend struct std::default_delete<Driver>;
};
/** A generic device, either hardware or virtual */
{
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);
+
struct sr_dev_inst *_structure;
- map<struct sr_channel *, Channel *> _channels;
- map<string, ChannelGroup *> _channel_groups;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Device *device) { delete device; }
- };
- friend class Deleter;
+ map<struct sr_channel *, unique_ptr<Channel> > _channels;
+private:
+ map<string, unique_ptr<ChannelGroup> > _channel_groups;
+
friend class Session;
friend class Channel;
friend class ChannelGroup;
friend class Output;
friend class Analog;
+ friend struct std::default_delete<Device>;
};
/** A real hardware device, connected via a driver */
class SR_API HardwareDevice :
- public UserOwned<HardwareDevice, struct sr_dev_inst>,
+ public UserOwned<HardwareDevice>,
public Device
{
public:
/** Driver providing this device. */
shared_ptr<Driver> driver();
-protected:
+private:
HardwareDevice(shared_ptr<Driver> driver, struct sr_dev_inst *structure);
~HardwareDevice();
shared_ptr<Device> get_shared_from_this();
shared_ptr<Driver> _driver;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(HardwareDevice *device) { delete device; }
- };
- friend class Deleter;
+
friend class Driver;
friend class ChannelGroup;
+ friend struct std::default_delete<HardwareDevice>;
};
/** A virtual device, created by the user */
class SR_API UserDevice :
- public UserOwned<UserDevice, struct sr_dev_inst>,
+ public UserOwned<UserDevice>,
public Device
{
public:
/** Add a new channel to this device. */
shared_ptr<Channel> add_channel(unsigned int index, const ChannelType *type, string name);
-protected:
+private:
UserDevice(string vendor, string model, string version);
~UserDevice();
shared_ptr<Device> get_shared_from_this();
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(UserDevice *device) { delete device; }
- };
+
friend class Context;
- friend class Deleter;
+ friend struct std::default_delete<UserDevice>;
};
/** A channel on a device */
class SR_API Channel :
- public ParentOwned<Channel, Device, struct sr_channel>
+ public ParentOwned<Channel, Device>
{
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();
-protected:
- Channel(struct sr_channel *structure);
+ unsigned int index() const;
+private:
+ explicit Channel(struct sr_channel *structure);
~Channel();
+ struct sr_channel *_structure;
const ChannelType * const _type;
friend class Device;
friend class UserDevice;
friend class Session;
friend class TriggerStage;
friend class Context;
+ friend struct std::default_delete<Channel>;
};
/** A group of channels on a device, which share some configuration */
class SR_API ChannelGroup :
- public ParentOwned<ChannelGroup, Device, struct sr_channel_group>,
+ public ParentOwned<ChannelGroup, Device>,
public Configurable
{
public:
/** Name of this channel group. */
- string name();
+ string name() const;
/** List of the channels in this group. */
vector<shared_ptr<Channel> > channels();
-protected:
- ChannelGroup(Device *device, struct sr_channel_group *structure);
+private:
+ ChannelGroup(const Device *device, struct sr_channel_group *structure);
~ChannelGroup();
vector<Channel *> _channels;
friend class Device;
+ friend struct std::default_delete<ChannelGroup>;
};
/** A trigger configuration */
-class SR_API Trigger : public UserOwned<Trigger, struct sr_trigger>
+class SR_API Trigger : public UserOwned<Trigger>
{
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. */
shared_ptr<TriggerStage> add_stage();
-protected:
+private:
Trigger(shared_ptr<Context> context, string name);
~Trigger();
+ struct sr_trigger *_structure;
shared_ptr<Context> _context;
- vector<TriggerStage *> _stages;
- friend class Deleter;
+ vector<unique_ptr<TriggerStage> > _stages;
friend class Context;
friend class Session;
+ friend struct std::default_delete<Trigger>;
};
/** A stage in a trigger configuration */
class SR_API TriggerStage :
- public ParentOwned<TriggerStage, Trigger, struct sr_trigger_stage>
+ public ParentOwned<TriggerStage, 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.
* @param type TriggerMatchType to apply.
* @param value Threshold value. */
void add_match(shared_ptr<Channel> channel, const TriggerMatchType *type, float value);
-protected:
- vector<TriggerMatch *> _matches;
- TriggerStage(struct sr_trigger_stage *structure);
+private:
+ struct sr_trigger_stage *_structure;
+ vector<unique_ptr<TriggerMatch> > _matches;
+ explicit TriggerStage(struct sr_trigger_stage *structure);
~TriggerStage();
friend class Trigger;
+ friend struct std::default_delete<TriggerStage>;
};
/** A match condition in a trigger configuration */
class SR_API TriggerMatch :
- public ParentOwned<TriggerMatch, TriggerStage, struct sr_trigger_match>
+ public ParentOwned<TriggerMatch, TriggerStage>
{
public:
/** Channel this condition matches on. */
shared_ptr<Channel> channel();
/** Type of match. */
- const TriggerMatchType *type();
+ const TriggerMatchType *type() const;
/** Threshold value. */
- float value();
-protected:
+ float value() const;
+private:
TriggerMatch(struct sr_trigger_match *structure, shared_ptr<Channel> channel);
~TriggerMatch();
+ struct sr_trigger_match *_structure;
shared_ptr<Channel> _channel;
friend class TriggerStage;
+ friend struct std::default_delete<TriggerMatch>;
};
+/** Type of session stopped callback */
+typedef function<void()> SessionStoppedCallback;
+
/** Type of datafeed callback */
typedef function<void(shared_ptr<Device>, shared_ptr<Packet>)>
DatafeedCallbackFunction;
public:
void run(const struct sr_dev_inst *sdi,
const struct sr_datafeed_packet *pkt);
-protected:
+private:
DatafeedCallbackFunction _callback;
DatafeedCallbackData(Session *session,
DatafeedCallbackFunction callback);
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 ParentOwned<SessionDevice, Session>,
public Device
{
-protected:
- SessionDevice(struct sr_dev_inst *sdi);
+private:
+ 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. */
- class Deleter
- {
- public:
- void operator()(SessionDevice *device) { delete device; }
- };
- friend class Deleter;
+
friend class Session;
+ friend struct std::default_delete<SessionDevice>;
};
/** A sigrok session */
-class SR_API Session : public UserOwned<Session, struct sr_session>
+class SR_API Session : public UserOwned<Session>
{
public:
/** Add a device to this session.
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();
+ /** 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();
-protected:
- Session(shared_ptr<Context> context);
+ string filename() const;
+private:
+ 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);
+ struct sr_session *_structure;
const shared_ptr<Context> _context;
- map<const struct sr_dev_inst *, SessionDevice *> _owned_devices;
+ map<const struct sr_dev_inst *, unique_ptr<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;
+ vector<unique_ptr<DatafeedCallbackData> > _datafeed_callbacks;
+ SessionStoppedCallback _stopped_callback;
string _filename;
shared_ptr<Trigger> _trigger;
- friend class Deleter;
+
friend class Context;
friend class DatafeedCallbackData;
friend class SessionDevice;
+ friend struct std::default_delete<Session>;
};
/** A packet on the session datafeed */
-class SR_API Packet : public UserOwned<Packet, const struct sr_datafeed_packet>
+class SR_API Packet : public UserOwned<Packet>
{
public:
/** Type of this packet. */
- const PacketType *type();
+ const PacketType *type() const;
/** Payload of this packet. */
shared_ptr<PacketPayload> payload();
-protected:
+private:
Packet(shared_ptr<Device> device,
const struct sr_datafeed_packet *structure);
~Packet();
+ const struct sr_datafeed_packet *_structure;
shared_ptr<Device> _device;
- PacketPayload *_payload;
- friend class Deleter;
+ unique_ptr<PacketPayload> _payload;
+
friend class Session;
friend class Output;
friend class DatafeedCallbackData;
friend class Logic;
friend class Analog;
friend class Context;
+ friend struct std::default_delete<Packet>;
};
/** Abstract base class for datafeed packet payloads */
protected:
PacketPayload();
virtual ~PacketPayload() = 0;
- virtual shared_ptr<PacketPayload> get_shared_pointer(Packet *parent) = 0;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(PacketPayload *payload) { delete payload; }
- };
- friend class Deleter;
+private:
+ virtual shared_ptr<PacketPayload> share_owned_by(shared_ptr<Packet> parent) = 0;
+
friend class Packet;
friend class Output;
+ friend struct std::default_delete<PacketPayload>;
};
/** Payload of a datafeed header packet */
class SR_API Header :
- public ParentOwned<Header, Packet, const struct sr_datafeed_header>,
+ public ParentOwned<Header, Packet>,
public PacketPayload
{
public:
/* Feed version number. */
- int feed_version();
+ int feed_version() const;
/* Start time of this session. */
- Glib::TimeVal start_time();
-protected:
- Header(const struct sr_datafeed_header *structure);
+ Glib::TimeVal start_time() const;
+private:
+ explicit Header(const struct sr_datafeed_header *structure);
~Header();
- shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
+ shared_ptr<PacketPayload> share_owned_by(shared_ptr<Packet> parent);
+
+ const struct sr_datafeed_header *_structure;
+
friend class Packet;
};
/** Payload of a datafeed metadata packet */
class SR_API Meta :
- public ParentOwned<Meta, Packet, const struct sr_datafeed_meta>,
+ public ParentOwned<Meta, Packet>,
public PacketPayload
{
public:
/* Mapping of (ConfigKey, value) pairs. */
- map<const ConfigKey *, Glib::VariantBase> config();
-protected:
- Meta(const struct sr_datafeed_meta *structure);
+ map<const ConfigKey *, Glib::VariantBase> config() const;
+private:
+ explicit Meta(const struct sr_datafeed_meta *structure);
~Meta();
- shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
+ shared_ptr<PacketPayload> share_owned_by(shared_ptr<Packet> parent);
+
+ const struct sr_datafeed_meta *_structure;
map<const ConfigKey *, Glib::VariantBase> _config;
+
friend class Packet;
};
/** Payload of a datafeed packet with logic data */
class SR_API Logic :
- public ParentOwned<Logic, Packet, const struct sr_datafeed_logic>,
+ public ParentOwned<Logic, Packet>,
public PacketPayload
{
public:
/* 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();
-protected:
- Logic(const struct sr_datafeed_logic *structure);
+ unsigned int unit_size() const;
+private:
+ explicit Logic(const struct sr_datafeed_logic *structure);
~Logic();
- shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
+ shared_ptr<PacketPayload> share_owned_by(shared_ptr<Packet> parent);
+
+ const struct sr_datafeed_logic *_structure;
+
friend class Packet;
+ friend class Analog;
+ friend struct std::default_delete<Logic>;
};
/** Payload of a datafeed packet with analog data */
class SR_API Analog :
- public ParentOwned<Analog, Packet, const struct sr_datafeed_analog>,
+ public ParentOwned<Analog, Packet>,
public PacketPayload
{
public:
/** Pointer to data. */
- float *data_pointer();
+ void *data_pointer();
+ /**
+ * Fills dest pointer with the analog data converted to float.
+ * The pointer must have space for num_samples() floats.
+ */
+ void get_data_as_float(float *dest);
/** 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();
+ /** Size of a single sample in bytes. */
+ unsigned int unitsize() const;
+ /** Samples use a signed data type. */
+ bool is_signed() const;
+ /** Samples use float. */
+ bool is_float() const;
+ /** Samples are stored in big-endian order. */
+ bool is_bigendian() const;
+ /**
+ * Number of significant digits after the decimal point if positive,
+ * or number of non-significant digits before the decimal point if negative
+ * (refers to the value we actually read on the wire).
+ */
+ int digits() const;
+ /** TBD */
+ bool is_digits_decimal() const;
+ /** TBD */
+ shared_ptr<Rational> scale();
+ /** TBD */
+ shared_ptr<Rational> offset();
/** 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();
-protected:
- Analog(const struct sr_datafeed_analog *structure);
+ vector<const QuantityFlag *> mq_flags() const;
+ /**
+ * Provides a Logic packet that contains a conversion of the analog
+ * data using a simple threshold.
+ *
+ * @param threshold Threshold to use.
+ * @param data_ptr Pointer to num_samples() bytes where the logic
+ * samples are stored. When nullptr, memory for
+ * logic->data_pointer() will be allocated and must
+ * be freed by the caller.
+ */
+ shared_ptr<Logic> get_logic_via_threshold(float threshold,
+ uint8_t *data_ptr=nullptr) const;
+ /**
+ * Provides a Logic packet that contains a conversion of the analog
+ * data using a Schmitt-Trigger.
+ *
+ * @param lo_thr Low threshold to use (anything below this is low).
+ * @param hi_thr High threshold to use (anything above this is high).
+ * @param state Points to a byte that contains the current state of the
+ * converter. For best results, set to value of logic
+ * sample n-1.
+ * @param data_ptr Pointer to num_samples() bytes where the logic
+ * samples are stored. When nullptr, memory for
+ * logic->data_pointer() will be allocated and must be
+ * freed by the caller.
+ */
+ shared_ptr<Logic> get_logic_via_schmitt_trigger(float lo_thr,
+ float hi_thr, uint8_t *state, uint8_t *data_ptr=nullptr) const;
+private:
+ explicit Analog(const struct sr_datafeed_analog *structure);
~Analog();
- shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
+ shared_ptr<PacketPayload> share_owned_by(shared_ptr<Packet> parent);
+
+ const struct sr_datafeed_analog *_structure;
+
friend class Packet;
};
+/** Number represented by a numerator/denominator integer pair */
+class SR_API Rational :
+ public ParentOwned<Rational, Analog>
+{
+public:
+ /** Numerator, i.e. the dividend. */
+ int64_t numerator() const;
+ /** Denominator, i.e. the divider. */
+ uint64_t denominator() const;
+ /** Actual (lossy) value. */
+ float value() const;
+private:
+ explicit Rational(const struct sr_rational *structure);
+ ~Rational();
+ shared_ptr<Rational> share_owned_by(shared_ptr<Analog> parent);
+
+ const struct sr_rational *_structure;
+
+ friend class Analog;
+ friend struct std::default_delete<Rational>;
+};
+
/** An input format supported by the library */
class SR_API InputFormat :
- public ParentOwned<InputFormat, Context, const struct sr_input_module>
+ public ParentOwned<InputFormat, Context>
{
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();
+ * @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>());
-protected:
- InputFormat(const struct sr_input_module *structure);
+ shared_ptr<Input> create_input(map<string, Glib::VariantBase>
+ options = map<string, Glib::VariantBase>());
+private:
+ explicit InputFormat(const struct sr_input_module *structure);
~InputFormat();
+
+ const struct sr_input_module *_structure;
+
friend class Context;
friend class InputDevice;
+ friend struct std::default_delete<InputFormat>;
};
/** An input instance (an input format applied to a file or stream) */
-class SR_API Input : public UserOwned<Input, const struct sr_input>
+class SR_API Input : public UserOwned<Input>
{
public:
/** Virtual device associated with this input. */
void send(void *data, size_t length);
/** Signal end of input data. */
void end();
-protected:
+ void reset();
+private:
Input(shared_ptr<Context> context, const struct sr_input *structure);
~Input();
+ const struct sr_input *_structure;
shared_ptr<Context> _context;
- InputDevice *_device;
- friend class Deleter;
+ unique_ptr<InputDevice> _device;
+
friend class Context;
friend class InputFormat;
+ friend struct std::default_delete<Input>;
};
/** A virtual device associated with an input */
class SR_API InputDevice :
- public ParentOwned<InputDevice, Input, struct sr_dev_inst>,
+ public ParentOwned<InputDevice, Input>,
public Device
{
-protected:
+private:
InputDevice(shared_ptr<Input> input, struct sr_dev_inst *sdi);
~InputDevice();
shared_ptr<Device> get_shared_from_this();
shared_ptr<Input> _input;
friend class Input;
+ friend struct std::default_delete<InputDevice>;
};
/** An option used by an output format */
-class SR_API Option : public UserOwned<Option, const struct sr_option>
+class SR_API Option : public UserOwned<Option>
{
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();
-protected:
+ vector<Glib::VariantBase> values() const;
+ /** Parse a string argument into the appropriate type for this option. */
+ Glib::VariantBase parse_string(string value);
+private:
Option(const struct sr_option *structure,
shared_ptr<const struct sr_option *> structure_array);
~Option();
+ const struct sr_option *_structure;
shared_ptr<const struct sr_option *> _structure_array;
- friend class Deleter;
+
friend class InputFormat;
friend class OutputFormat;
+ friend struct std::default_delete<Option>;
};
/** An output format supported by the library */
class SR_API OutputFormat :
- public ParentOwned<OutputFormat, Context, const struct sr_output_module>
+ public ParentOwned<OutputFormat, Context>
{
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();
+ * @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>());
+ shared_ptr<Output> create_output(shared_ptr<Device> device,
+ map<string, Glib::VariantBase> options = map<string, Glib::VariantBase>());
/** 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,
- map<string, Glib::VariantBase> options =
- map<string, Glib::VariantBase>());
+ map<string, Glib::VariantBase> options = map<string, Glib::VariantBase>());
/**
* 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);
-protected:
- OutputFormat(const struct sr_output_module *structure);
+ bool test_flag(const OutputFlag *flag) const;
+private:
+ explicit OutputFormat(const struct sr_output_module *structure);
~OutputFormat();
+
+ const struct sr_output_module *_structure;
+
friend class Context;
friend class Output;
+ friend struct std::default_delete<OutputFormat>;
};
/** An output instance (an output format applied to a device) */
-class SR_API Output : public UserOwned<Output, const struct sr_output>
+class SR_API Output : public UserOwned<Output>
{
public:
/** Update output with data from the given packet.
* @param packet Packet to handle. */
string receive(shared_ptr<Packet> packet);
-protected:
+ /** Output format in use for this output */
+ shared_ptr<OutputFormat> format();
+private:
Output(shared_ptr<OutputFormat> format, shared_ptr<Device> device);
Output(shared_ptr<OutputFormat> format,
shared_ptr<Device> device, map<string, Glib::VariantBase> options);
Output(string filename, shared_ptr<OutputFormat> format,
shared_ptr<Device> device, map<string, Glib::VariantBase> options);
~Output();
+
+ const struct sr_output *_structure;
const shared_ptr<OutputFormat> _format;
const shared_ptr<Device> _device;
const map<string, Glib::VariantBase> _options;
- friend class Deleter;
+
friend class OutputFormat;
+ friend struct std::default_delete<Output>;
};
/** Base class for objects which wrap an enumeration value from libsigrok */
/** 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()
~EnumValue()
{
}
+private:
static const std::map<const Enum, const Class * const> _values;
const Enum _id;
const string _name;
};
-#include <libsigrokcxx/enums.hpp>
-
}
+#include <libsigrokcxx/enums.hpp>
+
#endif
projects / libsigrok.git / blobdiff