File indexing completed on 2024-05-12 05:09:52

 /***************************************************************************
     Copyright (C) 2007-2009 Robby Stephenson <robby@periapsis.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or         *
  *   modify it under the terms of the GNU General Public License as        *
  *   published by the Free Software Foundation; either version 2 of        *
  *   the License or (at your option) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   This program 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 General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  *                                                                         *
  ***************************************************************************/
 
 #include "stringcomparison.h"
 #include "../fieldformat.h"
 #include "../tellico_debug.h"
 
 #include <QDateTime>
 
 using namespace Tellico;
 
 namespace {
   int compareFloat(const QString& s1, const QString& s2) {
     bool ok1, ok2;
     float n1 = s1.toFloat(&ok1);
     if(!ok1) {
       return 0;
     }
     float n2 = s2.toFloat(&ok2);
     if(!ok2) {
       return 0;
     }
     return n1 > n2 ? 1 : (n1 < n2 ? -1 : 0);
   }
 }
 
 Tellico::StringComparison* Tellico::StringComparison::create(Data::FieldPtr field_) {
   if(!field_) {
     myWarning() << "No field for creating a string comparison";
     return nullptr;
   }
   if(field_->type() == Data::Field::Number || field_->type() == Data::Field::Rating) {
     return new NumberComparison();
   } else if(field_->type() == Data::Field::Bool) {
     return new BoolComparison();
   } else if(field_->type() == Data::Field::Date || field_->formatType() == FieldFormat::FormatDate) {
     return new ISODateComparison();
   } else if(field_->formatType() == FieldFormat::FormatTitle) {
     return new TitleComparison();
   } else if(field_->property(QStringLiteral("lcc")) == QLatin1String("true") ||
             field_->name() == QLatin1String("lcc")) {
     // allow LCC comparison if LCC property is set, or if the name is lcc
     return new LCCComparison();
   }
   return new StringComparison();
 }
 
 Tellico::StringComparison::StringComparison() {
 }
 
 int Tellico::StringComparison::compare(const QString& str1_, const QString& str2_) {
   return str1_.localeAwareCompare(str2_);
 }
 
 Tellico::BoolComparison::BoolComparison() : StringComparison() {
 }
 
 int Tellico::BoolComparison::compare(const QString& str1_, const QString& str2_) {
   const bool b1 = str1_.compare(QLatin1String("true"), Qt::CaseInsensitive) == 0
                   || str1_ == QLatin1String("1");
   const bool b2 = str2_.compare(QLatin1String("true"), Qt::CaseInsensitive) == 0
                   || str2_ == QLatin1String("1");
   return b1 == b2 ? 0 : (b1 ? 1 : -1);
 }
 
 Tellico::TitleComparison::TitleComparison() : StringComparison() {
 }
 
 int Tellico::TitleComparison::compare(const QString& str1_, const QString& str2_) {
   // sortKeyTitle compares against the article list (which is already in lower-case)
   // additionally, we want lower case for localeAwareCompare
   const QString title1 = FieldFormat::sortKeyTitle(str1_.toLower());
   const QString title2 = FieldFormat::sortKeyTitle(str2_.toLower());
   const int ret = title1.localeAwareCompare(title2);
   return ret > 0 ? 1 : (ret < 0 ? -1 : 0);
 }
 
 Tellico::NumberComparison::NumberComparison() : StringComparison() {
 }
 
 int Tellico::NumberComparison::compare(const QString& str1_, const QString& str2_) {
   bool ok1, ok2;
   float num1 = 0, num2 = 0;
 
   const QStringList values1 = FieldFormat::splitValue(str1_);
   const QStringList values2 = FieldFormat::splitValue(str2_);
   int index = 0;
   do {
     if((ok1 = index < values1.count())) {
       num1 = values1.at(index).toFloat(&ok1);
     }
     if((ok2 = index < values2.count())) {
       num2 = values2.at(index).toFloat(&ok2);
     }
     if(ok1 && ok2) {
       if(!qFuzzyCompare(num1, num2)) {
         const float ret = num1 - num2;
         // if abs(ret) < 0.5, we want to round up/down to -1 or 1
         // so that comparing 0.2 to 0.4 yields 1, for example, and not 0
         return ret < 0 ? qMin(-1, qRound(ret)) : qMax(1, qRound(ret));
       }
     }
     ++index;
   } while(ok1 && ok2);
 
   if(ok1 && !ok2) {
     return 1;
   } else if(!ok1 && ok2) {
     return -1;
   }
   return 0;
 }
 
 // for details on the LCC comparison, see
 // http://www.mcgees.org/2001/08/08/sort-by-library-of-congress-call-number-in-perl/
 // http://library.dts.edu/Pages/RM/Helps/lc_call.shtml
 
 Tellico::LCCComparison::LCCComparison() : StringComparison(),
   m_regexp(QLatin1String("^([A-Z]+)"
                          "(\\d+(?:\\.\\d+)?)"
                          "\\.?([A-Z]*)"
                          "(\\d*)"
                          "\\.?([A-Z]*)"
                          "(\\d*)"
                          "(?: (.+))?")) {
 }
 
 int Tellico::LCCComparison::compare(const QString& str1_, const QString& str2_) {
   if(str1_.isEmpty()) {
     return str2_.isEmpty() ? 0 : -1;
   }
   if(str2_.isEmpty()) {
     return 1;
   }
 //  myDebug() << str1_ << " to " << str2_;
   QRegularExpressionMatch match1 = m_regexp.match(str1_);
   if(!match1.hasMatch()) {
     myDebug() << "no regexp match:" << str1_;
     return StringComparison::compare(str1_, str2_);
   }
   QRegularExpressionMatch match2 = m_regexp.match(str2_);
   if(!match2.hasMatch()) {
     myDebug() << "no regexp match:" << str2_;
     return StringComparison::compare(str1_, str2_);
   }
   QStringList cap1 = match1.capturedTexts();
   QStringList cap2 = match2.capturedTexts();
   // QRegularExpression doesn't include an empty string
   // in optional captured groups that don't exist
   while(cap1.size() < 8) {
     cap1 += QString();
   }
   while(cap2.size() < 8) {
     cap2 += QString();
   }
   return compareLCC(cap1, cap2);
 }
 
 int Tellico::LCCComparison::compareLCC(const QStringList& cap1, const QStringList& cap2) const {
 
   Q_ASSERT(cap1.size() == 8);
   Q_ASSERT(cap2.size() == 8);
   // the first item in the list is the full match, so start array index at 1
   int res = 0;
   return (res = cap1[1].compare(cap2[1]))                    != 0 ? res :
          (res = compareFloat(cap1[2], cap2[2]))              != 0 ? res :
          (res = cap1[3].compare(cap2[3]))                    != 0 ? res :
          (res = compareFloat(QLatin1String("0.") + cap1[4],
                              QLatin1String("0.") + cap2[4])) != 0 ? res :
          (res = cap1[5].compare(cap2[5]))                    != 0 ? res :
          (res = compareFloat(QLatin1String("0.") + cap1[6],
                              QLatin1String("0.") + cap2[6])) != 0 ? res :
          (res = cap1[7].compare(cap2[7]))                    != 0 ? res : 0;
 }
 
 Tellico::ISODateComparison::ISODateComparison() : StringComparison() {
 }
 
 int Tellico::ISODateComparison::compare(const QString& str1, const QString& str2) {
   if(str1.isEmpty()) {
     return str2.isEmpty() ? 0 : -1;
   }
   if(str2.isEmpty()) { // str1 is not
     return 1;
   }
   // modelled after Field::formatDate()
   // so dates would sort as expected without padding month and day with zero
   // and accounting for "current year - 1 - 1" default scheme
   const QDate now = QDate::currentDate();
 #if (QT_VERSION < QT_VERSION_CHECK(5, 14, 0))
   QStringList dlist1 = str1.split(QLatin1Char('-'), QString::KeepEmptyParts);
 #else
   QStringList dlist1 = str1.split(QLatin1Char('-'), Qt::KeepEmptyParts);
 #endif
   bool ok = true;
   int y1 = dlist1.count() > 0 ? dlist1[0].toInt(&ok) : now.year();
   if(!ok) {
     y1 = now.year();
   }
   int m1 = dlist1.count() > 1 ? dlist1[1].toInt(&ok) : 1;
   if(!ok) {
     m1 = 1;
   }
   int d1 = dlist1.count() > 2 ? dlist1[2].toInt(&ok) : 1;
   if(!ok) {
     d1 = 1;
   }
   QDate date1(y1, m1, d1);
 
 #if (QT_VERSION < QT_VERSION_CHECK(5, 14, 0))
   QStringList dlist2 = str2.split(QLatin1Char('-'), QString::KeepEmptyParts);
 #else
   QStringList dlist2 = str2.split(QLatin1Char('-'), Qt::KeepEmptyParts);
 #endif
   int y2 = dlist2.count() > 0 ? dlist2[0].toInt(&ok) : now.year();
   if(!ok) {
     y2 = now.year();
   }
   int m2 = dlist2.count() > 1 ? dlist2[1].toInt(&ok) : 1;
   if(!ok) {
     m2 = 1;
   }
   int d2 = dlist2.count() > 2 ? dlist2[2].toInt(&ok) : 1;
   if(!ok) {
     d2 = 1;
   }
   QDate date2(y2, m2, d2);
 
   if(date1 < date2) {
     return -1;
   } else if(date1 > date2) {
     return 1;
   }
   return 0;
 }