File indexing completed on 2024-05-12 05:17:22

 /*
     Copyright (c) 2007 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "imapset.h"
 
 #include <QtCore/QSharedData>
 
 using namespace KIMAP2;
 
 class ImapInterval::Private : public QSharedData
 {
 public:
     Private() :
         QSharedData(),
         begin(0),
         end(0)
     {}
 
     Private(const Private &other) :
         QSharedData(other)
     {
         begin = other.begin;
         end = other.end;
     }
 
     Id begin;
     Id end;
 };
 
 class ImapSet::Private : public QSharedData
 {
 public:
     Private() : QSharedData() {}
     Private(const Private &other) :
         QSharedData(other)
     {
         intervals = other.intervals;
     }
 
     ImapInterval::List intervals;
 };
 
 ImapInterval::ImapInterval() :
     d(new Private)
 {
 }
 
 ImapInterval::ImapInterval(const ImapInterval &other) :
     d(other.d)
 {
 }
 
 ImapInterval::ImapInterval(Id begin, Id end) :
     d(new Private)
 {
     d->begin = begin;
     d->end = end;
 }
 
 ImapInterval::~ ImapInterval()
 {
 }
 
 ImapInterval &ImapInterval::operator =(const ImapInterval &other)
 {
     if (this != &other) {
         d = other.d;
     }
     return *this;
 }
 
 bool ImapInterval::operator ==(const ImapInterval &other) const
 {
     return (d->begin == other.d->begin && d->end == other.d->end);
 }
 
 ImapInterval::Id ImapInterval::size() const
 {
     if (!d->begin && !d->end) {
         return 0;
     }
     if (d->begin && !d->end) {
         return Q_INT64_C(0x7FFFFFFFFFFFFFFF) - d->begin + 1;
     }
     return d->end - d->begin + 1;
 }
 
 bool ImapInterval::hasDefinedBegin() const
 {
     return d->begin != 0;
 }
 
 ImapInterval::Id ImapInterval::begin() const
 {
     return d->begin;
 }
 
 bool ImapInterval::hasDefinedEnd() const
 {
     return d->end != 0;
 }
 
 ImapInterval::Id ImapInterval::end() const
 {
     if (hasDefinedEnd()) {
         return d->end;
     }
     return 0xFFFFFFFF; // should be INT_MAX, but where is that defined again?
 }
 
 void ImapInterval::setBegin(Id value)
 {
     Q_ASSERT(value >= 0);
     Q_ASSERT(value <= d->end || !hasDefinedEnd());
     d->begin = value;
 }
 
 void ImapInterval::setEnd(Id value)
 {
     Q_ASSERT(value >= 0);
     Q_ASSERT(value >= d->begin || !hasDefinedBegin());
     d->end = value;
 }
 
 QByteArray ImapInterval::toImapSequence() const
 {
     if (size() == 0) {
         return QByteArray();
     }
     if (size() == 1) {
         return QByteArray::number(d->begin);
     }
     QByteArray rv;
     rv += QByteArray::number(d->begin) + ':';
     if (hasDefinedEnd()) {
         rv += QByteArray::number(d->end);
     } else {
         rv += '*';
     }
     return rv;
 }
 
 ImapInterval ImapInterval::fromImapSequence(const QByteArray &sequence)
 {
     QList<QByteArray> values = sequence.split(':');
     if (values.isEmpty() || values.size() > 2) {
         return ImapInterval();
     }
 
     bool ok = false;
     Id begin = values[0].toLongLong(&ok);
 
     if (!ok) {
         return ImapInterval();
     }
 
     Id end;
 
     if (values.size() == 1) {
         end = begin;
     } else if (values[1] == QByteArray("*")) {
         end = 0;
     } else {
         ok = false;
         end = values[1].toLongLong(&ok);
         if (!ok) {
             return ImapInterval();
         }
     }
 
     return ImapInterval(begin, end);
 }
 
 ImapSet::ImapSet() :
     d(new Private)
 {
 }
 
 ImapSet::ImapSet(Id begin, Id end) :
     d(new Private)
 {
     add(ImapInterval(begin, end));
 }
 
 ImapSet::ImapSet(Id value) :
     d(new Private)
 {
     add(QVector<Id>() << value);
 }
 
 ImapSet::ImapSet(const ImapSet &other) :
     d(other.d)
 {
 }
 
 ImapSet::~ImapSet()
 {
 }
 
 ImapSet &ImapSet::operator =(const ImapSet &other)
 {
     if (this != &other) {
         d = other.d;
     }
     return *this;
 }
 
 bool ImapSet::operator ==(const ImapSet &other) const
 {
     if (d->intervals.size() != other.d->intervals.size()) {
         return false;
     }
 
     foreach (const ImapInterval &interval, d->intervals) {
         if (!other.d->intervals.contains(interval)) {
             return false;
         }
     }
 
     return true;
 }
 
 void ImapSet::add(Id value)
 {
     add(QVector<Id>() << value);
 }
 
 void ImapSet::add(const QVector<Id> &values)
 {
     QVector<Id> vals = values;
     std::sort(vals.begin(), vals.end());
     for (auto i = 0; i < vals.count(); ++i) {
         const auto begin = vals[i];
         Q_ASSERT(begin >= 0);
         if (i == vals.count() - 1) {
             d->intervals << ImapInterval(begin, begin);
             break;
         }
         do {
             ++i;
             Q_ASSERT(vals[i] >= 0);
             if (vals[i] != (vals[i - 1] + 1)) {
                 --i;
                 break;
             }
         } while (i < vals.count() - 1);
         d->intervals << ImapInterval(begin, vals[i]);
     }
 }
 
 void ImapSet::add(const ImapInterval &interval)
 {
     d->intervals << interval;
 }
 
 QByteArray ImapSet::toImapSequenceSet() const
 {
     QList<QByteArray> rv;
     rv.reserve(d->intervals.count());
     foreach (const ImapInterval &interval, d->intervals) {
         rv << interval.toImapSequence();
     }
 
     QByteArray result;
 
     if (!rv.isEmpty()) {
         result = rv.first();
         QList<QByteArray>::ConstIterator it = rv.constBegin();
         ++it;
         for (; it != rv.constEnd(); ++it) {
             result += ',' + (*it);
         }
     }
 
     return result;
 }
 
 ImapSet ImapSet::fromImapSequenceSet(const QByteArray &sequence)
 {
     ImapSet result;
 
     QList<QByteArray> intervals = sequence.split(',');
 
     foreach (const QByteArray &interval, intervals) {
         if (!interval.isEmpty()) {
             result.add(ImapInterval::fromImapSequence(interval));
         }
     }
 
     return result;
 }
 
 ImapInterval::List ImapSet::intervals() const
 {
     return d->intervals;
 }
 
 bool ImapSet::isEmpty() const
 {
     return d->intervals.isEmpty();
 }
 
 void ImapSet::optimize()
 {
     // There's nothing to optimize if we have fewer than 2 intervals
     if (d->intervals.size() < 2) {
         return;
     }
 
     // Sort the intervals in ascending order by their beginning value
     std::sort(d->intervals.begin(), d->intervals.end(),
               [](const ImapInterval &lhs, const ImapInterval &rhs) {
                    return lhs.begin() < rhs.begin();
               });
 
     auto it = d->intervals.begin();
     while (it != d->intervals.end() && it != std::prev(d->intervals.end())) {
         auto next = std::next(it);
         // +1 so that we also merge neighbouring intervals, e.g. 1:2,3:4 -> 1:4
         if (it->hasDefinedEnd() && it->end() + 1 >= next->begin()) {
             next->setBegin(it->begin());
             if (next->hasDefinedEnd() && it->end() > next->end()) {
                 next->setEnd(it->end());
             }
             it = d->intervals.erase(it);
         } else if (!it->hasDefinedEnd()) {
             // We can eat up all the remaining intervals
             it = d->intervals.erase(next, d->intervals.end());
         } else {
             ++it;
         }
     }
 }
 
 QDebug &operator<<(QDebug &d, const ImapInterval &interval)
 {
     d << interval.toImapSequence();
     return d;
 }
 
 QDebug &operator<<(QDebug &d, const ImapSet &set)
 {
     d << set.toImapSequenceSet();
     return d;
 }