+ /**
+ * Individual ignore list rule
+ */
+ class COMMON_EXPORT IgnoreListItem
+ {
+ public:
+ /**
+ * Construct an empty ignore rule
+ */
+ IgnoreListItem() = default;
+
+ /**
+ * Construct an ignore rule with the given parameters
+ *
+ * CAUTION: For legacy reasons, "contents" doubles as the identifier for the ignore rule.
+ * Duplicate entries are not allowed.
+ *
+ * @param type Type of ignore rule
+ * @param contents String representing a message contents expression to match
+ * @param isRegEx True if regular expression, otherwise false
+ * @param strictness Strictness of ignore rule
+ * @param scope What to match scope rule against
+ * @param scopeRule String representing a scope rule expression to match
+ * @param isEnabled True if enabled, otherwise false
+ */
+ IgnoreListItem(
+ IgnoreType type, QString contents, bool isRegEx, StrictnessType strictness, ScopeType scope, QString scopeRule, bool isEnabled)
+ : _contents(std::move(contents))
+ , _isRegEx(isRegEx)
+ , _strictness(strictness)
+ , _scope(scope)
+ , _scopeRule(std::move(scopeRule))
+ , _isEnabled(isEnabled)
+ {
+ // Allow passing empty "contents" as they can happen when editing an ignore rule
+
+ // Handle CTCP ignores
+ setType(type);
+
+ _cacheInvalid = true;
+ // Cache expression matches on construction
+ //
+ // This provides immediate feedback on errors when loading the rule. If profiling shows
+ // this as a performance bottleneck, this can be removed in deference to caching on
+ // first use.
+ //
+ // Inversely, if needed for validity checks, caching can be done on every update below
+ // instead of on first use.
+ determineExpressions();
+ }
+
+ /**
+ * Gets the type of this ignore rule
+ *
+ * @return IgnoreType of the rule
+ */
+ inline IgnoreType type() const { return _type; }
+ /**
+ * Sets the type of this ignore rule
+ *
+ * @param type IgnoreType of the rule
+ */
+ inline void setType(IgnoreType type)
+ {
+ // Handle CTCP ignores
+ if (type == CtcpIgnore) {
+ // This is not performance-intensive; sticking with QRegExp for Qt 4 is fine
+ // Split based on whitespace characters
+ QStringList split(contents().split(QRegExp("\\s+"), QString::SkipEmptyParts));
+ // Match on the first item, handling empty rules/matches
+ if (!split.isEmpty()) {
+ // Take the first item as the sender
+ _cacheCtcpSender = split.takeFirst();
+ // Track the rest as CTCP types to ignore
+ _cacheCtcpTypes = split;
+ }
+ else {
+ // No match found - this can happen if a pure whitespace CTCP ignore rule is
+ // created. Fall back to matching all senders.
+ if (_isRegEx) {
+ // RegEx match everything
+ _cacheCtcpSender = ".*";
+ }
+ else {
+ // Wildcard match everything
+ _cacheCtcpSender = "*";
+ }
+ // Clear the types (split is already empty)
+ _cacheCtcpTypes = split;
+ }
+ }
+ _type = type;
+ }
+
+ /**
+ * Gets the message contents this rule matches
+ *
+ * NOTE: Use IgnoreListItem::contentsMatcher() for performing matches
+ *
+ * CAUTION: For legacy reasons, "contents" doubles as the identifier for the ignore rule.
+ * Duplicate entries are not allowed.
+ *
+ * @return String representing a phrase or expression to match
+ */
+ 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)
+ {
+ // Allow passing empty "contents" as they can happen when editing an ignore rule
+ _contents = contents;
+ _cacheInvalid = true;
+ }
+
+ /**
+ * Gets if this is a regular expression rule
+ *
+ * @return True if regular expression, otherwise false
+ */
+ 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)
+ {
+ _isRegEx = isRegEx;
+ _cacheInvalid = true;
+ }
+
+ /**
+ * Gets the strictness of this ignore rule
+ *
+ * @return StrictnessType of the rule
+ */
+ inline StrictnessType strictness() const { return _strictness; }
+ /**
+ * Sets the strictness of this ignore rule
+ *
+ * @param strictness StrictnessType of the rule
+ */
+ inline void setStrictness(StrictnessType strictness) { _strictness = strictness; }
+
+ /**
+ * Gets what to match scope rule against
+ *
+ * @return ScopeType of the rule
+ */
+ inline ScopeType scope() const { return _scope; }
+ /**
+ * Sets what to match scope rule against
+ *
+ * @param type ScopeType of the rule
+ */
+ inline void setScope(ScopeType scope) { _scope = scope; }
+
+ /**
+ * Gets the scope rule this rule matches
+ *
+ * NOTE: Use IgnoreListItem::scopeRuleMatcher() for performing matches
+ *
+ * @return String representing a phrase or expression to match
+ */
+ inline QString scopeRule() const { return _scopeRule; }
+ /**
+ * Sets the scope rule this rule matches
+ *
+ * @param scopeRule String representing a phrase or expression to match
+ */
+ inline void setScopeRule(const QString& scopeRule)
+ {
+ _scopeRule = scopeRule;
+ _cacheInvalid = true;
+ }
+
+ /**
+ * Gets if this rule is enabled and active
+ *
+ * @return True if enabled, otherwise false
+ */
+ 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; }
+
+ /**
+ * Gets the ignored CTCP types for CTCP ignores
+ *
+ * @return List of CTCP types to ignore, or empty for all
+ */
+ inline QStringList ctcpTypes() const { return _cacheCtcpTypes; }
+
+ /**
+ * Gets the expression matcher for the message contents, caching if needed
+ *
+ * @return Expression matcher to compare with message contents
+ */
+ inline ExpressionMatch contentsMatcher() const
+ {
+ if (_cacheInvalid) {
+ determineExpressions();
+ }
+ return _contentsMatch;
+ }
+
+ /**
+ * Gets the expression matcher for the scope, caching if needed
+ *
+ * @return Expression matcher to compare with scope
+ */
+ inline ExpressionMatch scopeRuleMatcher() const
+ {
+ if (_cacheInvalid) {
+ determineExpressions();