MeasurementSignalQueue.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#include <duds/hardware/MeasurementSignalSink.hpp>
#include <duds/general/Spinlock.hpp>
#include <utility>

namespace duds { namespace hardware {

template <
    class SVT,
    class SQT,
    class TVT,
    class TQT,
    template <typename, typename ...> class IS = std::shared_ptr,
    typename... ISArgs
>
class GenericMeasurementSignalQueue :
    public GenericMeasurementSignalSink<SVT, SQT, TVT, TQT>
{
public:
    typedef GenericInstrument<SVT, SQT, TVT, TQT>  Instrument;
    typedef duds::data::GenericMeasurement<SVT, SQT, TVT, TQT> Measurement;
    enum EventType {
        NewMeasurement,
        OldMeasurement
    };
    struct SignalData {
        IS<Instrument, ISArgs ...> insturment;
        std::shared_ptr<const Measurement> measurement;
        EventType type;
        SignalData() = default;
        SignalData(
            const IS<Instrument> &i,
            const std::shared_ptr<const Measurement> &m,
            EventType e
        ) : insturment(i), measurement(m), type(e) { }
    };
    typedef std::list<SignalData>  EventList;
private:
    EventList events;
    mutable duds::general::Spinlock block;
protected:
    void handleNewMeasure(
        const std::shared_ptr<Instrument> &i,
        const std::shared_ptr<const Measurement> &m
    ) {
        std::lock_guard<duds::general::Spinlock> lock(block);
        events.emplace_back(i, m, NewMeasurement);
    }
    void handleOldMeasure(
        const std::shared_ptr<Instrument> &i,
        const std::shared_ptr<const Measurement> &m
    ) {
        std::lock_guard<duds::general::Spinlock> lock(block);
        events.emplace_back(i, m, OldMeasurement);
    }
public:
    GenericMeasurementSignalQueue() = default;
    GenericMeasurementSignalQueue(const GenericMeasurementSignalQueue &sq) {
        std::lock_guard<duds::general::Spinlock> lock(sq.block);
        events = sq.events;
    }
    GenericMeasurementSignalQueue(GenericMeasurementSignalQueue &&sq) {
        std::lock_guard<duds::general::Spinlock> lock(sq.block);
        events = std::move(sq.events);
    }
    GenericMeasurementSignalQueue &operator = (
        const GenericMeasurementSignalQueue &sq
    ) {
        std::unique_lock<duds::general::Spinlock> lock0(block, std::defer_lock);
        std::unique_lock<duds::general::Spinlock> lock1(sq.block, std::defer_lock);
        std::lock(lock0, lock1);
        events = sq.events;
    }
    GenericMeasurementSignalQueue &operator = (
        GenericMeasurementSignalQueue &&sq
    ) {
        std::unique_lock<duds::general::Spinlock> lock0(block, std::defer_lock);
        std::unique_lock<duds::general::Spinlock> lock1(sq.block, std::defer_lock);
        std::lock(lock0, lock1);
        events = std::move(sq.events);
    }
    void swap(GenericMeasurementSignalQueue &sq) {
        std::unique_lock<duds::general::Spinlock> lock0(block, std::defer_lock);
        std::unique_lock<duds::general::Spinlock> lock1(sq.block, std::defer_lock);
        std::lock(lock0, lock1);
        events.swap(sq.events);
    }
    EventList copy() const {
        EventList copy;
        {
            std::lock_guard<duds::general::Spinlock> lock(block);
            copy = events;
        }
        return copy;
    }
    void copy(EventList &copy) const {
        std::lock_guard<duds::general::Spinlock> lock(block);
        copy = events;
    }
    EventList move() {
        EventList copy;
        {
            std::lock_guard<duds::general::Spinlock> lock(block);
            copy = std::move(events);
        }
        return copy;
    }
    void move(EventList &copy) {
        std::lock_guard<duds::general::Spinlock> lock(block);
        copy = std::move(events);
    }
    void pushBack(const SignalData &sd) {
        std::lock_guard<duds::general::Spinlock> lock(block);
        events.push_back(sd);
    }
    void pushFront(const SignalData &sd) {
        std::lock_guard<duds::general::Spinlock> lock(block);
        events.push_front(sd);
    }
    SignalData popBack() {
        SignalData sd;
        {
            std::lock_guard<duds::general::Spinlock> lock(block);
            sd = std::move(events.back());
            events.pop_back();
        }
        return sd;
    }
    SignalData popFront() {
        SignalData sd;
        {
            std::lock_guard<duds::general::Spinlock> lock(block);
            sd = std::move(events.front());
            events.pop_front();
        }
        return sd;
    }
    void clear() {
        std::lock_guard<duds::general::Spinlock> lock(block);
        events.clear();
    }
};

template <
    class SVT,
    class SQT,
    class TVT,
    class TQT,
    template <typename> class IS,
    typename ... ISArgs
>
void swap(
    GenericMeasurementSignalQueue<SVT, SQT, TVT, TQT, IS, ISArgs ...> &sq0,
    GenericMeasurementSignalQueue<SVT, SQT, TVT, TQT, IS, ISArgs ...> &sq1
) {
    sq0.swap(sq1);
}

typedef GenericMeasurementSignalQueue<
    duds::data::GenericValue,
    double,
    duds::time::interstellar::NanoTime,
    float
> MeasurementSignalQueue;

} }