#include <memory>
#include <vector>
#include <map>
+#include <set>
namespace sigrok
{
class SR_API Output;
class SR_API DataType;
class SR_API Option;
+class SR_API UserDevice;
/** Exception thrown when an error code is returned by any libsigrok call. */
class SR_API Error: public exception
const char *what() const throw();
};
-/* Base template for most classes which wrap a struct type from libsigrok. */
-template <class Parent, typename Struct> class SR_API StructureWrapper :
- public enable_shared_from_this<StructureWrapper<Parent, Struct> >
+/* Base template for classes whose resources are owned by a parent object. */
+template <class Class, class Parent, typename Struct>
+class SR_API ParentOwned
{
protected:
/* Parent object which owns this child object's underlying structure.
This strategy ensures that the destructors for both the child and
the parent are called at the correct time, i.e. only when all
references to both the parent and all its children are gone. */
- shared_ptr<Parent> parent;
+ shared_ptr<Parent> _parent;
+
+ /* Weak pointer for shared_from_this() implementation. */
+ weak_ptr<Class> _weak_this;
public:
- shared_ptr<StructureWrapper<Parent, Struct> >
- get_shared_pointer(Parent *parent)
+ /* Get parent object that owns this object. */
+ shared_ptr<Parent> parent()
+ {
+ return _parent;
+ }
+
+ /* Note, this implementation will create a new smart_ptr if none exists. */
+ shared_ptr<Class> shared_from_this()
+ {
+ shared_ptr<Class> shared;
+
+ if (!(shared = _weak_this.lock()))
+ {
+ shared = shared_ptr<Class>((Class *) this, reset_parent);
+ _weak_this = shared;
+ }
+
+ return shared;
+ }
+
+ shared_ptr<Class> get_shared_pointer(shared_ptr<Parent> parent)
{
- this->parent = static_pointer_cast<Parent>(parent->shared_from_this());
- return shared_ptr<StructureWrapper<Parent, Struct> >(
- this, reset_parent);
+ if (!parent)
+ throw Error(SR_ERR_BUG);
+ this->_parent = parent;
+ return shared_from_this();
}
- shared_ptr<StructureWrapper<Parent, Struct> >
- get_shared_pointer(shared_ptr<Parent> parent)
+
+ shared_ptr<Class> get_shared_pointer(Parent *parent)
{
- this->parent = parent;
- return shared_ptr<StructureWrapper<Parent, Struct> >(
- this, reset_parent);
+ if (!parent)
+ throw Error(SR_ERR_BUG);
+ return get_shared_pointer(parent->shared_from_this());
}
protected:
- static void reset_parent(StructureWrapper<Parent, Struct> *object)
+ static void reset_parent(Class *object)
{
- object->parent.reset();
+ if (!object->_parent)
+ throw Error(SR_ERR_BUG);
+ object->_parent.reset();
}
- Struct *structure;
+ Struct *_structure;
- StructureWrapper<Parent, Struct>(Struct *structure) :
- structure(structure)
+ ParentOwned<Class, Parent, Struct>(Struct *structure) :
+ _structure(structure)
{
}
};
+/* Base template for classes whose resources are owned by the user. */
+template <class Class, typename Struct>
+class SR_API UserOwned : public enable_shared_from_this<Class>
+{
+public:
+ shared_ptr<Class> shared_from_this()
+ {
+ auto shared = enable_shared_from_this<Class>::shared_from_this();
+ if (!shared)
+ 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 */
typedef function<void(const LogLevel *, string message)> LogCallbackFunction;
/** The global libsigrok context */
-class SR_API Context : public enable_shared_from_this<Context>
+class SR_API Context : public UserOwned<Context, struct sr_context>
{
public:
/** Create new context */
static shared_ptr<Context> create();
/** libsigrok package version. */
- string get_package_version();
+ string package_version();
/** libsigrok library version. */
- string get_lib_version();
+ string lib_version();
/** Available hardware drivers, indexed by name. */
- map<string, shared_ptr<Driver> > get_drivers();
+ map<string, shared_ptr<Driver> > drivers();
/** Available input formats, indexed by name. */
- map<string, shared_ptr<InputFormat> > get_input_formats();
+ map<string, shared_ptr<InputFormat> > input_formats();
/** Available output formats, indexed by name. */
- map<string, shared_ptr<OutputFormat> > get_output_formats();
+ map<string, shared_ptr<OutputFormat> > output_formats();
/** Current log level. */
- const LogLevel *get_log_level();
+ const LogLevel *log_level();
/** Set the log level.
* @param level LogLevel to use. */
void set_log_level(const LogLevel *level);
/** Current log domain. */
- string get_log_domain();
+ string log_domain();
/** Set the log domain.
* @param value Log domain prefix string. */
void set_log_domain(string value);
void set_log_callback_default();
/** Create a new session. */
shared_ptr<Session> create_session();
+ /** Create a new user device. */
+ shared_ptr<UserDevice> create_user_device(
+ string vendor, string model, string version);
+ /** Create a header packet. */
+ 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);
+ /** 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,
+ float *data_pointer, unsigned int num_samples, const Quantity *mq,
+ const Unit *unit, vector<const QuantityFlag *> mqflags);
/** Load a saved session.
* @param filename File name string. */
shared_ptr<Session> load_session(string filename);
* @param header Initial data from stream. */
shared_ptr<Input> open_stream(string header);
protected:
- struct sr_context *structure;
- map<string, Driver *> drivers;
- map<string, InputFormat *> input_formats;
- map<string, OutputFormat *> output_formats;
- Session *session;
- LogCallbackFunction log_callback;
+ map<string, Driver *> _drivers;
+ map<string, InputFormat *> _input_formats;
+ map<string, OutputFormat *> _output_formats;
+ Session *_session;
+ LogCallbackFunction _log_callback;
Context();
~Context();
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Context *context) { delete context; }
- };
friend class Deleter;
friend class Session;
friend class Driver;
};
-/** A hardware driver provided by the library */
-class SR_API Driver : public StructureWrapper<Context, struct sr_dev_driver>
-{
-public:
- /** Name of this driver. */
- string get_name();
- /** Long name for this driver. */
- string get_long_name();
- /** 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 = {});
-protected:
- bool initialized;
- vector<HardwareDevice *> devices;
- Driver(struct sr_dev_driver *structure);
- ~Driver();
- friend class Context;
- friend class HardwareDevice;
- friend class ChannelGroup;
+enum Capability {
+ GET = SR_CONF_GET,
+ SET = SR_CONF_SET,
+ LIST = SR_CONF_LIST
};
/** An object that can be configured. */
/** 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);
protected:
Configurable(
struct sr_dev_driver *driver,
struct sr_channel_group *config_channel_group;
};
+/** A hardware driver provided by the library */
+class SR_API Driver :
+ public ParentOwned<Driver, Context, struct sr_dev_driver>,
+ public Configurable
+{
+public:
+ /** Name of this driver. */
+ string name();
+ /** Long name for this driver. */
+ string long_name();
+ /** 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:
+ bool _initialized;
+ vector<HardwareDevice *> _devices;
+ Driver(struct sr_dev_driver *structure);
+ ~Driver();
+ friend class Context;
+ friend class HardwareDevice;
+ friend class ChannelGroup;
+};
+
/** A generic device, either hardware or virtual */
class SR_API Device : public Configurable
{
public:
- /** Description identifying this device. */
- string get_description();
/** Vendor name for this device. */
- string get_vendor();
+ string vendor();
/** Model name for this device. */
- string get_model();
+ string model();
/** Version string for this device. */
- string get_version();
+ string version();
+ /** Serial number for this device. */
+ string serial_number();
+ /** Connection ID for this device. */
+ string connection_id();
/** List of the channels available on this device. */
- vector<shared_ptr<Channel> > get_channels();
+ vector<shared_ptr<Channel> > channels();
/** Channel groups available on this device, indexed by name. */
- map<string, shared_ptr<ChannelGroup> > get_channel_groups();
+ map<string, shared_ptr<ChannelGroup> > channel_groups();
/** Open device. */
void open();
/** Close device. */
~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;
+ 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
{
/** A real hardware device, connected via a driver */
class SR_API HardwareDevice :
- public StructureWrapper<Context, struct sr_dev_inst>,
+ public UserOwned<HardwareDevice, struct sr_dev_inst>,
public Device
{
public:
/** Driver providing this device. */
- shared_ptr<Driver> get_driver();
+ shared_ptr<Driver> driver();
protected:
- HardwareDevice(Driver *driver, struct sr_dev_inst *structure);
+ HardwareDevice(shared_ptr<Driver> driver, struct sr_dev_inst *structure);
~HardwareDevice();
shared_ptr<Device> get_shared_from_this();
- Driver *driver;
+ 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;
};
+/** A virtual device, created by the user */
+class SR_API UserDevice :
+ public UserOwned<UserDevice, struct sr_dev_inst>,
+ public Device
+{
+public:
+ /** Add a new channel to this device. */
+ shared_ptr<Channel> add_channel(unsigned int index, const ChannelType *type, string name);
+protected:
+ 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;
+};
+
/** A channel on a device */
-class SR_API Channel : public StructureWrapper<Device, struct sr_channel>
+class SR_API Channel :
+ public ParentOwned<Channel, Device, struct sr_channel>
{
public:
/** Current name of this channel. */
- string get_name();
+ string name();
/** Set the name of this channel. *
* @param name Name string to set. */
void set_name(string name);
/** Type of this channel. */
- const ChannelType *get_type();
+ const ChannelType *type();
/** Enabled status of this channel. */
- bool get_enabled();
+ bool enabled();
/** 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 get_index();
+ unsigned int index();
protected:
Channel(struct sr_channel *structure);
~Channel();
- const ChannelType * const type;
+ const ChannelType * const _type;
friend class Device;
+ friend class UserDevice;
friend class ChannelGroup;
friend class Session;
friend class TriggerStage;
+ friend class Context;
};
/** A group of channels on a device, which share some configuration */
class SR_API ChannelGroup :
- public StructureWrapper<Device, struct sr_channel_group>,
+ public ParentOwned<ChannelGroup, Device, struct sr_channel_group>,
public Configurable
{
public:
/** Name of this channel group. */
- string get_name();
+ string name();
/** List of the channels in this group. */
- vector<shared_ptr<Channel> > get_channels();
+ vector<shared_ptr<Channel> > channels();
protected:
ChannelGroup(Device *device, struct sr_channel_group *structure);
~ChannelGroup();
- vector<Channel *> channels;
+ vector<Channel *> _channels;
friend class Device;
};
/** A trigger configuration */
-class SR_API Trigger : public enable_shared_from_this<Trigger>
+class SR_API Trigger : public UserOwned<Trigger, struct sr_trigger>
{
public:
/** Name of this trigger configuration. */
- string get_name();
+ string name();
/** List of the stages in this trigger. */
- vector<shared_ptr<TriggerStage> > get_stages();
+ vector<shared_ptr<TriggerStage> > stages();
/** Add a new stage to this trigger. */
shared_ptr<TriggerStage> add_stage();
protected:
Trigger(shared_ptr<Context> context, string name);
~Trigger();
- struct sr_trigger *structure;
- shared_ptr<Context> context;
- vector<TriggerStage *> stages;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Trigger *trigger) { delete trigger; }
- };
+ shared_ptr<Context> _context;
+ vector<TriggerStage *> _stages;
+ friend class Deleter;
friend class Context;
friend class Session;
};
/** A stage in a trigger configuration */
-class SR_API TriggerStage : public StructureWrapper<Trigger, struct sr_trigger_stage>
+class SR_API TriggerStage :
+ public ParentOwned<TriggerStage, Trigger, struct sr_trigger_stage>
{
public:
/** Index number of this stage. */
- int get_number();
+ int number();
/** List of match conditions on this stage. */
- vector<shared_ptr<TriggerMatch> > get_matches();
+ vector<shared_ptr<TriggerMatch> > matches();
/** Add a new match condition to this stage.
* @param channel Channel to match on.
* @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;
+ vector<TriggerMatch *> _matches;
TriggerStage(struct sr_trigger_stage *structure);
~TriggerStage();
friend class Trigger;
};
/** A match condition in a trigger configuration */
-class SR_API TriggerMatch : public StructureWrapper<TriggerStage, struct sr_trigger_match>
+class SR_API TriggerMatch :
+ public ParentOwned<TriggerMatch, TriggerStage, struct sr_trigger_match>
{
public:
/** Channel this condition matches on. */
- shared_ptr<Channel> get_channel();
+ shared_ptr<Channel> channel();
/** Type of match. */
- const TriggerMatchType *get_type();
+ const TriggerMatchType *type();
/** Threshold value. */
- float get_value();
+ float value();
protected:
TriggerMatch(struct sr_trigger_match *structure, shared_ptr<Channel> channel);
~TriggerMatch();
- shared_ptr<Channel> channel;
+ shared_ptr<Channel> _channel;
friend class TriggerStage;
};
void run(const struct sr_dev_inst *sdi,
const struct sr_datafeed_packet *pkt);
protected:
- DatafeedCallbackFunction callback;
+ DatafeedCallbackFunction _callback;
DatafeedCallbackData(Session *session,
DatafeedCallbackFunction callback);
- Session *session;
+ Session *_session;
friend class Session;
};
bool run(int revents);
protected:
SourceCallbackData(shared_ptr<EventSource> source);
- shared_ptr<EventSource> source;
+ shared_ptr<EventSource> _source;
friend class Session;
};
SOURCE_FD,
SOURCE_POLLFD,
SOURCE_IOCHANNEL
- } type;
- int fd;
- Glib::PollFD pollfd;
- Glib::RefPtr<Glib::IOChannel> channel;
- Glib::IOCondition events;
- int timeout;
- SourceCallbackFunction callback;
+ } _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
{
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);
+ ~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;
+};
+
/** A sigrok session */
-class SR_API Session
+class SR_API Session : public UserOwned<Session, struct sr_session>
{
public:
/** Add a device to this session.
* @param device Device to add. */
void add_device(shared_ptr<Device> device);
/** List devices attached to this session. */
- vector<shared_ptr<Device> > get_devices();
+ vector<shared_ptr<Device> > devices();
/** Remove all devices from this session. */
void remove_devices();
/** Add a datafeed callback to this session.
/** Append raw logic data to the session file being saved. */
void append(void *data, size_t length, unsigned int unit_size);
/** Get current trigger setting. */
- shared_ptr<Trigger> get_trigger();
+ shared_ptr<Trigger> trigger();
/** Set trigger setting.
* @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);
Session(shared_ptr<Context> context, string filename);
~Session();
- struct sr_session *structure;
- const shared_ptr<Context> context;
- map<const struct sr_dev_inst *, shared_ptr<Device> > devices;
- vector<DatafeedCallbackData *> datafeed_callbacks;
- map<shared_ptr<EventSource>, SourceCallbackData *> source_callbacks;
- bool saving;
- bool save_initialized;
- string save_filename;
- uint64_t save_samplerate;
- shared_ptr<Trigger> trigger;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Session *session) { delete session; }
- };
+ shared_ptr<Device> get_device(const struct sr_dev_inst *sdi);
+ const shared_ptr<Context> _context;
+ 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;
+ string _filename;
+ bool _saving;
+ bool _save_initialized;
+ string _save_filename;
+ uint64_t _save_samplerate;
+ shared_ptr<Trigger> _trigger;
friend class Deleter;
friend class Context;
friend class DatafeedCallbackData;
+ friend class SessionDevice;
};
/** A packet on the session datafeed */
-class SR_API Packet : public enable_shared_from_this<Packet>
+class SR_API Packet : public UserOwned<Packet, const struct sr_datafeed_packet>
{
public:
/** Type of this packet. */
- const PacketType *get_type();
+ const PacketType *type();
/** Payload of this packet. */
- shared_ptr<PacketPayload> get_payload();
+ shared_ptr<PacketPayload> payload();
protected:
Packet(shared_ptr<Device> device,
const struct sr_datafeed_packet *structure);
~Packet();
- const struct sr_datafeed_packet *structure;
- shared_ptr<Device> device;
- PacketPayload *payload;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Packet *packet) { delete packet; }
- };
+ shared_ptr<Device> _device;
+ PacketPayload *_payload;
friend class Deleter;
friend class Session;
friend class Output;
friend class Meta;
friend class Logic;
friend class Analog;
+ friend class Context;
};
/** Abstract base class for datafeed packet payloads */
protected:
PacketPayload();
virtual ~PacketPayload() = 0;
- shared_ptr<PacketPayload> get_shared_pointer(Packet *parent) {
- return static_pointer_cast<PacketPayload>(get_shared_pointer(parent));
- }
+ virtual shared_ptr<PacketPayload> get_shared_pointer(Packet *parent) = 0;
/** Deleter needed to allow shared_ptr use with protected destructor. */
class Deleter
{
};
/** Payload of a datafeed header packet */
-class SR_API Header : public PacketPayload,
- public StructureWrapper<Packet, const struct sr_datafeed_header>
+class SR_API Header :
+ public ParentOwned<Header, Packet, const struct sr_datafeed_header>,
+ public PacketPayload
{
public:
/* Feed version number. */
- int get_feed_version();
+ int feed_version();
/* Start time of this session. */
- Glib::TimeVal get_start_time();
+ Glib::TimeVal start_time();
protected:
Header(const struct sr_datafeed_header *structure);
~Header();
- const struct sr_datafeed_header *structure;
+ shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
friend class Packet;
};
/** Payload of a datafeed metadata packet */
-class SR_API Meta : public PacketPayload,
- public StructureWrapper<Packet, const struct sr_datafeed_meta>
+class SR_API Meta :
+ public ParentOwned<Meta, Packet, const struct sr_datafeed_meta>,
+ public PacketPayload
{
public:
/* Mapping of (ConfigKey, value) pairs. */
- map<const ConfigKey *, Glib::VariantBase> get_config();
+ map<const ConfigKey *, Glib::VariantBase> config();
protected:
Meta(const struct sr_datafeed_meta *structure);
~Meta();
- const struct sr_datafeed_meta *structure;
- map<const ConfigKey *, Glib::VariantBase> config;
+ shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
+ map<const ConfigKey *, Glib::VariantBase> _config;
friend class Packet;
};
/** Payload of a datafeed packet with logic data */
-class SR_API Logic : public PacketPayload,
- public StructureWrapper<Packet, const struct sr_datafeed_logic>
+class SR_API Logic :
+ public ParentOwned<Logic, Packet, const struct sr_datafeed_logic>,
+ public PacketPayload
{
public:
/* Pointer to data. */
- void *get_data_pointer();
+ void *data_pointer();
/* Data length in bytes. */
- size_t get_data_length();
+ size_t data_length();
/* Size of each sample in bytes. */
- unsigned int get_unit_size();
+ unsigned int unit_size();
protected:
Logic(const struct sr_datafeed_logic *structure);
~Logic();
- const struct sr_datafeed_logic *structure;
+ shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
friend class Packet;
};
/** Payload of a datafeed packet with analog data */
-class SR_API Analog : public PacketPayload,
- public StructureWrapper<Packet, const struct sr_datafeed_analog>
+class SR_API Analog :
+ public ParentOwned<Analog, Packet, const struct sr_datafeed_analog>,
+ public PacketPayload
{
public:
/** Pointer to data. */
- float *get_data_pointer();
+ float *data_pointer();
/** Number of samples in this packet. */
- unsigned int get_num_samples();
+ unsigned int num_samples();
/** Channels for which this packet contains data. */
- vector<shared_ptr<Channel> > get_channels();
+ vector<shared_ptr<Channel> > channels();
/** Measured quantity of the samples in this packet. */
- const Quantity *get_mq();
+ const Quantity *mq();
/** Unit of the samples in this packet. */
- const Unit *get_unit();
+ const Unit *unit();
/** Measurement flags associated with the samples in this packet. */
- vector<const QuantityFlag *> get_mq_flags();
+ vector<const QuantityFlag *> mq_flags();
protected:
Analog(const struct sr_datafeed_analog *structure);
~Analog();
- const struct sr_datafeed_analog *structure;
+ shared_ptr<PacketPayload> get_shared_pointer(Packet *parent);
friend class Packet;
};
/** An input format supported by the library */
class SR_API InputFormat :
- public StructureWrapper<Context, const struct sr_input_module>
+ public ParentOwned<InputFormat, Context, const struct sr_input_module>
{
public:
/** Name of this input format. */
- string get_name();
+ string name();
/** Description of this input format. */
- string get_description();
+ string description();
/** Options supported by this input format. */
- map<string, shared_ptr<Option> > get_options();
+ 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 = {});
+ shared_ptr<Input> create_input(map<string, Glib::VariantBase> options =
+ map<string, Glib::VariantBase>());
protected:
InputFormat(const struct sr_input_module *structure);
~InputFormat();
};
/** An input instance (an input format applied to a file or stream) */
-class SR_API Input : public enable_shared_from_this<Input>
+class SR_API Input : public UserOwned<Input, const struct sr_input>
{
public:
/** Virtual device associated with this input. */
- shared_ptr<InputDevice> get_device();
+ shared_ptr<InputDevice> device();
/** Send next stream data.
* @param data Next stream data. */
void send(string data);
+ /** Signal end of input data. */
+ void end();
protected:
Input(shared_ptr<Context> context, const struct sr_input *structure);
~Input();
- shared_ptr<Device> get_shared_from_this();
- const struct sr_input *structure;
- shared_ptr<Context> context;
- InputDevice *device;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Input *input) { delete input; }
- };
+ shared_ptr<Context> _context;
+ InputDevice *_device;
friend class Deleter;
friend class Context;
friend class InputFormat;
/** A virtual device associated with an input */
class SR_API InputDevice :
- public StructureWrapper<Input, struct sr_dev_inst>,
+ public ParentOwned<InputDevice, Input, struct sr_dev_inst>,
public Device
{
protected:
InputDevice(shared_ptr<Input> input, struct sr_dev_inst *sdi);
~InputDevice();
shared_ptr<Device> get_shared_from_this();
- shared_ptr<Input> input;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(InputDevice *device) { delete device; }
- };
- friend class Deleter;
+ shared_ptr<Input> _input;
friend class Input;
};
/** An option used by an output format */
-class SR_API Option
+class SR_API Option : public UserOwned<Option, const struct sr_option>
{
public:
/** Short name of this option suitable for command line usage. */
- string get_id();
+ string id();
/** Short name of this option suitable for GUI usage. */
- string get_name();
+ string name();
/** Description of this option in a sentence. */
- string get_description();
+ string description();
/** Default value for this option. */
- Glib::VariantBase get_default_value();
+ Glib::VariantBase default_value();
/** Possible values for this option, if a limited set. */
- vector<Glib::VariantBase> get_values();
+ vector<Glib::VariantBase> values();
protected:
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;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Option *option) { delete option; }
- };
+ shared_ptr<const struct sr_option *> _structure_array;
friend class Deleter;
friend class InputFormat;
friend class OutputFormat;
/** An output format supported by the library */
class SR_API OutputFormat :
- public StructureWrapper<Context, const struct sr_output_module>
+ public ParentOwned<OutputFormat, Context, const struct sr_output_module>
{
public:
/** Name of this output format. */
- string get_name();
+ string name();
/** Description of this output format. */
- string get_description();
+ string description();
/** Options supported by this output format. */
- map<string, shared_ptr<Option> > get_options();
+ 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> options =
+ map<string, Glib::VariantBase>());
protected:
OutputFormat(const struct sr_output_module *structure);
~OutputFormat();
};
/** An output instance (an output format applied to a device) */
-class SR_API Output
+class SR_API Output : public UserOwned<Output, const struct sr_output>
{
public:
/** Update output with data from the given packet.
Output(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;
- /** Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Output *output) { delete output; }
- };
+ const shared_ptr<OutputFormat> _format;
+ const shared_ptr<Device> _device;
+ const map<string, Glib::VariantBase> _options;
friend class Deleter;
friend class OutputFormat;
};
/** Base class for objects which wrap an enumeration value from libsigrok */
-template <typename T> class SR_API EnumValue
+template <class Class, typename Enum> class SR_API EnumValue
{
public:
- /** The enum constant associated with this value. */
- T get_id() const { return id; }
+ /** The integer constant associated with this value. */
+ int id() const
+ {
+ return static_cast<int>(_id);
+ }
/** The name associated with this value. */
- string get_name() const { return name; }
+ string name() const
+ {
+ return _name;
+ }
+ /** 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())
+ throw Error(SR_ERR_ARG);
+ return _values.at(key);
+ }
+ /** Get possible values. */
+ static std::vector<const Class *> values()
+ {
+ std::vector<const Class *> result;
+ for (auto entry : _values)
+ result.push_back(entry.second);
+ return result;
+ }
protected:
- EnumValue(T id, const char name[]) : id(id), name(name) {}
- ~EnumValue() {}
- const T id;
- const string name;
+ EnumValue(Enum id, const char name[]) : _id(id), _name(name)
+ {
+ }
+ ~EnumValue()
+ {
+ }
+ static const std::map<const Enum, const Class * const> _values;
+ const Enum _id;
+ const string _name;
};
#include "enums.hpp"
projects / libsigrok.git / blobdiff