Method enqueue

src/core/AsyncLogWriter.cpp:205–251

}

void AsyncLogWriter::enqueue(QtMsgType type,
                             const QTime& timestamp,
                             const QString& category,
                             const QString& message)
{
    {
        std::lock_guard lock(m_mutex);
        if (!m_started || !m_accepting)
            return;

        if (m_queue.size() >= kMaxQueueEntries) {
            if (isDebugOrInfo(type)) {
                ++m_counters.droppedDebugInfoLines;
                ++m_pendingDroppedDebugInfo;
                m_cv.notify_one();
                return;
            }

            auto dropIt = std::find_if(m_queue.begin(), m_queue.end(),
                [](const QueueItem& item) {
                    return item.kind == ItemKind::Log && isDebugOrInfo(item.log.type);
                });
            if (dropIt != m_queue.end()) {
                m_queue.erase(dropIt);
                ++m_counters.droppedDebugInfoLines;
                ++m_pendingDroppedDebugInfo;
            } else if (m_queue.size() >= kHardMaxQueueEntries) {
                ++m_counters.droppedHighPriorityLines;
                ++m_pendingDroppedHighPriority;
                m_cv.notify_one();
                return;
            }
        }

        QueueItem item;
        item.kind = ItemKind::Log;
        item.log.type = type;
        item.log.timestamp = timestamp;
        item.log.category = category;
        item.log.message = message;
        m_queue.push_back(std::move(item));

        ++m_counters.queuedLines;
        m_counters.maxQueueDepth = std::max<quint64>(m_counters.maxQueueDepth, m_queue.size());
    }
    m_cv.notify_one();
}

void AsyncLogWriter::flush()
{