#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 Channel;
class SR_API Session;
class SR_API ConfigKey;
+class SR_API Capability;
class SR_API InputFormat;
class SR_API OutputFormat;
class SR_API OutputFlag;
throw Error(SR_ERR_BUG);
return shared;
}
-
- /* Deleter needed to allow shared_ptr use with protected destructor. */
- class Deleter
- {
- public:
- void operator()(Class *object) { delete object; }
- };
};
/** Type of log callback */
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,
+ static SR_PRIV gssize read_callback(const struct sr_resource *res,
void *buf, size_t count, void *cb_data) noexcept;
friend class Context;
};
shared_ptr<Packet> create_header_packet(Glib::TimeVal start_time);
/** Create a meta packet. */
shared_ptr<Packet> create_meta_packet(
- const map<const ConfigKey *, Glib::VariantBase> &config);
+ 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(
- const vector<shared_ptr<Channel> > &channels,
+ vector<shared_ptr<Channel> > channels,
float *data_pointer, unsigned int num_samples, const Quantity *mq,
- const Unit *unit, const vector<const QuantityFlag *> &mqflags);
+ const Unit *unit, vector<const QuantityFlag *> mqflags);
/** Load a saved session.
* @param filename File name string. */
shared_ptr<Session> load_session(string filename);
map<string, string> serials(shared_ptr<Driver> driver) const;
private:
struct sr_context *_structure;
- map<string, Driver *> _drivers;
- map<string, InputFormat *> _input_formats;
- map<string, OutputFormat *> _output_formats;
+ 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) const;
/** Enumerate available values for the given configuration key.
* @param key ConfigKey to enumerate values for. */
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) 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>,
- public Configurable
+class SR_API Driver : public ParentOwned<Driver, Context>, public Configurable
{
public:
/** Name of this driver. */
string name() const;
/** Long name for this driver. */
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(
- const map<const ConfigKey *, Glib::VariantBase> &options = {});
+ vector<shared_ptr<HardwareDevice> > scan(map<const ConfigKey *, Glib::VariantBase>
+ options = map<const ConfigKey *, Glib::VariantBase>());
private:
struct sr_dev_driver *_structure;
bool _initialized;
friend class Context;
friend class HardwareDevice;
friend class ChannelGroup;
+ friend struct std::default_delete<Driver>;
};
/** A generic device, either hardware or virtual */
shared_ptr<Channel> get_channel(struct sr_channel *ptr);
struct sr_dev_inst *_structure;
- map<struct sr_channel *, Channel *> _channels;
+ map<struct sr_channel *, unique_ptr<Channel> > _channels;
private:
- 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<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 */
~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 */
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 */
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 */
/** List of the channels in this group. */
vector<shared_ptr<Channel> > channels();
private:
- ChannelGroup(Device *device, struct sr_channel_group *structure);
+ 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 */
~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 */
void add_match(shared_ptr<Channel> channel, const TriggerMatchType *type, float value);
private:
struct sr_trigger_stage *_structure;
- vector<TriggerMatch *> _matches;
+ 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 */
struct sr_trigger_match *_structure;
shared_ptr<Channel> _channel;
friend class TriggerStage;
+ friend struct std::default_delete<TriggerMatch>;
};
/** Type of session stopped callback */
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 */
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;
+ 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 */
~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 */
private:
virtual shared_ptr<PacketPayload> share_owned_by(shared_ptr<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;
friend class Packet;
friend class Output;
+ friend struct std::default_delete<PacketPayload>;
};
/** Payload of a datafeed header packet */
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(const map<string, Glib::VariantBase> &options = {});
+ shared_ptr<Input> create_input(map<string, Glib::VariantBase>
+ options = map<string, Glib::VariantBase>());
private:
explicit InputFormat(const struct sr_input_module *structure);
~InputFormat();
friend class Context;
friend class InputDevice;
+ friend struct std::default_delete<InputFormat>;
};
/** An input instance (an input format applied to a file or stream) */
void send(void *data, size_t length);
/** Signal end of input data. */
void end();
+ 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 */
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 */
~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 */
/** 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,
- const map<string, Glib::VariantBase> &options = {});
+ 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,
- const map<string, Glib::VariantBase> &options = {});
+ map<string, Glib::VariantBase> options = map<string, Glib::VariantBase>());
/**
* Checks whether a given flag is set.
* @param flag Flag to check
friend class Context;
friend class Output;
+ friend struct std::default_delete<OutputFormat>;
};
/** An output instance (an output format applied to a device) */
private:
Output(shared_ptr<OutputFormat> format, shared_ptr<Device> device);
Output(shared_ptr<OutputFormat> format,
- shared_ptr<Device> device, const map<string, Glib::VariantBase> &options);
+ shared_ptr<Device> device, map<string, Glib::VariantBase> options);
Output(string filename, shared_ptr<OutputFormat> format,
- shared_ptr<Device> device, const map<string, Glib::VariantBase> &options);
+ shared_ptr<Device> device, map<string, Glib::VariantBase> options);
~Output();
const struct sr_output *_structure;
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 */
const string _name;
};
-#include <libsigrokcxx/enums.hpp>
-
}
+#include <libsigrokcxx/enums.hpp>
+
#endif