queue.hpp

Go to the documentation of this file.

 
#ifndef CAMCOM_COMMON_FRAMEQUEUE_HPP
#define CAMCOM_COMMON_FRAMEQUEUE_HPP
 
#include <cstdint>
#include <iostream>
#include <mutex>
#include <queue>
#include <string>
#include <cmath>
#include <chrono>
 
#include "camcom/common/tools.hpp"
#include "ifw/fnd/defs/base.hpp"
 
namespace camcom::common {
 
    template <typename QueueType>
    class Queue {
        public:
            std::string m_queue_id;
            unsigned int m_max_size;
 
            Queue() {
                m_queue_id = "";
                m_max_size = 0;
            };
 
            Queue(unsigned int max_size, std::string id) {
                m_queue_id = id;
                m_max_size = max_size;
            };
 
 
            virtual size_t GetSize() {
                size_t size;
                const std::lock_guard<std::mutex> lock(m_mutex);
                size = m_queue.size();
                return size;
            }
 
            virtual void Clear() {
                FNDTRACE();
                std::queue<QueueType> new_queue = std::queue<QueueType>();
                const std::lock_guard<std::mutex> lock(m_mutex);
                std::swap(new_queue, m_queue);
            }
 
            virtual void Push(QueueType value) {
                FNDTRACE();
                auto size = GetSize();
                const std::lock_guard<std::mutex> lock(m_mutex);
 
                if (size == this->m_max_size) {
                    m_queue_full_push_count++;
 
                    if (common::TimeNow() - m_last_queue_full_push_err > m_log_full_push_timer) {
                        FNDWARNING(
                            "Queue full; first item lost; has occurred {} "
                            "times in last {}us",
                            m_queue_full_push_count,
                            std::chrono::duration_cast<std::chrono::microseconds>(
                                m_log_full_push_timer).count());
 
                        m_last_queue_full_push_err = common::TimeNow();
                        m_queue_full_push_count = 0;
                    }
 
                    m_queue.pop();
                }
 
                m_queue.push(value);
            }
 
            virtual bool Pop(QueueType &value) {
                FNDTRACE();
                const std::lock_guard<std::mutex> lock(m_mutex);
                if (m_queue.empty()) {
                    return false;
                }
                value = m_queue.front();
                m_queue.pop();
                return true;
            }
 
            virtual void Pop() {
                FNDTRACE();
                const std::lock_guard<std::mutex> lock(m_mutex);
                m_queue.pop();
            }
 
        protected:
          std::queue<QueueType> m_queue;
          std::chrono::time_point<std::chrono::system_clock>
              m_last_queue_full_push_err{common::TimeNow()};
          uint32_t m_queue_full_push_count{0};
          std::mutex m_mutex;
          std::chrono::duration<double_t> m_log_full_push_timer{std::chrono::duration<double_t>(10)};
    };
}
 
#endif