Fifo.hpp

Go to the documentation of this file.

#include <etk/types.hpp>

#pragma once

#include <mutex>
#include <vector>
#include <condition_variable>

namespace etk {
    template<class MY_TYPE=int32_t> class Fifo {
        private :
            std::mutex m_mutex; 
            std::condition_variable m_condition; 
            std::vector<MY_TYPE> m_data; 
        public :
            Fifo() {
                // nothing to do ...
            };
            ~Fifo() {
                // nothing to do ...
            };
            bool wait(MY_TYPE &_data) {
                std::unique_lock<std::mutex> lock(m_mutex);
                // Check if data is not previously here
                while(m_data.size() == 0) {
                    m_condition.wait(lock);
                }
                // End Waiting message :
                if (m_data.size() > 0) {
                    // copy element :
                    std::swap(_data, m_data[0]);
                    // remove element :
                    m_data.erase(m_data.begin());
                    return true;
                }
                return false;
            };
            bool wait(MY_TYPE &_data, uint32_t _timeOutInUs) {
                std::unique_lock<std::mutex> lock(m_mutex);
                // Check if data is not previously here
                while(m_data.size() == 0) {
                    if (m_condition.wait_for(lock, std::chrono::microseconds(_timeOutInUs)) == std::cv_status::timeout) {
                        return false;
                    }
                }
                // End Waiting message :
                if (m_data.size() > 0) {
                    // copy element :
                    std::swap(_data, m_data[0]);
                    // remove element :
                    m_data.erase(0);
                    return true;
                }
                return false;
            };
            int32_t count() {
                std::unique_lock<std::mutex> lock(m_mutex);
                int32_t nbElement = m_data.size();
                return nbElement;
            };
            void post(MY_TYPE &_data) {
                std::unique_lock<std::mutex> lock(m_mutex);
                m_data.push_back(_data);
                m_condition.notify_all();
            };
            void post(const MY_TYPE &_data) {
                std::unique_lock<std::mutex> lock(m_mutex);
                m_data.push_back(_data);
                m_condition.notify_all();
            };
            void clean() {
                std::unique_lock<std::mutex> lock(m_mutex);
                // remove data
                m_data.clear();
                m_condition.wait_for(lock, std::chrono::microseconds(0));
            };
    };
}