class SR_API Quantity;
class SR_API Unit;
class SR_API QuantityFlag;
-class SR_API InputFileDevice;
+class SR_API Input;
+class SR_API InputDevice;
class SR_API Output;
class SR_API DataType;
class SR_API Option;
};
/* 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> >
+template <class Class, class Parent, typename Struct>
+class SR_API StructureWrapper
{
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:
- shared_ptr<StructureWrapper<Parent, Struct> >
- get_shared_pointer(Parent *parent)
+ /* Note, this implementation will create a new smart_ptr if none exists. */
+ shared_ptr<Class> shared_from_this()
{
- this->parent = static_pointer_cast<Parent>(parent->shared_from_this());
- return shared_ptr<StructureWrapper<Parent, Struct> >(
- this, reset_parent);
+ shared_ptr<Class> shared;
+
+ if (!(shared = weak_this.lock()))
+ {
+ shared = shared_ptr<Class>((Class *) this, reset_parent);
+ weak_this = shared;
+ }
+
+ return shared;
}
- shared_ptr<StructureWrapper<Parent, Struct> >
- get_shared_pointer(shared_ptr<Parent> parent)
+
+ shared_ptr<Class> get_shared_pointer(shared_ptr<Parent> parent)
{
+ if (!parent)
+ throw Error(SR_ERR_BUG);
this->parent = parent;
- return shared_ptr<StructureWrapper<Parent, Struct> >(
- this, reset_parent);
+ 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(StructureWrapper<Parent, Struct> *object)
+ static void reset_parent(Class *object)
{
+ if (!object->parent)
+ throw Error(SR_ERR_BUG);
object->parent.reset();
}
Struct *structure;
- StructureWrapper<Parent, Struct>(Struct *structure) :
+ StructureWrapper<Class, Parent, Struct>(Struct *structure) :
structure(structure)
{
}
/** Create a new trigger.
* @param name Name string for new trigger. */
shared_ptr<Trigger> create_trigger(string name);
+ /** Open an input file.
+ * @param filename File name string. */
+ shared_ptr<Input> open_file(string filename);
+ /** Open an input stream based on header data.
+ * @param header Initial data from stream. */
+ shared_ptr<Input> open_stream(string header);
protected:
struct sr_context *structure;
map<string, Driver *> drivers;
};
/** A hardware driver provided by the library */
-class SR_API Driver : public StructureWrapper<Context, struct sr_dev_driver>
+class SR_API Driver :
+ public StructureWrapper<Driver, Context, struct sr_dev_driver>
{
public:
/** Name of this driver. */
};
/** A generic device, either hardware or virtual */
-class SR_API Device :
- public Configurable,
- public StructureWrapper<Context, struct sr_dev_inst>
+class SR_API Device : public Configurable
{
public:
/** Description identifying this device. */
protected:
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. */
};
/** A real hardware device, connected via a driver */
-class SR_API HardwareDevice : public Device
+class SR_API HardwareDevice :
+ public StructureWrapper<HardwareDevice, Context, struct sr_dev_inst>,
+ public Device
{
public:
/** Driver providing this device. */
protected:
HardwareDevice(Driver *driver, struct sr_dev_inst *structure);
~HardwareDevice();
+ shared_ptr<Device> get_shared_from_this();
Driver *driver;
friend class Driver;
friend class ChannelGroup;
};
/** A channel on a device */
-class SR_API Channel : public StructureWrapper<Device, struct sr_channel>
+class SR_API Channel :
+ public StructureWrapper<Channel, Device, struct sr_channel>
{
public:
/** Current name of this channel. */
/** A group of channels on a device, which share some configuration */
class SR_API ChannelGroup :
- public StructureWrapper<Device, struct sr_channel_group>,
+ public StructureWrapper<ChannelGroup, Device, struct sr_channel_group>,
public Configurable
{
public:
};
/** A stage in a trigger configuration */
-class SR_API TriggerStage : public StructureWrapper<Trigger, struct sr_trigger_stage>
+class SR_API TriggerStage :
+ public StructureWrapper<TriggerStage, Trigger, struct sr_trigger_stage>
{
public:
/** Index number of this stage. */
};
/** A match condition in a trigger configuration */
-class SR_API TriggerMatch : public StructureWrapper<TriggerStage, struct sr_trigger_match>
+class SR_API TriggerMatch :
+ public StructureWrapper<TriggerMatch, TriggerStage, struct sr_trigger_match>
{
public:
/** Channel this condition matches on. */
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 StructureWrapper<Header, Packet, const struct sr_datafeed_header>,
+ public PacketPayload
{
public:
/* Feed version number. */
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 StructureWrapper<Meta, Packet, const struct sr_datafeed_meta>,
+ public PacketPayload
{
public:
/* Mapping of (ConfigKey, value) pairs. */
protected:
Meta(const struct sr_datafeed_meta *structure);
~Meta();
- const struct sr_datafeed_meta *structure;
+ 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 StructureWrapper<Logic, Packet, const struct sr_datafeed_logic>,
+ public PacketPayload
{
public:
/* Pointer to data. */
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 StructureWrapper<Analog, Packet, const struct sr_datafeed_analog>,
+ public PacketPayload
{
public:
/** Pointer to data. */
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, struct sr_input_format>
+ public StructureWrapper<InputFormat, Context, const struct sr_input_module>
{
public:
/** Name of this input format. */
string get_name();
/** Description of this input format. */
string get_description();
- /** Check whether a given file matches this input format.
- * @param filename File name string. */
- bool format_match(string filename);
- /** Open a file using this input format.
- * @param filename File name string.
- * @param options Mapping of (option name, value) strings. */
- shared_ptr<InputFileDevice> open_file(string filename,
- map<string, string> options = {});
+ /** Options supported by this input format. */
+ map<string, shared_ptr<Option> > get_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 = {});
protected:
- InputFormat(struct sr_input_format *structure);
+ InputFormat(const struct sr_input_module *structure);
~InputFormat();
friend class Context;
- friend class InputFileDevice;
+ friend class InputDevice;
};
-/** A virtual device associated with an input file */
-class SR_API InputFileDevice : public Device
+/** An input instance (an input format applied to a file or stream) */
+class SR_API Input : public enable_shared_from_this<Input>
{
public:
- /** Load data from file. */
- void load();
+ /** Virtual device associated with this input. */
+ shared_ptr<InputDevice> get_device();
+ /** Send next stream data.
+ * @param data Next stream data. */
+ void send(string data);
protected:
- InputFileDevice(shared_ptr<InputFormat> format,
- struct sr_input *input, string filename);
- ~InputFileDevice();
- struct sr_input *input;
- shared_ptr<InputFormat> format;
- string filename;
+ Input(shared_ptr<Context> context, const struct sr_input *structure);
+ ~Input();
+ 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()(InputFileDevice *device) { delete device; }
+ void operator()(Input *input) { delete input; }
};
friend class Deleter;
+ friend class Context;
friend class InputFormat;
};
+/** A virtual device associated with an input */
+class SR_API InputDevice :
+ public StructureWrapper<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;
+ friend class Input;
+};
+
/** An option used by an output format */
class SR_API Option
{
void operator()(Option *option) { delete option; }
};
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 StructureWrapper<OutputFormat, Context, const struct sr_output_module>
{
public:
/** Name of this output format. */