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()),
shared_ptr<Input> Context::open_file(string filename)
{
- auto input = sr_input_scan_file(filename.c_str());
- if (!input)
- throw Error(SR_ERR_NA);
+ 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 input = sr_input_scan_buffer(gstr);
- g_string_free(gstr, false);
- if (!input)
- throw Error(SR_ERR_NA);
+ 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),
+ StructureWrapper(structure),
initialized(false)
{
}
vector<shared_ptr<Channel>> result;
for (auto entry : channels)
result.push_back(static_pointer_cast<Channel>(
- entry.second->get_shared_pointer(this)));
+ 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));
+ 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));
+ channel_group->get_shared_pointer(get_shared_from_this()));
}
return result;
}
{
}
+shared_ptr<Device> HardwareDevice::get_shared_from_this()
+{
+ return static_pointer_cast<Device>(
+ static_pointer_cast<HardwareDevice>(shared_from_this()));
+}
+
shared_ptr<Driver> HardwareDevice::get_driver()
{
return static_pointer_cast<Driver>(driver->get_shared_pointer(parent));
}
Channel::Channel(struct sr_channel *structure) :
- StructureWrapper<Device, struct sr_channel>(structure),
+ StructureWrapper(structure),
type(ChannelType::get(structure->type))
{
}
ChannelGroup::ChannelGroup(Device *device,
struct sr_channel_group *structure) :
- StructureWrapper<Device, struct sr_channel_group>(structure),
+ StructureWrapper(structure),
Configurable(device->structure->driver, device->structure, structure)
{
for (GSList *entry = structure->channels; entry; entry = entry->next)
}
TriggerStage::TriggerStage(struct sr_trigger_stage *structure) :
- StructureWrapper<Trigger, struct sr_trigger_stage>(structure)
+ StructureWrapper(structure)
{
}
}
TriggerMatch::TriggerMatch(struct sr_trigger_match *structure, shared_ptr<Channel> channel) :
- StructureWrapper<TriggerStage, struct sr_trigger_match>(structure), channel(channel)
+ StructureWrapper(structure), channel(channel)
{
}
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;
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)
+ StructureWrapper(structure),
+ PacketPayload()
{
}
{
}
+shared_ptr<PacketPayload> Header::get_shared_pointer(Packet *parent)
+{
+ return static_pointer_cast<PacketPayload>(
+ static_pointer_cast<Header>(
+ StructureWrapper::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)
+ StructureWrapper(structure),
+ PacketPayload()
{
}
{
}
+shared_ptr<PacketPayload> Meta::get_shared_pointer(Packet *parent)
+{
+ return static_pointer_cast<PacketPayload>(
+ static_pointer_cast<Meta>(
+ StructureWrapper::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)
+ StructureWrapper(structure),
+ PacketPayload()
{
}
{
}
+shared_ptr<PacketPayload> Logic::get_shared_pointer(Packet *parent)
+{
+ return static_pointer_cast<PacketPayload>(
+ static_pointer_cast<Logic>(
+ StructureWrapper::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)
+ StructureWrapper(structure),
+ PacketPayload()
{
}
{
}
+shared_ptr<PacketPayload> Analog::get_shared_pointer(Packet *parent)
+{
+ return static_pointer_cast<PacketPayload>(
+ static_pointer_cast<Analog>(
+ StructureWrapper::get_shared_pointer(parent)));
+}
+
float *Analog::get_data_pointer()
{
return structure->data;
}
InputFormat::InputFormat(const struct sr_input_module *structure) :
- StructureWrapper<Context, const struct sr_input_module>(structure)
+ StructureWrapper(structure)
{
}
return valid_string(sr_input_description_get(structure));
}
+map<string, shared_ptr<Option>> InputFormat::get_options()
+{
+ 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<Input> InputFormat::create_input(
map<string, Glib::VariantBase> options)
{
{
}
+shared_ptr<Device> InputDevice::get_shared_from_this()
+{
+ return static_pointer_cast<Device>(
+ static_pointer_cast<InputDevice>(shared_from_this()));
+}
+
Option::Option(const struct sr_option *structure,
shared_ptr<const struct sr_option *> structure_array) :
structure(structure),
}
OutputFormat::OutputFormat(const struct sr_output_module *structure) :
- StructureWrapper<Context, const struct sr_output_module>(structure)
+ StructureWrapper(structure)
{
}