return "";
}
-/** Helper function to convert between map<string, string> and GHashTable */
-static GHashTable *map_to_hash_string(map<string, string> input)
-{
- auto output = g_hash_table_new_full(
- g_str_hash, g_str_equal, g_free, g_free);
- for (auto entry : input)
- g_hash_table_insert(output,
- g_strdup(entry.first.c_str()),
- g_strdup(entry.second.c_str()));
- return output;
-}
-
/** Helper function to convert between map<string, VariantBase> and GHashTable */
static GHashTable *map_to_hash_variant(map<string, Glib::VariantBase> input)
{
auto output = g_hash_table_new_full(
- g_variant_hash, g_variant_equal, g_free,
- (void (*)(void *))g_variant_unref);
+ g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
for (auto entry : input)
g_hash_table_insert(output,
g_strdup(entry.first.c_str()),
}
Context::Context() :
+ UserOwned(structure),
session(NULL)
{
check(sr_init(&structure));
+
struct sr_dev_driver **driver_list = sr_driver_list();
if (driver_list)
for (int i = 0; driver_list[i]; i++)
drivers[driver_list[i]->name] =
new Driver(driver_list[i]);
- struct sr_input_format **input_list = sr_input_list();
+ const struct sr_input_module **input_list = sr_input_list();
if (input_list)
for (int i = 0; input_list[i]; i++)
- input_formats[input_list[i]->id] =
+ input_formats[sr_input_id_get(input_list[i])] =
new InputFormat(input_list[i]);
const struct sr_output_module **output_list = sr_output_list();
if (output_list)
{
auto name = entry.first;
auto driver = entry.second;
- result[name] = static_pointer_cast<Driver>(
- driver->get_shared_pointer(this));
+ result[name] = driver->get_shared_pointer(this);
}
return result;
}
{
auto name = entry.first;
auto input_format = entry.second;
- result[name] = static_pointer_cast<InputFormat>(
- input_format->get_shared_pointer(this));
+ result[name] = input_format->get_shared_pointer(this);
}
return result;
}
{
auto name = entry.first;
auto output_format = entry.second;
- result[name] = static_pointer_cast<OutputFormat>(
- output_format->get_shared_pointer(this));
+ result[name] = output_format->get_shared_pointer(this);
}
return result;
}
new Trigger(shared_from_this(), name), Trigger::Deleter());
}
+shared_ptr<Input> Context::open_file(string filename)
+{
+ const struct sr_input *input;
+
+ check( sr_input_scan_file(filename.c_str(), &input));
+ return shared_ptr<Input>(
+ new Input(shared_from_this(), input), Input::Deleter());
+}
+
+shared_ptr<Input> Context::open_stream(string header)
+{
+ const struct sr_input *input;
+
+ auto gstr = g_string_new(header.c_str());
+ auto ret = sr_input_scan_buffer(gstr, &input);
+ g_string_free(gstr, true);
+ check(ret);
+ return shared_ptr<Input>(
+ new Input(shared_from_this(), input), Input::Deleter());
+}
+
Driver::Driver(struct sr_dev_driver *structure) :
- StructureWrapper<Context, struct sr_dev_driver>(structure),
+ ParentOwned(structure),
initialized(false)
{
}
/* Create list of shared pointers to device instances for return. */
vector<shared_ptr<HardwareDevice>> result;
for (auto device : devices)
- result.push_back(static_pointer_cast<HardwareDevice>(
- device->get_shared_pointer(parent)));
+ result.push_back(device->get_shared_pointer(parent));
return result;
}
Device::Device(struct sr_dev_inst *structure) :
Configurable(structure->driver, structure, NULL),
- StructureWrapper<Context, struct sr_dev_inst>(structure)
+ structure(structure)
{
for (GSList *entry = structure->channels; entry; entry = entry->next)
{
{
vector<shared_ptr<Channel>> result;
for (auto entry : channels)
- result.push_back(static_pointer_cast<Channel>(
- entry.second->get_shared_pointer(this)));
+ result.push_back(entry.second->get_shared_pointer(get_shared_from_this()));
return result;
}
shared_ptr<Channel> Device::get_channel(struct sr_channel *ptr)
{
- return static_pointer_cast<Channel>(
- channels[ptr]->get_shared_pointer(this));
+ return channels[ptr]->get_shared_pointer(get_shared_from_this());
}
map<string, shared_ptr<ChannelGroup>>
{
auto name = entry.first;
auto channel_group = entry.second;
- result[name] = static_pointer_cast<ChannelGroup>(
- channel_group->get_shared_pointer(this));
+ result[name] = channel_group->get_shared_pointer(get_shared_from_this());
}
return result;
}
}
HardwareDevice::HardwareDevice(Driver *driver, struct sr_dev_inst *structure) :
+ ParentOwned(structure),
Device(structure),
driver(driver)
{
{
}
+shared_ptr<Device> HardwareDevice::get_shared_from_this()
+{
+ return static_pointer_cast<Device>(shared_from_this());
+}
+
shared_ptr<Driver> HardwareDevice::get_driver()
{
- return static_pointer_cast<Driver>(driver->get_shared_pointer(parent));
+ return driver->get_shared_pointer(parent);
}
Channel::Channel(struct sr_channel *structure) :
- StructureWrapper<Device, struct sr_channel>(structure),
+ ParentOwned(structure),
type(ChannelType::get(structure->type))
{
}
ChannelGroup::ChannelGroup(Device *device,
struct sr_channel_group *structure) :
- StructureWrapper<Device, struct sr_channel_group>(structure),
+ ParentOwned(structure),
Configurable(device->structure->driver, device->structure, structure)
{
for (GSList *entry = structure->channels; entry; entry = entry->next)
{
vector<shared_ptr<Channel>> result;
for (auto channel : channels)
- result.push_back(static_pointer_cast<Channel>(
- channel->get_shared_pointer(parent)));
+ result.push_back(channel->get_shared_pointer(parent));
return result;
}
Trigger::Trigger(shared_ptr<Context> context, string name) :
- structure(sr_trigger_new(name.c_str())), context(context)
+ UserOwned(sr_trigger_new(name.c_str())),
+ context(context)
{
for (auto stage = structure->stages; stage; stage = stage->next)
stages.push_back(new TriggerStage((struct sr_trigger_stage *) stage->data));
{
vector<shared_ptr<TriggerStage>> result;
for (auto stage : stages)
- result.push_back(static_pointer_cast<TriggerStage>(
- stage->get_shared_pointer(this)));
+ result.push_back(stage->get_shared_pointer(this));
return result;
}
{
auto stage = new TriggerStage(sr_trigger_stage_add(structure));
stages.push_back(stage);
- return static_pointer_cast<TriggerStage>(
- stage->get_shared_pointer(this));
+ return stage->get_shared_pointer(this);
}
TriggerStage::TriggerStage(struct sr_trigger_stage *structure) :
- StructureWrapper<Trigger, struct sr_trigger_stage>(structure)
+ ParentOwned(structure)
{
}
{
vector<shared_ptr<TriggerMatch>> result;
for (auto match : matches)
- result.push_back(static_pointer_cast<TriggerMatch>(
- match->get_shared_pointer(this)));
+ result.push_back(match->get_shared_pointer(this));
return result;
}
}
TriggerMatch::TriggerMatch(struct sr_trigger_match *structure, shared_ptr<Channel> channel) :
- StructureWrapper<TriggerStage, struct sr_trigger_match>(structure), channel(channel)
+ ParentOwned(structure), channel(channel)
{
}
}
Session::Session(shared_ptr<Context> context) :
+ UserOwned(structure),
context(context), saving(false)
{
check(sr_session_new(&structure));
}
Session::Session(shared_ptr<Context> context, string filename) :
+ UserOwned(structure),
context(context), saving(false)
{
check(sr_session_load(filename.c_str(), &structure));
for (GSList *dev = dev_list; dev; dev = dev->next)
{
auto sdi = (struct sr_dev_inst *) dev->data;
- if (devices.count(sdi) == 0)
- devices[sdi] = shared_ptr<Device>(
- new Device(sdi), Device::Deleter());
result.push_back(devices[sdi]);
}
return result;
Packet::Packet(shared_ptr<Device> device,
const struct sr_datafeed_packet *structure) :
- structure(structure),
+ UserOwned(structure),
device(device)
{
switch (structure->type)
static_cast<const struct sr_datafeed_analog *>(
structure->payload));
break;
+ default:
+ payload = nullptr;
+ break;
}
}
shared_ptr<PacketPayload> Packet::get_payload()
{
- return payload->get_shared_pointer(this);
+ if (payload)
+ return payload->get_shared_pointer(this);
+ else
+ throw Error(SR_ERR_NA);
}
PacketPayload::PacketPayload()
}
Header::Header(const struct sr_datafeed_header *structure) :
- PacketPayload(),
- StructureWrapper<Packet, const struct sr_datafeed_header>(structure)
+ ParentOwned(structure),
+ PacketPayload()
{
}
{
}
+shared_ptr<PacketPayload> Header::get_shared_pointer(Packet *parent)
+{
+ return static_pointer_cast<PacketPayload>(get_shared_pointer(parent));
+}
+
int Header::get_feed_version()
{
return structure->feed_version;
}
Meta::Meta(const struct sr_datafeed_meta *structure) :
- PacketPayload(),
- StructureWrapper<Packet, const struct sr_datafeed_meta>(structure)
+ ParentOwned(structure),
+ PacketPayload()
{
}
{
}
+shared_ptr<PacketPayload> Meta::get_shared_pointer(Packet *parent)
+{
+ return static_pointer_cast<PacketPayload>(get_shared_pointer(parent));
+}
+
map<const ConfigKey *, Glib::VariantBase> Meta::get_config()
{
map<const ConfigKey *, Glib::VariantBase> result;
}
Logic::Logic(const struct sr_datafeed_logic *structure) :
- PacketPayload(),
- StructureWrapper<Packet, const struct sr_datafeed_logic>(structure)
+ ParentOwned(structure),
+ PacketPayload()
{
}
{
}
+shared_ptr<PacketPayload> Logic::get_shared_pointer(Packet *parent)
+{
+ return static_pointer_cast<PacketPayload>(get_shared_pointer(parent));
+}
+
void *Logic::get_data_pointer()
{
return structure->data;
}
Analog::Analog(const struct sr_datafeed_analog *structure) :
- PacketPayload(),
- StructureWrapper<Packet, const struct sr_datafeed_analog>(structure)
+ ParentOwned(structure),
+ PacketPayload()
{
}
{
}
+shared_ptr<PacketPayload> Analog::get_shared_pointer(Packet *parent)
+{
+ return static_pointer_cast<PacketPayload>(get_shared_pointer(parent));
+}
+
float *Analog::get_data_pointer()
{
return structure->data;
return QuantityFlag::flags_from_mask(structure->mqflags);
}
-InputFormat::InputFormat(struct sr_input_format *structure) :
- StructureWrapper<Context, struct sr_input_format>(structure)
+InputFormat::InputFormat(const struct sr_input_module *structure) :
+ ParentOwned(structure)
{
}
string InputFormat::get_name()
{
- return valid_string(structure->id);
+ return valid_string(sr_input_id_get(structure));
}
string InputFormat::get_description()
{
- return valid_string(structure->description);
+ return valid_string(sr_input_description_get(structure));
}
-bool InputFormat::format_match(string filename)
+map<string, shared_ptr<Option>> InputFormat::get_options()
{
- return structure->format_match(filename.c_str());
+ const struct sr_option **options = sr_input_options_get(structure);
+ auto option_array = shared_ptr<const struct sr_option *>(
+ options, sr_input_options_free);
+ map<string, shared_ptr<Option>> result;
+ for (int i = 0; options[i]; i++)
+ result[options[i]->id] = shared_ptr<Option>(
+ new Option(options[i], option_array), Option::Deleter());
+ return result;
}
-shared_ptr<InputFileDevice> InputFormat::open_file(string filename,
- map<string, string> options)
+shared_ptr<Input> InputFormat::create_input(
+ map<string, Glib::VariantBase> options)
{
- auto input = g_new(struct sr_input, 1);
- input->param = map_to_hash_string(options);
+ auto input = sr_input_new(structure, map_to_hash_variant(options));
+ if (!input)
+ throw Error(SR_ERR_ARG);
+ return shared_ptr<Input>(
+ new Input(parent->shared_from_this(), input), Input::Deleter());
+}
- /** Run initialisation. */
- check(structure->init(input, filename.c_str()));
+Input::Input(shared_ptr<Context> context, const struct sr_input *structure) :
+ UserOwned(structure),
+ context(context),
+ device(nullptr)
+{
+}
- /** Create virtual device. */
- return shared_ptr<InputFileDevice>(new InputFileDevice(
- static_pointer_cast<InputFormat>(shared_from_this()), input, filename),
- InputFileDevice::Deleter());
+shared_ptr<InputDevice> Input::get_device()
+{
+ if (!device)
+ {
+ auto sdi = sr_input_dev_inst_get(structure);
+ if (!sdi)
+ throw Error(SR_ERR_NA);
+ device = new InputDevice(shared_from_this(), sdi);
+ }
+
+ return device->get_shared_pointer(shared_from_this());
}
-InputFileDevice::InputFileDevice(shared_ptr<InputFormat> format,
- struct sr_input *input, string filename) :
- Device(input->sdi),
- input(input),
- format(format),
- filename(filename)
+void Input::send(string data)
+{
+ auto gstr = g_string_new(data.c_str());
+ auto ret = sr_input_send(structure, gstr);
+ g_string_free(gstr, false);
+ check(ret);
+}
+
+Input::~Input()
+{
+ if (device)
+ delete device;
+ check(sr_input_free(structure));
+}
+
+InputDevice::InputDevice(shared_ptr<Input> input,
+ struct sr_dev_inst *structure) :
+ ParentOwned(structure),
+ Device(structure),
+ input(input)
{
}
-InputFileDevice::~InputFileDevice()
+InputDevice::~InputDevice()
{
- g_hash_table_unref(input->param);
- g_free(input);
}
-void InputFileDevice::load()
+shared_ptr<Device> InputDevice::get_shared_from_this()
{
- check(format->structure->loadfile(input, filename.c_str()));
+ return static_pointer_cast<Device>(shared_from_this());
}
Option::Option(const struct sr_option *structure,
- shared_ptr<const struct sr_option> structure_array) :
- structure(structure),
+ shared_ptr<const struct sr_option *> structure_array) :
+ UserOwned(structure),
structure_array(structure_array)
{
}
}
OutputFormat::OutputFormat(const struct sr_output_module *structure) :
- StructureWrapper<Context, const struct sr_output_module>(structure)
+ ParentOwned(structure)
{
}
map<string, shared_ptr<Option>> OutputFormat::get_options()
{
- const struct sr_option *option = sr_output_options_get(structure);
- auto option_array = shared_ptr<const struct sr_option>(
- option, [=](const struct sr_option *) {
- sr_output_options_free(structure); });
+ const struct sr_option **options = sr_output_options_get(structure);
+ auto option_array = shared_ptr<const struct sr_option *>(
+ options, sr_output_options_free);
map<string, shared_ptr<Option>> result;
- for (; option->id; option++)
- result[option->id] = shared_ptr<Option>(
- new Option(option, option_array), Option::Deleter());
+ for (int i = 0; options[i]; i++)
+ result[options[i]->id] = shared_ptr<Option>(
+ new Option(options[i], option_array), Option::Deleter());
return result;
}
shared_ptr<Device> device, map<string, Glib::VariantBase> options)
{
return shared_ptr<Output>(
- new Output(
- static_pointer_cast<OutputFormat>(shared_from_this()),
- device, options),
+ new Output(shared_from_this(), device, options),
Output::Deleter());
}
Output::Output(shared_ptr<OutputFormat> format,
shared_ptr<Device> device, map<string, Glib::VariantBase> options) :
- structure(sr_output_new(format->structure,
+ UserOwned(sr_output_new(format->structure,
map_to_hash_variant(options), device->structure)),
format(format), device(device), options(options)
{
projects / libsigrok.git / blobdiff