QueuingExporter.h

#pragma once

#include <deque>

#include <Poco/Event.h>
#include <Poco/Mutex.h>
#include <Poco/SharedPtr.h>

#include "core/Exporter.h"
#include "exporters/QueuingStrategy.h"
#include "model/SensorData.h"
#include "util/Loggable.h"

namespace BeeeOn {

class QueuingExporter : public Exporter, protected Loggable {
public:
        typedef Poco::SharedPtr<QueuingExporter> Ptr;

        QueuingExporter();
        ~QueuingExporter() override;

        bool ship(const SensorData &data) override;

        void setStrategy(const QueuingStrategy::Ptr strategy);

        void setSaveThreshold(const int dataCount);

        void setSaveTimeout(const Poco::Timespan &timeout);

        void setStrategyPriority(const int percent);

protected:
        void acquire(
                std::vector<SensorData> &data,
                size_t count,
                const Poco::Timespan &timeout);

        void ack();

        void reset();

        bool empty() const;

private:
        bool shouldSave() const;
        size_t queueSize() const;

        bool waitNotEmpty(const Poco::Timespan &timeout);

        void mix(
                std::vector<SensorData> &data,
                size_t count,
                size_t &acquired,
                size_t &peeked);

        size_t mixFromBackup(
                size_t requiredCount,
                size_t queueDataCount,
                size_t backupPriority,
                double remainder);

        void updateRemaindersAfterPeek(
                        size_t peeked,
                        size_t requiredToPeek,
                        double potentialRemainder);

        size_t mixFromQueue(size_t toAcquire, size_t queueDataCount);

        void saveQueue(size_t skipFirst);
        void doSaveQueue(size_t skipFirst);

private:
        mutable Poco::Mutex m_queueMutex;

        QueuingStrategy::Ptr m_strategy;

        Poco::Event m_notEmpty;

        uint32_t m_backupPriority;
        size_t m_saveThreshold;
        Poco::Timespan m_saveTimeout;

        size_t m_acquiredDataCount;
        size_t m_peekedDataCount;
        Poco::Timestamp m_lastExport;
        std::deque<SensorData> m_queue;

        bool m_acked;
        double m_mixRemainder;
        double m_previousMixRemainder;
};

}