}
Context::Context() :
- UserOwned(_structure),
+ _structure(nullptr),
_session(nullptr)
{
check(sr_init(&_structure));
}
Driver::Driver(struct sr_dev_driver *structure) :
- ParentOwned(structure),
Configurable(structure, nullptr, nullptr),
+ _structure(structure),
_initialized(false)
{
}
HardwareDevice::HardwareDevice(shared_ptr<Driver> driver,
struct sr_dev_inst *structure) :
- UserOwned(structure),
Device(structure),
_driver(move(driver))
{
}
UserDevice::UserDevice(string vendor, string model, string version) :
- UserOwned(sr_dev_inst_user_new(
- vendor.c_str(), model.c_str(), version.c_str())),
- Device(UserOwned::_structure)
+ Device(sr_dev_inst_user_new(
+ vendor.c_str(), model.c_str(), version.c_str()))
{
}
}
Channel::Channel(struct sr_channel *structure) :
- ParentOwned(structure),
+ _structure(structure),
_type(ChannelType::get(_structure->type))
{
}
ChannelGroup::ChannelGroup(Device *device,
struct sr_channel_group *structure) :
- ParentOwned(structure),
Configurable(sr_dev_inst_driver_get(device->_structure), device->_structure, structure)
{
- for (GSList *entry = structure->channels; entry; entry = entry->next) {
+ for (GSList *entry = config_channel_group->channels; entry; entry = entry->next) {
auto *const ch = static_cast<struct sr_channel *>(entry->data);
_channels.push_back(device->_channels[ch]);
}
string ChannelGroup::name() const
{
- return valid_string(_structure->name);
+ return valid_string(config_channel_group->name);
}
vector<shared_ptr<Channel>> ChannelGroup::channels()
}
Trigger::Trigger(shared_ptr<Context> context, string name) :
- UserOwned(sr_trigger_new(name.c_str())),
+ _structure(sr_trigger_new(name.c_str())),
_context(move(context))
{
for (auto stage = _structure->stages; stage; stage = stage->next)
return stage->share_owned_by(shared_from_this());
}
-TriggerStage::TriggerStage(struct sr_trigger_stage *structure) :
- ParentOwned(structure)
+TriggerStage::TriggerStage(struct sr_trigger_stage *structure) :
+ _structure(structure)
{
}
TriggerMatch::TriggerMatch(struct sr_trigger_match *structure,
shared_ptr<Channel> channel) :
- ParentOwned(structure),
+ _structure(structure),
_channel(move(channel))
{
}
}
SessionDevice::SessionDevice(struct sr_dev_inst *structure) :
- ParentOwned(structure),
Device(structure)
{
}
}
Session::Session(shared_ptr<Context> context) :
- UserOwned(_structure),
+ _structure(nullptr),
_context(move(context))
{
check(sr_session_new(_context->_structure, &_structure));
}
Session::Session(shared_ptr<Context> context, string filename) :
- UserOwned(_structure),
+ _structure(nullptr),
_context(move(context)),
_filename(move(filename))
{
Packet::Packet(shared_ptr<Device> device,
const struct sr_datafeed_packet *structure) :
- UserOwned(structure),
+ _structure(structure),
_device(move(device))
{
switch (structure->type)
}
Header::Header(const struct sr_datafeed_header *structure) :
- ParentOwned(structure),
- PacketPayload()
+ PacketPayload(),
+ _structure(structure)
{
}
}
Meta::Meta(const struct sr_datafeed_meta *structure) :
- ParentOwned(structure),
- PacketPayload()
+ PacketPayload(),
+ _structure(structure)
{
}
}
Logic::Logic(const struct sr_datafeed_logic *structure) :
- ParentOwned(structure),
- PacketPayload()
+ PacketPayload(),
+ _structure(structure)
{
}
}
Analog::Analog(const struct sr_datafeed_analog *structure) :
- ParentOwned(structure),
- PacketPayload()
+ PacketPayload(),
+ _structure(structure)
{
}
}
InputFormat::InputFormat(const struct sr_input_module *structure) :
- ParentOwned(structure)
+ _structure(structure)
{
}
}
Input::Input(shared_ptr<Context> context, const struct sr_input *structure) :
- UserOwned(structure),
+ _structure(structure),
_context(move(context)),
_device(nullptr)
{
InputDevice::InputDevice(shared_ptr<Input> input,
struct sr_dev_inst *structure) :
- ParentOwned(structure),
Device(structure),
_input(move(input))
{
Option::Option(const struct sr_option *structure,
shared_ptr<const struct sr_option *> structure_array) :
- UserOwned(structure),
+ _structure(structure),
_structure_array(move(structure_array))
{
}
}
OutputFormat::OutputFormat(const struct sr_output_module *structure) :
- ParentOwned(structure)
+ _structure(structure)
{
}
Output::Output(shared_ptr<OutputFormat> format,
shared_ptr<Device> device, const map<string, Glib::VariantBase> &options) :
- UserOwned(sr_output_new(format->_structure,
+ _structure(sr_output_new(format->_structure,
map_to_hash_variant(options), device->_structure, nullptr)),
_format(move(format)),
_device(move(device)),
Output::Output(string filename, shared_ptr<OutputFormat> format,
shared_ptr<Device> device, const map<string, Glib::VariantBase> &options) :
- UserOwned(sr_output_new(format->_structure,
+ _structure(sr_output_new(format->_structure,
map_to_hash_variant(options), device->_structure, filename.c_str())),
_format(move(format)),
_device(move(device)),
};
/* 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:
references to both the parent and all its children are gone. */
shared_ptr<Parent> _parent;
- Struct *_structure;
-
- explicit ParentOwned(Struct *structure) :
- _structure(structure)
- {
- }
+ ParentOwned() {}
/* Note, this implementation will create a new smart_ptr if none exists. */
shared_ptr<Class> shared_from_this()
};
/* 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>
{
protected:
- Struct *_structure;
-
- explicit UserOwned(Struct *structure) :
- _structure(structure)
- {
- }
+ UserOwned() {}
shared_ptr<Class> shared_from_this()
{
};
/** 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 */
shared_ptr<Input> open_stream(string header);
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;
/** A hardware driver provided by the library */
class SR_API Driver :
- public ParentOwned<Driver, Context, struct sr_dev_driver>,
+ public ParentOwned<Driver, Context>,
public Configurable
{
public:
vector<shared_ptr<HardwareDevice> > scan(
const map<const ConfigKey *, Glib::VariantBase> &options = {});
private:
+ struct sr_dev_driver *_structure;
bool _initialized;
vector<HardwareDevice *> _devices;
explicit Driver(struct sr_dev_driver *structure);
/** 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:
/** A virtual device, created by the user */
class SR_API UserDevice :
- public UserOwned<UserDevice, struct sr_dev_inst>,
+ public UserOwned<UserDevice>,
public Device
{
public:
/** 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. */
private:
explicit Channel(struct sr_channel *structure);
~Channel();
+ struct sr_channel *_structure;
const ChannelType * const _type;
friend class Device;
friend class UserDevice;
/** 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:
};
/** 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. */
private:
Trigger(shared_ptr<Context> context, string name);
~Trigger();
+ struct sr_trigger *_structure;
shared_ptr<Context> _context;
vector<TriggerStage *> _stages;
friend class Deleter;
/** 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. */
* @param value Threshold value. */
void add_match(shared_ptr<Channel> channel, const TriggerMatchType *type, float value);
private:
+ struct sr_trigger_stage *_structure;
vector<TriggerMatch *> _matches;
explicit TriggerStage(struct sr_trigger_stage *structure);
~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. */
private:
TriggerMatch(struct sr_trigger_match *structure, shared_ptr<Channel> channel);
~TriggerMatch();
+ struct sr_trigger_match *_structure;
shared_ptr<Channel> _channel;
friend class TriggerStage;
};
/** 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
{
private:
};
/** 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.
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 *, shared_ptr<Device> > _other_devices;
};
/** 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. */
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;
/** 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:
explicit Header(const struct sr_datafeed_header *structure);
~Header();
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:
explicit Meta(const struct sr_datafeed_meta *structure);
~Meta();
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:
explicit Logic(const struct sr_datafeed_logic *structure);
~Logic();
shared_ptr<PacketPayload> share_owned_by(shared_ptr<Packet> parent);
+
+ const struct sr_datafeed_logic *_structure;
+
friend class Packet;
};
/** 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:
explicit Analog(const struct sr_datafeed_analog *structure);
~Analog();
shared_ptr<PacketPayload> share_owned_by(shared_ptr<Packet> parent);
+
+ const struct sr_datafeed_analog *_structure;
+
friend class Packet;
};
/** 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. */
private:
explicit InputFormat(const struct sr_input_module *structure);
~InputFormat();
+
+ const struct sr_input_module *_structure;
+
friend class Context;
friend class InputDevice;
};
/** 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. */
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;
/** 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
{
private:
};
/** 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. */
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;
/** 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. */
private:
explicit OutputFormat(const struct sr_output_module *structure);
~OutputFormat();
+
+ const struct sr_output_module *_structure;
+
friend class Context;
friend class Output;
};
/** 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.
Output(string filename, shared_ptr<OutputFormat> format,
shared_ptr<Device> device, const 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;
};
projects / libsigrok.git / commitdiff