X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=bindings%2Fcxx%2Finclude%2Flibsigrokcxx%2Flibsigrokcxx.hpp;h=3bebdd234936c246b7a559ad3569ce509d79629a;hb=HEAD;hp=a83600aa99753d9b4a5baf83ce95a4c4b7de5eaa;hpb=21d1bec60e6d69f6f2ef6f3dc3e07219153285c0;p=libsigrok.git diff --git a/bindings/cxx/include/libsigrokcxx/libsigrokcxx.hpp b/bindings/cxx/include/libsigrokcxx/libsigrokcxx.hpp index a83600aa..3bebdd23 100644 --- a/bindings/cxx/include/libsigrokcxx/libsigrokcxx.hpp +++ b/bindings/cxx/include/libsigrokcxx/libsigrokcxx.hpp @@ -71,8 +71,14 @@ raised, which provides access to the error code and description. #define LIBSIGROKCXX_HPP #include + +/* Suppress warnings due to glibmm's use of std::auto_ptr<> in a public + * header file. To be removed once glibmm is fixed. */ +G_GNUC_BEGIN_IGNORE_DEPRECATIONS #include +G_GNUC_END_IGNORE_DEPRECATIONS +#include #include #include #include @@ -82,8 +88,6 @@ raised, which provides access to the error code and description. namespace sigrok { -using namespace std; - /* Forward declarations */ class SR_API Error; class SR_API Context; @@ -93,6 +97,7 @@ class SR_API HardwareDevice; class SR_API Channel; class SR_API Session; class SR_API ConfigKey; +class SR_API Capability; class SR_API InputFormat; class SR_API OutputFormat; class SR_API OutputFlag; @@ -109,6 +114,7 @@ class SR_API PacketType; class SR_API Quantity; class SR_API Unit; class SR_API QuantityFlag; +class SR_API Rational; class SR_API Input; class SR_API InputDevice; class SR_API Output; @@ -117,7 +123,7 @@ class SR_API Option; class SR_API UserDevice; /** Exception thrown when an error code is returned by any libsigrok call. */ -class SR_API Error: public exception +class SR_API Error: public std::exception { public: explicit Error(int result); @@ -127,12 +133,12 @@ public: }; /* Base template for classes whose resources are owned by a parent object. */ -template +template class SR_API ParentOwned { private: /* Weak pointer for shared_from_this() implementation. */ - weak_ptr _weak_this; + std::weak_ptr _weak_this; static void reset_parent(Class *object) { @@ -155,37 +161,25 @@ protected: This strategy ensures that the destructors for both the child and the parent are called at the correct time, i.e. only when all references to both the parent and all its children are gone. */ - shared_ptr _parent; - - Struct *_structure; - - explicit ParentOwned(Struct *structure) : - _structure(structure) - { - } + std::shared_ptr _parent; -public: - /* Get parent object that owns this object. */ - shared_ptr parent() - { - return _parent; - } + ParentOwned() {} /* Note, this implementation will create a new smart_ptr if none exists. */ - shared_ptr shared_from_this() + std::shared_ptr shared_from_this() { - shared_ptr shared; + std::shared_ptr shared = _weak_this.lock(); - if (!(shared = _weak_this.lock())) + if (!shared) { - shared = shared_ptr(static_cast(this), reset_parent); + shared.reset(static_cast(this), &reset_parent); _weak_this = shared; } return shared; } - shared_ptr get_shared_pointer(shared_ptr parent) + std::shared_ptr share_owned_by(std::shared_ptr parent) { if (!parent) throw Error(SR_ERR_BUG); @@ -193,44 +187,32 @@ public: return shared_from_this(); } - shared_ptr get_shared_pointer(Parent *parent) +public: + /* Get parent object that owns this object. */ + std::shared_ptr parent() { - if (!parent) - throw Error(SR_ERR_BUG); - return get_shared_pointer(parent->shared_from_this()); + return _parent; } }; /* Base template for classes whose resources are owned by the user. */ -template -class SR_API UserOwned : public enable_shared_from_this +template +class SR_API UserOwned : public std::enable_shared_from_this { -public: - shared_ptr shared_from_this() +protected: + UserOwned() {} + + std::shared_ptr shared_from_this() { - auto shared = enable_shared_from_this::shared_from_this(); + auto shared = std::enable_shared_from_this::shared_from_this(); if (!shared) throw Error(SR_ERR_BUG); return shared; } -protected: - Struct *_structure; - - explicit UserOwned(Struct *structure) : - _structure(structure) - { - } - - /* Deleter needed to allow shared_ptr use with protected destructor. */ - class Deleter - { - public: - void operator()(Class *object) { delete object; } - }; }; /** Type of log callback */ -typedef function LogCallbackFunction; +typedef std::function LogCallbackFunction; /** Resource reader delegate. */ class SR_API ResourceReader @@ -240,7 +222,7 @@ public: virtual ~ResourceReader(); private: /** Resource open hook. */ - virtual void open(struct sr_resource *res, string name) = 0; + virtual void open(struct sr_resource *res, std::string name) = 0; /** Resource close hook. */ virtual void close(struct sr_resource *res) = 0; /** Resource read hook. */ @@ -250,27 +232,29 @@ private: const char *name, void *cb_data) noexcept; static SR_PRIV int close_callback(struct sr_resource *res, void *cb_data) noexcept; - static SR_PRIV ssize_t read_callback(const struct sr_resource *res, + static SR_PRIV gssize read_callback(const struct sr_resource *res, void *buf, size_t count, void *cb_data) noexcept; friend class Context; }; /** The global libsigrok context */ -class SR_API Context : public UserOwned +class SR_API Context : public UserOwned { public: /** Create new context */ - static shared_ptr create(); + static std::shared_ptr create(); /** libsigrok package version. */ - static string package_version(); + static std::string package_version(); /** libsigrok library version. */ - static string lib_version(); + static std::string lib_version(); /** Available hardware drivers, indexed by name. */ - map > drivers(); + std::map > drivers(); /** Available input formats, indexed by name. */ - map > input_formats(); + std::map > input_formats(); + /** Lookup the responsible input module for an input file. */ + std::shared_ptr input_format_match(std::string filename); /** Available output formats, indexed by name. */ - map > output_formats(); + std::map > output_formats(); /** Current log level. */ const LogLevel *log_level() const; /** Set the log level. @@ -285,59 +269,58 @@ public: * @param reader The resource reader delegate, or nullptr to unset. */ void set_resource_reader(ResourceReader *reader); /** Create a new session. */ - shared_ptr create_session(); + std::shared_ptr create_session(); /** Create a new user device. */ - shared_ptr create_user_device( - string vendor, string model, string version); + std::shared_ptr create_user_device( + std::string vendor, std::string model, std::string version); /** Create a header packet. */ - shared_ptr create_header_packet(Glib::TimeVal start_time); + std::shared_ptr create_header_packet(Glib::DateTime start_time); /** Create a meta packet. */ - shared_ptr create_meta_packet( - const map &config); + std::shared_ptr create_meta_packet( + std::map config); /** Create a logic packet. */ - shared_ptr create_logic_packet( + std::shared_ptr create_logic_packet( void *data_pointer, size_t data_length, unsigned int unit_size); /** Create an analog packet. */ - shared_ptr create_analog_packet( - const vector > &channels, - float *data_pointer, unsigned int num_samples, const Quantity *mq, - const Unit *unit, const vector &mqflags); + std::shared_ptr create_analog_packet( + std::vector > channels, + const float *data_pointer, unsigned int num_samples, const Quantity *mq, + const Unit *unit, std::vector mqflags); + /** Create an end packet. */ + std::shared_ptr create_end_packet(); /** Load a saved session. * @param filename File name string. */ - shared_ptr load_session(string filename); + std::shared_ptr load_session(std::string filename); /** Create a new trigger. * @param name Name string for new trigger. */ - shared_ptr create_trigger(string name); + std::shared_ptr create_trigger(std::string name); /** Open an input file. * @param filename File name string. */ - shared_ptr open_file(string filename); + std::shared_ptr open_file(std::string filename); /** Open an input stream based on header data. * @param header Initial data from stream. */ - shared_ptr open_stream(string header); - map serials(shared_ptr driver) const; + std::shared_ptr open_stream(std::string header); + std::map serials(std::shared_ptr driver) const; private: - map _drivers; - map _input_formats; - map _output_formats; + struct sr_context *_structure; + std::map > _drivers; + std::map > _input_formats; + std::map > _output_formats; Session *_session; LogCallbackFunction _log_callback; Context(); ~Context(); - friend class Deleter; friend class Session; friend class Driver; -}; - -enum Capability { - GET = SR_CONF_GET, - SET = SR_CONF_SET, - LIST = SR_CONF_LIST + friend struct std::default_delete; }; /** An object that can be configured. */ class SR_API Configurable { public: + /** Supported configuration keys. */ + std::set config_keys() const; /** Read configuration for the given key. * @param key ConfigKey to read. */ Glib::VariantBase config_get(const ConfigKey *key) const; @@ -348,10 +331,13 @@ public: /** Enumerate available values for the given configuration key. * @param key ConfigKey to enumerate values for. */ Glib::VariantContainerBase config_list(const ConfigKey *key) const; - /** Enumerate available keys, according to a given index key. */ - map > config_keys(const ConfigKey *key); - /** Check for a key in the list from a given index key. */ - bool config_check(const ConfigKey *key, const ConfigKey *index_key) const; + /** Enumerate configuration capabilities for the given configuration key. + * @param key ConfigKey to enumerate capabilities for. */ + std::set config_capabilities(const ConfigKey *key) const; + /** Check whether a configuration capability is supported for a given key. + * @param key ConfigKey to check. + * @param capability Capability to check for. */ + bool config_check(const ConfigKey *key, const Capability *capability) const; protected: Configurable( struct sr_dev_driver *driver, @@ -364,27 +350,29 @@ protected: }; /** A hardware driver provided by the library */ -class SR_API Driver : - public ParentOwned, - public Configurable +class SR_API Driver : public ParentOwned, public Configurable { public: /** Name of this driver. */ - string name() const; + std::string name() const; /** Long name for this driver. */ - string long_name() const; + std::string long_name() const; + /** Scan options supported by this driver. */ + std::set scan_options() const; /** Scan for devices and return a list of devices found. * @param options Mapping of (ConfigKey, value) pairs. */ - vector > scan( - const map &options = {}); + std::vector > scan(std::map + options = std::map()); private: + struct sr_dev_driver *_structure; bool _initialized; - vector _devices; + std::vector _devices; explicit Driver(struct sr_dev_driver *structure); ~Driver(); friend class Context; friend class HardwareDevice; friend class ChannelGroup; + friend struct std::default_delete; }; /** A generic device, either hardware or virtual */ @@ -392,19 +380,19 @@ class SR_API Device : public Configurable { public: /** Vendor name for this device. */ - string vendor() const; + std::string vendor() const; /** Model name for this device. */ - string model() const; + std::string model() const; /** Version string for this device. */ - string version() const; + std::string version() const; /** Serial number for this device. */ - string serial_number() const; + std::string serial_number() const; /** Connection ID for this device. */ - string connection_id() const; + std::string connection_id() const; /** List of the channels available on this device. */ - vector > channels(); + std::vector > channels(); /** Channel groups available on this device, indexed by name. */ - map > channel_groups(); + std::map > channel_groups(); /** Open device. */ void open(); /** Close device. */ @@ -412,83 +400,68 @@ public: protected: explicit Device(struct sr_dev_inst *structure); ~Device(); - virtual shared_ptr get_shared_from_this() = 0; - shared_ptr get_channel(struct sr_channel *ptr); + virtual std::shared_ptr get_shared_from_this() = 0; + std::shared_ptr get_channel(struct sr_channel *ptr); struct sr_dev_inst *_structure; - map _channels; + std::map > _channels; private: - map _channel_groups; - /** Deleter needed to allow shared_ptr use with protected destructor. */ - class Deleter - { - public: - void operator()(Device *device) { delete device; } - }; - friend class Deleter; + std::map > _channel_groups; + friend class Session; friend class Channel; friend class ChannelGroup; friend class Output; friend class Analog; + friend struct std::default_delete; }; /** A real hardware device, connected via a driver */ class SR_API HardwareDevice : - public UserOwned, + public UserOwned, public Device { public: /** Driver providing this device. */ - shared_ptr driver(); + std::shared_ptr driver(); private: - HardwareDevice(shared_ptr driver, struct sr_dev_inst *structure); + HardwareDevice(std::shared_ptr driver, struct sr_dev_inst *structure); ~HardwareDevice(); - shared_ptr get_shared_from_this(); - shared_ptr _driver; - /** Deleter needed to allow shared_ptr use with protected destructor. */ - class Deleter - { - public: - void operator()(HardwareDevice *device) { delete device; } - }; - friend class Deleter; + std::shared_ptr get_shared_from_this(); + std::shared_ptr _driver; + friend class Driver; friend class ChannelGroup; + friend struct std::default_delete; }; /** A virtual device, created by the user */ class SR_API UserDevice : - public UserOwned, + public UserOwned, public Device { public: /** Add a new channel to this device. */ - shared_ptr add_channel(unsigned int index, const ChannelType *type, string name); + std::shared_ptr add_channel(unsigned int index, const ChannelType *type, std::string name); private: - UserDevice(string vendor, string model, string version); + UserDevice(std::string vendor, std::string model, std::string version); ~UserDevice(); - shared_ptr get_shared_from_this(); - /** Deleter needed to allow shared_ptr use with protected destructor. */ - class Deleter - { - public: - void operator()(UserDevice *device) { delete device; } - }; + std::shared_ptr get_shared_from_this(); + friend class Context; - friend class Deleter; + friend struct std::default_delete; }; /** A channel on a device */ class SR_API Channel : - public ParentOwned + public ParentOwned { public: /** Current name of this channel. */ - string name() const; + std::string name() const; /** Set the name of this channel. * * @param name Name string to set. */ - void set_name(string name); + void set_name(std::string name); /** Type of this channel. */ const ChannelType *type() const; /** Enabled status of this channel. */ @@ -501,6 +474,7 @@ public: private: explicit Channel(struct sr_channel *structure); ~Channel(); + struct sr_channel *_structure; const ChannelType * const _type; friend class Device; friend class UserDevice; @@ -508,93 +482,100 @@ private: friend class Session; friend class TriggerStage; friend class Context; + friend struct std::default_delete; }; /** A group of channels on a device, which share some configuration */ class SR_API ChannelGroup : - public ParentOwned, + public ParentOwned, public Configurable { public: /** Name of this channel group. */ - string name() const; + std::string name() const; /** List of the channels in this group. */ - vector > channels(); + std::vector > channels(); private: - ChannelGroup(Device *device, struct sr_channel_group *structure); + ChannelGroup(const Device *device, struct sr_channel_group *structure); ~ChannelGroup(); - vector _channels; + std::vector _channels; friend class Device; + friend struct std::default_delete; }; /** A trigger configuration */ -class SR_API Trigger : public UserOwned +class SR_API Trigger : public UserOwned { public: /** Name of this trigger configuration. */ - string name() const; + std::string name() const; /** List of the stages in this trigger. */ - vector > stages(); + std::vector > stages(); /** Add a new stage to this trigger. */ - shared_ptr add_stage(); + std::shared_ptr add_stage(); private: - Trigger(shared_ptr context, string name); + Trigger(std::shared_ptr context, std::string name); ~Trigger(); - shared_ptr _context; - vector _stages; - friend class Deleter; + struct sr_trigger *_structure; + std::shared_ptr _context; + std::vector > _stages; friend class Context; friend class Session; + friend struct std::default_delete; }; /** A stage in a trigger configuration */ class SR_API TriggerStage : - public ParentOwned + public ParentOwned { public: /** Index number of this stage. */ int number() const; /** List of match conditions on this stage. */ - vector > matches(); + std::vector > matches(); /** Add a new match condition to this stage. * @param channel Channel to match on. * @param type TriggerMatchType to apply. */ - void add_match(shared_ptr channel, const TriggerMatchType *type); + void add_match(std::shared_ptr channel, const TriggerMatchType *type); /** Add a new match condition to this stage. * @param channel Channel to match on. * @param type TriggerMatchType to apply. * @param value Threshold value. */ - void add_match(shared_ptr channel, const TriggerMatchType *type, float value); + void add_match(std::shared_ptr channel, const TriggerMatchType *type, float value); private: - vector _matches; + struct sr_trigger_stage *_structure; + std::vector > _matches; explicit TriggerStage(struct sr_trigger_stage *structure); ~TriggerStage(); friend class Trigger; + friend struct std::default_delete; }; /** A match condition in a trigger configuration */ class SR_API TriggerMatch : - public ParentOwned + public ParentOwned { public: /** Channel this condition matches on. */ - shared_ptr channel(); + std::shared_ptr channel(); /** Type of match. */ const TriggerMatchType *type() const; /** Threshold value. */ float value() const; private: - TriggerMatch(struct sr_trigger_match *structure, shared_ptr channel); + TriggerMatch(struct sr_trigger_match *structure, std::shared_ptr channel); ~TriggerMatch(); - shared_ptr _channel; + struct sr_trigger_match *_structure; + std::shared_ptr _channel; friend class TriggerStage; + friend struct std::default_delete; }; /** Type of session stopped callback */ -typedef function SessionStoppedCallback; +typedef std::function SessionStoppedCallback; /** Type of datafeed callback */ -typedef function, shared_ptr)> +typedef std::function, std::shared_ptr)> DatafeedCallbackFunction; /* Data required for C callback function to call a C++ datafeed callback */ @@ -613,32 +594,27 @@ private: /** A virtual device associated with a stored session */ class SR_API SessionDevice : - public ParentOwned, + public ParentOwned, public Device { private: explicit SessionDevice(struct sr_dev_inst *sdi); ~SessionDevice(); - shared_ptr get_shared_from_this(); - /** Deleter needed to allow shared_ptr use with protected destructor. */ - class Deleter - { - public: - void operator()(SessionDevice *device) { delete device; } - }; - friend class Deleter; + std::shared_ptr get_shared_from_this(); + friend class Session; + friend struct std::default_delete; }; /** A sigrok session */ -class SR_API Session : public UserOwned +class SR_API Session : public UserOwned { public: /** Add a device to this session. * @param device Device to add. */ - void add_device(shared_ptr device); + void add_device(std::shared_ptr device); /** List devices attached to this session. */ - vector > devices(); + std::vector > devices(); /** Remove all devices from this session. */ void remove_devices(); /** Add a datafeed callback to this session. @@ -657,47 +633,50 @@ public: /** Set callback to be invoked on session stop. */ void set_stopped_callback(SessionStoppedCallback callback); /** Get current trigger setting. */ - shared_ptr trigger(); + std::shared_ptr trigger(); /** Get the context. */ - shared_ptr context(); + std::shared_ptr context(); /** Set trigger setting. * @param trigger Trigger object to use. */ - void set_trigger(shared_ptr trigger); + void set_trigger(std::shared_ptr trigger); /** Get filename this session was loaded from. */ - string filename() const; + std::string filename() const; private: - explicit Session(shared_ptr context); - Session(shared_ptr context, string filename); + explicit Session(std::shared_ptr context); + Session(std::shared_ptr context, std::string filename); ~Session(); - shared_ptr get_device(const struct sr_dev_inst *sdi); - const shared_ptr _context; - map _owned_devices; - map > _other_devices; - vector _datafeed_callbacks; + std::shared_ptr get_device(const struct sr_dev_inst *sdi); + struct sr_session *_structure; + const std::shared_ptr _context; + std::map > _owned_devices; + std::map > _other_devices; + std::vector > _datafeed_callbacks; SessionStoppedCallback _stopped_callback; - string _filename; - shared_ptr _trigger; - friend class Deleter; + std::string _filename; + std::shared_ptr _trigger; + friend class Context; friend class DatafeedCallbackData; friend class SessionDevice; + friend struct std::default_delete; }; /** A packet on the session datafeed */ -class SR_API Packet : public UserOwned +class SR_API Packet : public UserOwned { public: /** Type of this packet. */ const PacketType *type() const; /** Payload of this packet. */ - shared_ptr payload(); + std::shared_ptr payload(); private: - Packet(shared_ptr device, + Packet(std::shared_ptr device, const struct sr_datafeed_packet *structure); ~Packet(); - shared_ptr _device; - PacketPayload *_payload; - friend class Deleter; + const struct sr_datafeed_packet *_structure; + std::shared_ptr _device; + std::unique_ptr _payload; + friend class Session; friend class Output; friend class DatafeedCallbackData; @@ -706,6 +685,7 @@ private: friend class Logic; friend class Analog; friend class Context; + friend struct std::default_delete; }; /** Abstract base class for datafeed packet payloads */ @@ -714,49 +694,56 @@ class SR_API PacketPayload protected: PacketPayload(); virtual ~PacketPayload() = 0; - virtual shared_ptr get_shared_pointer(Packet *parent) = 0; +private: + virtual std::shared_ptr share_owned_by(std::shared_ptr parent) = 0; - friend class Deleter; friend class Packet; friend class Output; + friend struct std::default_delete; }; /** Payload of a datafeed header packet */ class SR_API Header : - public ParentOwned, + public ParentOwned, public PacketPayload { public: /* Feed version number. */ int feed_version() const; /* Start time of this session. */ - Glib::TimeVal start_time() const; + Glib::DateTime start_time() const; private: explicit Header(const struct sr_datafeed_header *structure); ~Header(); - shared_ptr get_shared_pointer(Packet *parent); + std::shared_ptr share_owned_by(std::shared_ptr parent); + + const struct sr_datafeed_header *_structure; + friend class Packet; }; /** Payload of a datafeed metadata packet */ class SR_API Meta : - public ParentOwned, + public ParentOwned, public PacketPayload { public: /* Mapping of (ConfigKey, value) pairs. */ - map config() const; + std::map config() const; private: explicit Meta(const struct sr_datafeed_meta *structure); ~Meta(); - shared_ptr get_shared_pointer(Packet *parent); - map _config; + std::shared_ptr share_owned_by(std::shared_ptr parent); + + const struct sr_datafeed_meta *_structure; + std::map _config; + friend class Packet; }; /** Payload of a datafeed packet with logic data */ class SR_API Logic : - public ParentOwned, + public ParentOwned, public PacketPayload { public: @@ -769,145 +756,253 @@ public: private: explicit Logic(const struct sr_datafeed_logic *structure); ~Logic(); - shared_ptr get_shared_pointer(Packet *parent); + std::shared_ptr share_owned_by(std::shared_ptr parent); + + const struct sr_datafeed_logic *_structure; + friend class Packet; + friend class Analog; + friend struct std::default_delete; }; /** Payload of a datafeed packet with analog data */ class SR_API Analog : - public ParentOwned, + public ParentOwned, public PacketPayload { public: /** Pointer to data. */ void *data_pointer(); + /** + * Fills dest pointer with the analog data converted to float. + * The pointer must have space for num_samples() floats. + */ + void get_data_as_float(float *dest); /** Number of samples in this packet. */ unsigned int num_samples() const; /** Channels for which this packet contains data. */ - vector > channels(); + std::vector > channels(); + /** Size of a single sample in bytes. */ + unsigned int unitsize() const; + /** Samples use a signed data type. */ + bool is_signed() const; + /** Samples use float. */ + bool is_float() const; + /** Samples are stored in big-endian order. */ + bool is_bigendian() const; + /** + * Number of significant digits after the decimal point, if positive. + * When negative, exponent with reversed polarity that is necessary to + * express the value with all digits without a decimal point. + * Refers to the value we actually read on the wire. + * + * Examples: + * + * | On the wire | Exponential notation | Exp. not. (normalized) | digits | + * |-------------|----------------------|------------------------|--------| + * | 12.34 MOhm | 1.234 * 10^7 Ohm | 1234 * 10^4 Ohm | -4 | + * | 1.2345 MOhm | 1.2345 * 10^6 Ohm | 12345 * 10^2 Ohm | -2 | + * | 123.4 kOhm | 1.234 * 10^5 Ohm | 1234 * 10^2 Ohm | -2 | + * | 1234 Ohm | 1.234 * 10^3 Ohm | 1234 * 10^0 Ohm | 0 | + * | 12.34 Ohm | 1.234 * 10^1 Ohm | 1234 * 10^-2 Ohm | 2 | + * | 0.0123 Ohm | 1.23 * 10^-2 Ohm | 123 * 10^-4 Ohm | 4 | + * | 1.234 pF | 1.234 * 10^-12 F | 1234 * 10^-15 F | 15 | + */ + int digits() const; + /** TBD */ + bool is_digits_decimal() const; + /** TBD */ + std::shared_ptr scale(); + /** TBD */ + std::shared_ptr offset(); /** Measured quantity of the samples in this packet. */ const Quantity *mq() const; /** Unit of the samples in this packet. */ const Unit *unit() const; /** Measurement flags associated with the samples in this packet. */ - vector mq_flags() const; + std::vector mq_flags() const; + /** + * Provides a Logic packet that contains a conversion of the analog + * data using a simple threshold. + * + * @param threshold Threshold to use. + * @param data_ptr Pointer to num_samples() bytes where the logic + * samples are stored. When nullptr, memory for + * logic->data_pointer() will be allocated and must + * be freed by the caller. + */ + std::shared_ptr get_logic_via_threshold(float threshold, + uint8_t *data_ptr=nullptr) const; + /** + * Provides a Logic packet that contains a conversion of the analog + * data using a Schmitt-Trigger. + * + * @param lo_thr Low threshold to use (anything below this is low). + * @param hi_thr High threshold to use (anything above this is high). + * @param state Points to a byte that contains the current state of the + * converter. For best results, set to value of logic + * sample n-1. + * @param data_ptr Pointer to num_samples() bytes where the logic + * samples are stored. When nullptr, memory for + * logic->data_pointer() will be allocated and must be + * freed by the caller. + */ + std::shared_ptr get_logic_via_schmitt_trigger(float lo_thr, + float hi_thr, uint8_t *state, uint8_t *data_ptr=nullptr) const; private: explicit Analog(const struct sr_datafeed_analog *structure); ~Analog(); - shared_ptr get_shared_pointer(Packet *parent); + std::shared_ptr share_owned_by(std::shared_ptr parent); + + const struct sr_datafeed_analog *_structure; + friend class Packet; }; +/** Number represented by a numerator/denominator integer pair */ +class SR_API Rational : + public ParentOwned +{ +public: + /** Numerator, i.e. the dividend. */ + int64_t numerator() const; + /** Denominator, i.e. the divider. */ + uint64_t denominator() const; + /** Actual (lossy) value. */ + float value() const; +private: + explicit Rational(const struct sr_rational *structure); + ~Rational(); + std::shared_ptr share_owned_by(std::shared_ptr parent); + + const struct sr_rational *_structure; + + friend class Analog; + friend struct std::default_delete; +}; + /** An input format supported by the library */ class SR_API InputFormat : - public ParentOwned + public ParentOwned { public: /** Name of this input format. */ - string name() const; + std::string name() const; /** Description of this input format. */ - string description() const; + std::string description() const; /** A list of preferred file name extensions for this file format. - * @note This list is a recommendation only. */ - vector extensions() const; + * @note This list is a recommendation only. */ + std::vector extensions() const; /** Options supported by this input format. */ - map > options(); + std::map > options(); /** Create an input using this input format. * @param options Mapping of (option name, value) pairs. */ - shared_ptr create_input(const map &options = {}); + std::shared_ptr create_input(std::map + options = std::map()); private: explicit InputFormat(const struct sr_input_module *structure); ~InputFormat(); + + const struct sr_input_module *_structure; + friend class Context; friend class InputDevice; + friend struct std::default_delete; }; /** An input instance (an input format applied to a file or stream) */ -class SR_API Input : public UserOwned +class SR_API Input : public UserOwned { public: /** Virtual device associated with this input. */ - shared_ptr device(); + std::shared_ptr device(); /** Send next stream data. * @param data Next stream data. * @param length Length of data. */ void send(void *data, size_t length); /** Signal end of input data. */ void end(); + void reset(); private: - Input(shared_ptr context, const struct sr_input *structure); + Input(std::shared_ptr context, const struct sr_input *structure); ~Input(); - shared_ptr _context; - InputDevice *_device; - friend class Deleter; + const struct sr_input *_structure; + std::shared_ptr _context; + std::unique_ptr _device; + friend class Context; friend class InputFormat; + friend struct std::default_delete; }; /** A virtual device associated with an input */ class SR_API InputDevice : - public ParentOwned, + public ParentOwned, public Device { private: - InputDevice(shared_ptr input, struct sr_dev_inst *sdi); + InputDevice(std::shared_ptr input, struct sr_dev_inst *sdi); ~InputDevice(); - shared_ptr get_shared_from_this(); - shared_ptr _input; + std::shared_ptr get_shared_from_this(); + std::shared_ptr _input; friend class Input; + friend struct std::default_delete; }; /** An option used by an output format */ -class SR_API Option : public UserOwned +class SR_API Option : public UserOwned