MessageQueueThread.h

Go to the documentation of this file.

// This file is part of CoreLibrary containing useful reusable utility
// classes.
//
// Copyright (C) 2014 to present, Duncan Crutchley
// Contact <dac1976github@outlook.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License and GNU Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// and GNU Lesser General Public License along with this program. If
// not, see <http://www.gnu.org/licenses/>.

#ifndef MESSAGEQUEUETHREAD
#define MESSAGEQUEUETHREAD

#include "Platform/PlatformDefines.h"
#include <functional>
#include <map>
#include <stdexcept>
#include <boost/throw_exception.hpp>
#include "ThreadBase.h"
#include "ConcurrentQueue.h"

namespace core_lib
{
namespace threads
{

enum class eOnDestroyOptions
{
    ignoreRemainingItems,
    processRemainingItems
};
template <typename MessageId, typename MessageType>
class MessageQueueThread final : public ThreadBase
{
    using msg_id_decoder_t = std::function<MessageId(const MessageType&)>;
    using msg_deleter_t = std::function<void(MessageType&)>;

public:
    explicit MessageQueueThread(
        const msg_id_decoder_t& messageIdDecoder,
        eOnDestroyOptions       destroyOptions = eOnDestroyOptions::ignoreRemainingItems,
        const msg_deleter_t&    messageDeleter = msg_deleter_t())
        : m_msgIdDecoder{messageIdDecoder}
        , m_destroyOptions{destroyOptions}
        , m_messageDeleter{messageDeleter}
    {
        if (!Start())
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("ThreadBase::Start() returned false"));
        }
    }
    MessageQueueThread(const MessageQueueThread&) = delete;
    MessageQueueThread& operator=(const MessageQueueThread&) = delete;
    MessageQueueThread(MessageQueueThread&&) = delete;
    MessageQueueThread& operator=(MessageQueueThread&&) = delete;
    ~MessageQueueThread() override
    {
        Stop();

        while (!m_messageQueue.Empty())
        {
            switch (m_destroyOptions)
            {
            case eOnDestroyOptions::processRemainingItems:
                ProcessNextMessage();
                break;
            case eOnDestroyOptions::ignoreRemainingItems:
            default:
                DeleteNextMessage();
                break;
            }
        }
    }
    using msg_handler_t = std::function<bool(MessageType&)>;
    void RegisterMessageHandler(MessageId const& messageID, msg_handler_t const& messageHandler)
    {
        std::lock_guard<std::mutex> lock{m_mutex};

        if (m_msgHandlerMap.count(messageID) > 0)
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("message handler already defined"));
        }

        m_msgHandlerMap.emplace(messageID, messageHandler);
    }
    void Push(MessageType&& msg)
    {
        m_messageQueue.Push(std::forward<MessageType>(msg));
    }

private:
    void ThreadIteration() NO_EXCEPT_ override
    {
        ProcessNextMessage();
    }
    void ProcessTerminationConditions() NO_EXCEPT_ override
    {
        // Make sure we break out of m_messageQueue.Pop();
        m_messageQueue.BreakPopWait();
    }
    void ProcessNextMessage()
    {
        MessageType msg{};

        if (!m_messageQueue.Pop(msg))
        {
            return;
        }

        bool canDeleteMsg;

        try
        {
            MessageId                   messageId{m_msgIdDecoder(msg)};
            std::lock_guard<std::mutex> lock{m_mutex};

            if (m_msgHandlerMap.count(messageId) > 0)
            {
                canDeleteMsg = m_msgHandlerMap[messageId](msg);
            }
            else
            {
                canDeleteMsg = true;
            }
        }
        catch (...)
        {
            canDeleteMsg = true;
        }

        if (canDeleteMsg && m_messageDeleter)
        {
            try
            {
                m_messageDeleter(msg);
            }
            catch (...)
            {
                // Do nothing.
            }
        }
    }
    void DeleteNextMessage()
    {
        MessageType msg{};

        if (!m_messageQueue.Pop(msg))
        {
            return;
        }

        try
        {
            if (m_messageDeleter)
            {
                m_messageDeleter(msg);
            }
        }
        catch (...)
        {
            // Do nothing.
        }
    }

private:
    mutable std::mutex m_mutex;
    msg_id_decoder_t m_msgIdDecoder{};
    eOnDestroyOptions m_destroyOptions{};
    msg_deleter_t m_messageDeleter{};
    using msg_map_t = std::map<MessageId, msg_handler_t>;
    msg_map_t m_msgHandlerMap{};
    ConcurrentQueue<MessageType> m_messageQueue{};
};

} // namespace threads
} // namespace core_lib

#endif // MESSAGEQUEUETHREAD