concurrent_queue.h

#ifndef CONCURRENT_QUEUE_H
#define CONCURRENT_QUEUE_H
 
#include <mutex>
#include <queue>
#include <atomic>
 
namespace ara
{
    namespace com
    {
        namespace helper
        {
            template <typename T>
            class ConcurrentQueue
            {
            private:
                std::mutex mMutex;
                std::queue<T> mQueue;
                std::atomic_size_t mSize;
 
            public:
                ConcurrentQueue() : mSize{0}
                {
                }
 
                ~ConcurrentQueue() = default;
 
                bool Empty() const noexcept
                {
                    return mSize == 0;
                }
 
                bool TryEnqueue(T &&element)
                {
                    std::unique_lock<std::mutex> _lock(mMutex, std::defer_lock);
                    if (_lock.try_lock())
                    {
                        mQueue.emplace(std::move(element));
                        ++mSize;
                        _lock.unlock();
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
 
                bool TryEnqueue(const T &element)
                {
                    std::unique_lock<std::mutex> _lock(mMutex, std::defer_lock);
                    if (_lock.try_lock())
                    {
                        mQueue.emplace(element);
                        ++mSize;
                        _lock.unlock();
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
 
                bool TryDequeue(T &element)
                {
                    std::unique_lock<std::mutex> _lock(mMutex, std::defer_lock);
                    if (_lock.try_lock())
                    {
                        element = std::move(mQueue.front());
                        mQueue.pop();
                        --mSize;
                        _lock.unlock();
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            };
        }
    }
}
 
#endif