#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
weak_ptr<Class> _weak_this;
public:
+ /* 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()
{
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);
friend class Driver;
};
+enum Capability {
+ GET = SR_CONF_GET,
+ SET = SR_CONF_SET,
+ LIST = SR_CONF_LIST
+};
+
/** An object that can be configured. */
class SR_API Configurable
{
* @param key ConfigKey to enumerate values for. */
Glib::VariantContainerBase config_list(const ConfigKey *key);
/** Enumerate available keys, according to a given index key. */
- vector<const ConfigKey *> config_keys(const ConfigKey *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:
/** 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> options =
+ map<const ConfigKey *, Glib::VariantBase>());
protected:
bool _initialized;
vector<HardwareDevice *> _devices;
class SR_API Device : public Configurable
{
public:
- /** Description identifying this device. */
- string description();
/** Vendor name for this device. */
string vendor();
/** Model name for this device. */
string model();
/** Version string for this device. */
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> > channels();
/** Channel groups available on this device, indexed by name. */
/** A real hardware device, connected via a driver */
class SR_API HardwareDevice :
- public ParentOwned<HardwareDevice, Context, struct sr_dev_inst>,
+ public UserOwned<HardwareDevice, struct sr_dev_inst>,
public Device
{
public:
/** Driver providing this device. */
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 ParentOwned<Channel, Device, struct sr_channel>
~Channel();
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 */
void append(void *data, size_t length, unsigned int unit_size);
/** Get current trigger setting. */
shared_ptr<Trigger> trigger();
+ /** Get the context. */
+ shared_ptr<Context> context();
/** 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();
+ shared_ptr<Device> get_device(const struct sr_dev_inst *sdi);
const shared_ptr<Context> _context;
- map<const struct sr_dev_inst *, shared_ptr<Device> > _devices;
+ 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;
friend class Deleter;
friend class Context;
friend class DatafeedCallbackData;
+ friend class SessionDevice;
};
/** A packet on the session datafeed */
friend class Meta;
friend class Logic;
friend class Analog;
+ friend class Context;
};
/** Abstract base class for datafeed packet payloads */
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();
/** 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();
* @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();
};
/** 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 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 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;
+ 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;
};
projects / libsigrok.git / blobdiff