/***************************************************************************
- * Copyright (C) 2005-2018 by the Quassel Project *
+ * Copyright (C) 2005-2020 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
#ifndef QTUIMESSAGEPROCESSOR_H_
#define QTUIMESSAGEPROCESSOR_H_
+#include <utility>
+
#include <QTimer>
#include "abstractmessageprocessor.h"
#include "expressionmatch.h"
+#include "nickhighlightmatcher.h"
class QtUiMessageProcessor : public AbstractMessageProcessor
{
Q_OBJECT
public:
- enum Mode {
+ enum Mode
+ {
TimerBased,
Concurrent
};
- QtUiMessageProcessor(QObject *parent);
+ QtUiMessageProcessor(QObject* parent);
inline bool isProcessing() const { return _processing; }
inline Mode processMode() const { return _processMode; }
- void reset();
+ void reset() override;
public slots:
- void process(Message &msg);
- void process(QList<Message> &msgs);
+ void process(Message& msg) override;
+ void process(QList<Message>& msgs) override;
+
+ /**
+ * Network removed from system
+ *
+ * Handles cleaning up cache from stale networks.
+ *
+ * @param id Network ID of removed network
+ */
+ void networkRemoved(NetworkId id) override;
private slots:
void processNextMessage();
- void nicksCaseSensitiveChanged(const QVariant &variant);
- void highlightListChanged(const QVariant &variant);
- void highlightNickChanged(const QVariant &variant);
+ void nicksCaseSensitiveChanged(const QVariant& variant);
+ void highlightListChanged(const QVariant& variant);
+ void highlightNickChanged(const QVariant& variant);
private:
/**
/**
* Construct an empty highlight rule
*/
- LegacyHighlightRule() {}
+ LegacyHighlightRule() = default;
/**
* Construct a highlight rule with the given parameters
* @param isEnabled True if enabled, otherwise false
* @param chanName String representing a channel name expression to match
*/
- LegacyHighlightRule(QString contents, bool isRegEx, bool isCaseSensitive, bool isEnabled,
- QString chanName)
- : _contents(contents), _isRegEx(isRegEx), _isCaseSensitive(isCaseSensitive),
- _isEnabled(isEnabled), _chanName(chanName)
+ LegacyHighlightRule(QString contents, bool isRegEx, bool isCaseSensitive, bool isEnabled, QString chanName)
+ : _contents(std::move(contents))
+ , _isRegEx(isRegEx)
+ , _isCaseSensitive(isCaseSensitive)
+ , _isEnabled(isEnabled)
+ , _chanName(std::move(chanName))
{
_cacheInvalid = true;
// Cache expression matches on construction
*
* @return String representing a phrase or expression to match
*/
- inline QString contents() const {
- return _contents;
- }
+ inline QString contents() const { return _contents; }
/**
* Sets the message contents this rule matches
*
* @param contents String representing a phrase or expression to match
*/
- inline void setContents(const QString &contents) {
+ inline void setContents(const QString& contents)
+ {
_contents = contents;
_cacheInvalid = true;
}
*
* @return True if regular expression, otherwise false
*/
- inline bool isRegEx() const {
- return _isRegEx;
- }
+ inline bool isRegEx() const { return _isRegEx; }
/**
* Sets if this rule is a regular expression rule
*
* @param isRegEx True if regular expression, otherwise false
*/
- inline void setIsRegEx(bool isRegEx) {
+ inline void setIsRegEx(bool isRegEx)
+ {
_isRegEx = isRegEx;
_cacheInvalid = true;
}
*
* @return True if case sensitive, otherwise false
*/
- inline bool isCaseSensitive() const {
- return _isCaseSensitive;
- }
+ inline bool isCaseSensitive() const { return _isCaseSensitive; }
/**
* Sets if this rule is case sensitive
*
* @param isCaseSensitive True if case sensitive, otherwise false
*/
- inline void setIsCaseSensitive(bool isCaseSensitive) {
+ inline void setIsCaseSensitive(bool isCaseSensitive)
+ {
_isCaseSensitive = isCaseSensitive;
_cacheInvalid = true;
}
*
* @return True if enabled, otherwise false
*/
- inline bool isEnabled() const {
- return _isEnabled;
- }
+ inline bool isEnabled() const { return _isEnabled; }
/**
* Sets if this rule is enabled and active
*
* @param isEnabled True if enabled, otherwise false
*/
- inline void setIsEnabled(bool isEnabled) {
- _isEnabled = isEnabled;
- }
+ inline void setIsEnabled(bool isEnabled) { _isEnabled = isEnabled; }
/**
* Gets the channel name this rule matches
*
* @return String representing a phrase or expression to match
*/
- inline QString chanName() const {
- return _chanName;
- }
+ inline QString chanName() const { return _chanName; }
/**
* Sets the channel name this rule matches
*
* @param chanName String representing a phrase or expression to match
*/
- inline void setChanName(const QString &chanName) {
+ inline void setChanName(const QString& chanName)
+ {
_chanName = chanName;
_cacheInvalid = true;
}
*
* @return Expression matcher to compare with message contents
*/
- inline ExpressionMatch contentsMatcher() const {
+ inline ExpressionMatch contentsMatcher() const
+ {
if (_cacheInvalid) {
determineExpressions();
}
*
* @return Expression matcher to compare with channel name
*/
- inline ExpressionMatch chanNameMatcher() const {
+ inline ExpressionMatch chanNameMatcher() const
+ {
if (_cacheInvalid) {
determineExpressions();
}
return _chanNameMatch;
}
- bool operator!=(const LegacyHighlightRule &other) const;
+ bool operator!=(const LegacyHighlightRule& other) const;
private:
/**
// These represent internal cache and should be safe to mutate in 'const' functions
// See https://stackoverflow.com/questions/3141087/what-is-meant-with-const-at-end-of-function-declaration
- mutable bool _cacheInvalid = true; ///< If true, match cache needs redone
- mutable ExpressionMatch _contentsMatch = {}; ///< Expression match cache for message content
- mutable ExpressionMatch _chanNameMatch = {}; ///< Expression match cache for channel name
+ mutable bool _cacheInvalid = true; ///< If true, match cache needs redone
+ mutable ExpressionMatch _contentsMatch = {}; ///< Expression match cache for message content
+ mutable ExpressionMatch _chanNameMatch = {}; ///< Expression match cache for channel name
};
using LegacyHighlightRuleList = QList<LegacyHighlightRule>;
- void checkForHighlight(Message &msg);
+ void checkForHighlight(Message& msg);
void startProcessing();
using HighlightNickType = NotificationSettings::HighlightNickType;
- /**
- * Update internal cache of expression matching if needed
- */
- void determineNickExpressions(const QString ¤tNick,
- const QStringList identityNicks) const;
-
- /**
- * Check if nickname matching cache is invalid
- * @param currentNick
- * @param identityNicks
- * @return
- */
- bool cacheNickInvalid(const QString ¤tNick, const QStringList identityNicks) const {
- if (_cacheNickConfigInvalid) return true;
- if (_cachedNickCurrent != currentNick) return true;
- if (_cachedIdentityNicks != identityNicks) return true;
- }
+ LegacyHighlightRuleList _highlightRuleList; ///< Custom highlight rule list
+ NickHighlightMatcher _nickMatcher = {}; ///< Nickname highlight matcher
- LegacyHighlightRuleList _highlightRuleList;
+ /// Nickname highlighting mode
HighlightNickType _highlightNick = HighlightNickType::CurrentNick;
- bool _nicksCaseSensitive = false;
-
- // These represent internal cache and should be safe to mutate in 'const' functions
- mutable bool _cacheNickConfigInvalid = true; ///< If true, nick match cache needs redone
- mutable QString _cachedNickCurrent = {}; ///< Last cached current nick
- mutable QStringList _cachedIdentityNicks = {}; ///< Last cached identity nicks
- mutable ExpressionMatch _cachedNickMatcher = {}; ///< Expression match cache for nicks
+ bool _nicksCaseSensitive = false; ///< If true, match nicknames with exact case
- QList<QList<Message> > _processQueue;
+ QList<QList<Message>> _processQueue;
QList<Message> _currentBatch;
QTimer _processTimer;
bool _processing;
Mode _processMode;
};
-
#endif