C

MessageQueueInterface 类

类 Qul::Platform::MessageQueueInterface

提供特定平台队列的接口类，供 Qt Quick Ultralite 使用。更多...

头文件	#include <platform/messagequeue.h>
自	Qt Quick Ultralite (Platform) 1.9

所有成员的列表，包括继承成员

公共函数

虚拟	~MessageQueueInterface()
虚拟 uint32_t	capacity() const = 0
虚拟 void	clearOverrun() = 0
虚拟 bool	discardSupported() const = 0
虚拟 Qul::Platform::MessageQueueStatus	enqueueOrDiscard(const void *message) = 0
虚拟 Qul::Platform::MessageQueueStatus	enqueueOrDiscardFromInterrupt(const void *message)
虚拟 Qul::Platform::MessageQueueStatus	enqueueOrOverwrite(const void *message) = 0
虚拟 Qul::Platform::MessageQueueStatus	enqueueOrOverwriteFromInterrupt(const void *message)
虚拟 bool	isEmpty() const = 0
虚拟 bool	isEmptyFromInterrupt() const
虚拟 bool	isOverrun() const = 0
虚拟 bool	overwriteSupported() const = 0
虚拟 Qul::Platform::MessageQueueStatus	receive(void *message, int32_t timeout = 0) = 0
虚拟 Qul::Platform::MessageQueueStatus	receiveFromInterrupt(void *message, int32_t timeout = 0)

受保护函数

MessageQueueInterface()

详细描述

Qt Quick Ultralite 使用此接口实现 EventQueues 的队列。在有自己实现的队列（或操作系统提供的）时非常有用，并优于 Qt Quick Ultralite 提供的默认实现。

默认情况下，enqueueOrDiscardFromInterrupt()、enqueueOrOverwriteFromInterrupt() 和 receiveFromInterrupt() 会调用它们各自的非中断版本。除非底层队列功能是中断安全的或采取了确保中断安全的措施，否则这些函数必须被重写。*

通过从 discardSupported() 和 overwriteSupported() 函数返回布尔值来表示对丢弃和/或覆盖的支持。

注意：必须支持其中一个或两个操作，以确保事件队列能够按预期工作。

示例

MessageQueueInterface 是使用一个简单的环形缓冲区实现的。

队列实现不支持覆盖，因此所有无法推入队列的消息都会被丢弃。

子类可能看起来像这样

class MyMessageQueue : public MessageQueueInterface
{
public:
    MyMessageQueue(const uint32_t &capacity, const uint32_t &messageSize)
        : MessageQueueInterface()
        , mQueue(NULL)
        , mOverrunFlag(false)
    {
        void *memory = qul_malloc(sizeof(Private::CircularBuffer));
        mQueue = new (memory) Private::CircularBuffer(capacity, messageSize);
    }

    ~MyMessageQueue()
    {
        mQueue->~CircularBuffer();
        qul_free(mQueue);
    }

    MessageQueueStatus enqueueOrDiscard(const void *message) QUL_DECL_OVERRIDE
    {
        if (mQueue->isFull()) {
            // Discard message
            mOverrunFlag = true;
            return MessageQueueStatus::MessageDiscarded;
        }

        mQueue->pushBack(message);
        return MessageQueueStatus::Success;
    }

    MessageQueueStatus enqueueOrDiscardFromInterrupt(const void *message) QUL_DECL_OVERRIDE
    {
        // disableInterrupts();
        MessageQueueStatus state = enqueueOrDiscard(message);
        // enableInterrupts();
        return state;
    }

    MessageQueueStatus enqueueOrOverwrite(const void *message) QUL_DECL_OVERRIDE
    {
        return MessageQueueStatus::OverwriteNotSupported;
    }

    MessageQueueStatus receive(void *message, int32_t timeout = 0) QUL_DECL_OVERRIDE
    {
        (void) timeout; // This example does not implement timeout handling.

        if (mQueue->isEmpty())
            return MessageQueueStatus::EmptyQueue;

        mQueue->popFront(message);
        return MessageQueueStatus::Success;
    }

    MessageQueueStatus receiveFromInterrupt(void *message, int32_t timeout = 0) QUL_DECL_OVERRIDE
    {
        (void) timeout; // This example does not implement timeout handling.

        // disableInterrupts();
        MessageQueueStatus state = receive(message);
        // enableInterrupts();
        return state;
    }

    bool discardSupported() const QUL_DECL_OVERRIDE { return true; }
    bool overwriteSupported() const QUL_DECL_OVERRIDE { return false; }

    bool isEmpty() const QUL_DECL_OVERRIDE { return mQueue->isEmpty(); }
    bool isEmptyFromInterrupt() const QUL_DECL_OVERRIDE
    {
        // disableInterrupts();
        return isEmpty();
        // enableInterrupts();
    }

    bool isOverrun() const QUL_DECL_OVERRIDE { return mOverrunFlag; }

    void clearOverrun() QUL_DECL_OVERRIDE { mOverrunFlag = false; }

    uint32_t capacity() const QUL_DECL_OVERRIDE { return mQueue->capacity(); }

private:
    Private::CircularBuffer *mQueue;
    bool mOverrunFlag;
};

之后，实现 Qul::Platform::requestQueue() 函数

MessageQueueInterface *requestQueue(size_t queueCapacity, size_t messageSize)
{
    void *queue = qul_malloc(sizeof(MyMessageQueue));

    if (queue == NULL) {
        return NULL;
    }

    MessageQueueInterface *interface = new (queue) MyMessageQueue(queueCapacity, messageSize);
    return interface;
}

此外，实现 Qul::Platform::deleteQueue() 函数

void deleteQueue(MessageQueueInterface *queue)
{
    MyMessageQueue *mq = static_cast<MyMessageQueue *>(queue);
    mq->~MyMessageQueue();
    qul_free(mq);
}

最后，实现 Qul::Platform::maxQueueMessageSize()

size_t maximumQueueMessageSize()
{
    return LONG_MAX;
}

另请参阅：Qul::Platform::MessageQueue 和 Qul::EventQueue.