qndeffilter.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qndeffilter.h"
#include "qndefmessage.h"
 
#include <QtCore/QList>
#include <QtCore/QMap>
 
QT_BEGIN_NAMESPACE
 
class QNdefFilterPrivate : public QSharedData
{
public:
    QNdefFilterPrivate();
 
    bool orderMatching;
    QList<QNdefFilter::Record> filterRecords;
};
 
QNdefFilterPrivate::QNdefFilterPrivate()
:   orderMatching(false)
{
}
 
QNdefFilter::QNdefFilter()
:   d(new QNdefFilterPrivate)
{
}
 
QNdefFilter::QNdefFilter(const QNdefFilter &other)
:   d(other.d)
{
}
 
QNdefFilter::~QNdefFilter()
{
}
 
QNdefFilter &QNdefFilter::operator=(const QNdefFilter &other)
{
    if (d != other.d)
        d = other.d;
 
    return *this;
}
 
bool QNdefFilter::match(const QNdefMessage &message) const
{
    // empty filter matches only empty message
    if (d->filterRecords.isEmpty())
        return message.isEmpty();
 
    bool matched = true;
    int totalCount = 0;
 
    if (!d->orderMatching) {
        // Order is not important. The most reliable way is to merge all the
        // similar records, and then simply check the amount of occurrences.
        using MapKey = QPair<QNdefRecord::TypeNameFormat, QByteArray>;
 
        // Creating a map from the list of filter records.
        QMap<MapKey, Record> joinedFilterRecords;
        for (const auto &rec : d->filterRecords) {
            const auto key = qMakePair(rec.typeNameFormat, rec.type);
            if (joinedFilterRecords.contains(key)) {
                joinedFilterRecords[key].minimum += rec.minimum;
                joinedFilterRecords[key].maximum += rec.maximum;
            } else {
                joinedFilterRecords.insert(key, rec);
            }
        }
        // Checking the message, calculate occurrences.
        QMap<MapKey, unsigned int> counts; // current number of occurrences
        for (const auto &record : message) {
            const auto key = qMakePair(record.typeNameFormat(), record.type());
            // Do not forget that we handle an empty type as "any type".
            const auto emptyTypeKey = qMakePair(record.typeNameFormat(), QByteArray());
 
            if (joinedFilterRecords.contains(key))
                counts[key] += 1;
            else if (joinedFilterRecords.contains(emptyTypeKey))
                counts[emptyTypeKey] += 1;
        }
        // Check that the occurrences match [min; max] range.
        for (auto it = joinedFilterRecords.cbegin(); it != joinedFilterRecords.cend(); ++it) {
            const auto count = counts.value(it.key(), 0);
            totalCount += count;
            if (count < it.value().minimum || count > it.value().maximum) {
                matched = false;
                break;
            }
        }
    } else {
        // Order *is* important. Need to iterate the list.
 
        // Here we need to merge consecutive records with the same parameters.
        QList<Record> mergedRecords;
        // we know that filer is not empty here
        Record currentRecord = d->filterRecords.first();
        for (qsizetype i = 1; i < d->filterRecords.size(); ++i) {
            const auto &rec = d->filterRecords.at(i);
            if (rec.typeNameFormat == currentRecord.typeNameFormat
                && rec.type == currentRecord.type) {
                currentRecord.minimum += rec.minimum;
                currentRecord.maximum += rec.maximum;
            } else {
                mergedRecords.push_back(currentRecord);
                currentRecord = rec;
            }
        }
        mergedRecords.push_back(currentRecord);
 
        // The list contains the current number of occurrences of each record.
        QList<unsigned int> counts(mergedRecords.size(), 0);
 
        // Iterate through the messages and calculate the number of occurrences.
        qsizetype filterIndex = 0;
        for (qsizetype messageIndex = 0; matched && messageIndex < message.size(); ++messageIndex) {
            const auto &messageRec = message.at(messageIndex);
            // Try to find a filter record that matches the message record.
            // We start from the last processed filter record, not from the very
            // beginning (because the order matters).
            qsizetype idx = filterIndex;
            for (; idx < mergedRecords.size(); ++idx) {
                const auto &filterRec = mergedRecords.at(idx);
                if (filterRec.typeNameFormat == messageRec.typeNameFormat()
                    && (filterRec.type == messageRec.type() || filterRec.type.isEmpty())) {
                    counts[idx] += 1;
                    break;
                } else if (counts[idx] < filterRec.minimum || counts[idx] > filterRec.maximum) {
                    // The current message record does not match the current
                    // filter record, but we didn't get enough records to
                    // fulfill the filter => that's an error.
                    matched = false;
                    break;
                }
            }
            filterIndex = idx;
        }
 
        if (matched) {
            // Check that the occurrences match [min; max] range.
            for (qsizetype i = 0; i < mergedRecords.size(); ++i) {
                const auto &rec = mergedRecords.at(i);
                totalCount += counts[i];
                if (counts[i] < rec.minimum || counts[i] > rec.maximum) {
                    matched = false;
                    break;
                }
            }
        }
    }
 
    // Check if the message has records that do not match any record from the
    // filter. To do it we just need to compare the total count of records,
    // detected by filter, with the full message size. If they do not match,
    // we have some records, that are not covered by the filter.
    if (matched && (totalCount != message.size())) {
        matched = false;
    }
 
    return matched;
}
 
void QNdefFilter::clear()
{
    d->orderMatching = false;
    d->filterRecords.clear();
}
 
void QNdefFilter::setOrderMatch(bool on)
{
    d->orderMatching = on;
}
 
bool QNdefFilter::orderMatch() const
{
    return d->orderMatching;
}
 
bool QNdefFilter::appendRecord(QNdefRecord::TypeNameFormat typeNameFormat, const QByteArray &type,
                               unsigned int min, unsigned int max)
{
    QNdefFilter::Record record;
 
    record.typeNameFormat = typeNameFormat;
    record.type = type;
    record.minimum = min;
    record.maximum = max;
 
    return appendRecord(record);
}
 
static bool verifyRecord(const QNdefFilter::Record &record)
{
    return record.minimum <= record.maximum;
}
 
bool QNdefFilter::appendRecord(const Record &record)
{
    if (verifyRecord(record)) {
        d->filterRecords.append(record);
        return true;
    }
    return false;
}
 
QNdefFilter::Record QNdefFilter::recordAt(qsizetype i) const
{
    return d->filterRecords.at(i);
}
 
qsizetype QNdefFilter::recordCount() const
{
    return d->filterRecords.size();
}
 
QT_END_NAMESPACE