{
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;
}
/* 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;
}
{
vector<shared_ptr<Channel>> result;
for (auto entry : channels)
- result.push_back(static_pointer_cast<Channel>(
- entry.second->get_shared_pointer(get_shared_from_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(get_shared_from_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(get_shared_from_this()));
+ result[name] = 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()));
+ 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) :
{
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;
}
{
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) :
{
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;
}
shared_ptr<PacketPayload> Header::get_shared_pointer(Packet *parent)
{
- return static_pointer_cast<PacketPayload>(
- static_pointer_cast<Header>(
- StructureWrapper::get_shared_pointer(parent)));
+ return static_pointer_cast<PacketPayload>(get_shared_pointer(parent));
}
int Header::get_feed_version()
shared_ptr<PacketPayload> Meta::get_shared_pointer(Packet *parent)
{
- return static_pointer_cast<PacketPayload>(
- static_pointer_cast<Meta>(
- StructureWrapper::get_shared_pointer(parent)));
+ return static_pointer_cast<PacketPayload>(get_shared_pointer(parent));
}
map<const ConfigKey *, Glib::VariantBase> Meta::get_config()
shared_ptr<PacketPayload> Logic::get_shared_pointer(Packet *parent)
{
- return static_pointer_cast<PacketPayload>(
- static_pointer_cast<Logic>(
- StructureWrapper::get_shared_pointer(parent)));
+ return static_pointer_cast<PacketPayload>(get_shared_pointer(parent));
}
void *Logic::get_data_pointer()
shared_ptr<PacketPayload> Analog::get_shared_pointer(Packet *parent)
{
- return static_pointer_cast<PacketPayload>(
- static_pointer_cast<Analog>(
- StructureWrapper::get_shared_pointer(parent)));
+ return static_pointer_cast<PacketPayload>(get_shared_pointer(parent));
}
float *Analog::get_data_pointer()
device = new InputDevice(shared_from_this(), sdi);
}
- return static_pointer_cast<InputDevice>(
- device->get_shared_pointer(shared_from_this()));
+ return device->get_shared_pointer(shared_from_this());
}
void Input::send(string data)
shared_ptr<Device> InputDevice::get_shared_from_this()
{
- return static_pointer_cast<Device>(
- static_pointer_cast<InputDevice>(shared_from_this()));
+ return static_pointer_cast<Device>(shared_from_this());
}
Option::Option(const struct sr_option *structure,
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());
}
};
/* Base template for most classes which wrap a struct type from libsigrok. */
-template <class Parent, typename Struct> class SR_API StructureWrapper
+template <class Class, class Parent, typename Struct>
+class SR_API StructureWrapper
{
protected:
/* Parent object which owns this child object's underlying structure.
shared_ptr<Parent> parent;
/* Weak pointer for shared_from_this() implementation. */
- weak_ptr<StructureWrapper<Parent, Struct> > weak_this;
+ weak_ptr<Class> weak_this;
public:
/* Note, this implementation will create a new smart_ptr if none exists. */
- shared_ptr<StructureWrapper<Parent, Struct> > shared_from_this()
+ shared_ptr<Class> shared_from_this()
{
- shared_ptr<StructureWrapper<Parent, Struct> > shared;
+ shared_ptr<Class> shared;
if (!(shared = weak_this.lock()))
{
- shared = shared_ptr<StructureWrapper<Parent, Struct> >(
- this, reset_parent);
+ 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);
return shared_from_this();
}
- shared_ptr<StructureWrapper<Parent, Struct> >
- get_shared_pointer(Parent *parent)
+ shared_ptr<Class> get_shared_pointer(Parent *parent)
{
if (!parent)
throw Error(SR_ERR_BUG);
- return get_shared_pointer(static_pointer_cast<Parent>(
- parent->shared_from_this()));
+ 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);
Struct *structure;
- StructureWrapper<Parent, Struct>(Struct *structure) :
+ StructureWrapper<Class, Parent, Struct>(Struct *structure) :
structure(structure)
{
}
};
/** 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 real hardware device, connected via a driver */
class SR_API HardwareDevice :
- public StructureWrapper<Context, struct sr_dev_inst>,
+ public StructureWrapper<HardwareDevice, Context, struct sr_dev_inst>,
public Device
{
public:
};
/** 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. */
/** Payload of a datafeed header packet */
class SR_API Header :
- public StructureWrapper<Packet, const struct sr_datafeed_header>,
+ public StructureWrapper<Header, Packet, const struct sr_datafeed_header>,
public PacketPayload
{
public:
/** Payload of a datafeed metadata packet */
class SR_API Meta :
- public StructureWrapper<Packet, const struct sr_datafeed_meta>,
+ public StructureWrapper<Meta, Packet, const struct sr_datafeed_meta>,
public PacketPayload
{
public:
/** Payload of a datafeed packet with logic data */
class SR_API Logic :
- public StructureWrapper<Packet, const struct sr_datafeed_logic>,
+ public StructureWrapper<Logic, Packet, const struct sr_datafeed_logic>,
public PacketPayload
{
public:
/** Payload of a datafeed packet with analog data */
class SR_API Analog :
- public StructureWrapper<Packet, const struct sr_datafeed_analog>,
+ public StructureWrapper<Analog, Packet, const struct sr_datafeed_analog>,
public PacketPayload
{
public:
/** An input format supported by the library */
class SR_API InputFormat :
- public StructureWrapper<Context, const struct sr_input_module>
+ public StructureWrapper<InputFormat, Context, const struct sr_input_module>
{
public:
/** Name of this input format. */
/** A virtual device associated with an input */
class SR_API InputDevice :
- public StructureWrapper<Input, struct sr_dev_inst>,
+ public StructureWrapper<InputDevice, Input, struct sr_dev_inst>,
public Device
{
protected:
/** 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. */
projects / libsigrok.git / commitdiff