bindings: Use SR_DF_ANALOG, drop SR_DF_ANALOG_OLD support.

[libsigrok.git] / bindings / cxx / classes.cpp

diff --git a/bindings/cxx/classes.cpp b/bindings/cxx/classes.cpp
index 3e441f72252c2e4a34ebe30c303cd7a0e4b07a1c..d7ba79177033bbee9ea164c20d787066fb7330a2 100644 (file)
--- a/bindings/cxx/classes.cpp
+++ b/bindings/cxx/classes.cpp
@@ -319,21 +319,25 @@ shared_ptr<Packet> Context::create_logic_packet(
        return shared_ptr<Packet>(new Packet(nullptr, packet), Packet::Deleter());
 }
 
-shared_ptr<Packet> Context::create_analog_old_packet(
+shared_ptr<Packet> Context::create_analog_packet(
        vector<shared_ptr<Channel> > channels,
        float *data_pointer, unsigned int num_samples, const Quantity *mq,
        const Unit *unit, vector<const QuantityFlag *> mqflags)
 {
-       auto analog = g_new0(struct sr_datafeed_analog_old, 1);
+       auto analog = g_new0(struct sr_datafeed_analog, 1);
+       auto meaning = g_new0(struct sr_analog_meaning, 1);
+
+       analog->meaning = meaning;
+
        for (auto channel : channels)
-               analog->channels = g_slist_append(analog->channels, channel->_structure);
+               meaning->channels = g_slist_append(meaning->channels, channel->_structure);
        analog->num_samples = num_samples;
-       analog->mq = mq->id();
-       analog->unit = unit->id();
-       analog->mqflags = QuantityFlag::mask_from_flags(mqflags);
+       meaning->mq = (sr_mq)mq->id();
+       meaning->unit = (sr_unit)unit->id();
+       meaning->mqflags = (sr_mqflag)QuantityFlag::mask_from_flags(mqflags);
        analog->data = data_pointer;
        auto packet = g_new(struct sr_datafeed_packet, 1);
-       packet->type = SR_DF_ANALOG_OLD;
+       packet->type = SR_DF_ANALOG;
        packet->payload = analog;
        return shared_ptr<Packet>(new Packet(nullptr, packet), Packet::Deleter());
 }
@@ -1068,9 +1072,9 @@ Packet::Packet(shared_ptr<Device> device,
                                static_cast<const struct sr_datafeed_logic *>(
                                        structure->payload));
                        break;
-               case SR_DF_ANALOG_OLD:
-                       _payload = new AnalogOld(
-                               static_cast<const struct sr_datafeed_analog_old *>(
+               case SR_DF_ANALOG:
+                       _payload = new Analog(
+                               static_cast<const struct sr_datafeed_analog *>(
                                        structure->payload));
                        break;
                default:
@@ -1192,54 +1196,54 @@ unsigned int Logic::unit_size()
        return _structure->unitsize;
 }
 
-AnalogOld::AnalogOld(const struct sr_datafeed_analog_old *structure) :
+Analog::Analog(const struct sr_datafeed_analog *structure) :
        ParentOwned(structure),
        PacketPayload()
 {
 }
 
-AnalogOld::~AnalogOld()
+Analog::~Analog()
 {
 }
 
-shared_ptr<PacketPayload> AnalogOld::get_shared_pointer(Packet *_parent)
+shared_ptr<PacketPayload> Analog::get_shared_pointer(Packet *_parent)
 {
        return static_pointer_cast<PacketPayload>(
                ParentOwned::get_shared_pointer(_parent));
 }
 
-float *AnalogOld::data_pointer()
+void *Analog::data_pointer()
 {
        return _structure->data;
 }
 
-unsigned int AnalogOld::num_samples()
+unsigned int Analog::num_samples()
 {
        return _structure->num_samples;
 }
 
-vector<shared_ptr<Channel>> AnalogOld::channels()
+vector<shared_ptr<Channel>> Analog::channels()
 {
        vector<shared_ptr<Channel>> result;
-       for (auto l = _structure->channels; l; l = l->next)
+       for (auto l = _structure->meaning->channels; l; l = l->next)
                result.push_back(_parent->_device->get_channel(
                        (struct sr_channel *)l->data));
        return result;
 }
 
-const Quantity *AnalogOld::mq()
+const Quantity *Analog::mq()
 {
-       return Quantity::get(_structure->mq);
+       return Quantity::get(_structure->meaning->mq);
 }
 
-const Unit *AnalogOld::unit()
+const Unit *Analog::unit()
 {
-       return Unit::get(_structure->unit);
+       return Unit::get(_structure->meaning->unit);
 }
 
-vector<const QuantityFlag *> AnalogOld::mq_flags()
+vector<const QuantityFlag *> Analog::mq_flags()
 {
-       return QuantityFlag::flags_from_mask(_structure->mqflags);
+       return QuantityFlag::flags_from_mask(_structure->meaning->mqflags);
 }
 
 InputFormat::InputFormat(const struct sr_input_module *structure) :