File indexing completed on 2024-04-14 03:51:24

 /*
     SPDX-FileCopyrightText: 2022 Volker Krause <vkrause@kde.org>
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "addressformat.h"
 #include "address.h"
 #include "addressformat_p.h"
 #include "addressformatparser_p.h"
 #include "addressformatscript_p.h"
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KCountry>
 
 #include <QDebug>
 #include <QLocale>
 
 using namespace KContacts;
 
 AddressFormatElement::AddressFormatElement()
     : d(new AddressFormatElementPrivate)
 {
 }
 
 AddressFormatElement::AddressFormatElement(const AddressFormatElement &) = default;
 AddressFormatElement::~AddressFormatElement() = default;
 AddressFormatElement &AddressFormatElement::operator=(const AddressFormatElement &) = default;
 
 bool AddressFormatElement::isField() const
 {
     return d->field != AddressFormatField::NoField;
 }
 
 AddressFormatField AddressFormatElement::field() const
 {
     return d->field;
 }
 
 bool AddressFormatElement::isLiteral() const
 {
     return !d->literal.isEmpty();
 }
 
 QString AddressFormatElement::literal() const
 {
     return d->literal;
 }
 
 bool AddressFormatElement::isSeparator() const
 {
     return !isField() && !isLiteral();
 }
 
 AddressFormat::AddressFormat()
     : d(new AddressFormatPrivate)
 {
 }
 
 AddressFormat::AddressFormat(const AddressFormat &) = default;
 AddressFormat::~AddressFormat() = default;
 AddressFormat &AddressFormat::operator=(const AddressFormat &) = default;
 
 const std::vector<AddressFormatElement> &AddressFormat::elements() const
 {
     return d->elements;
 }
 
 AddressFormatFields AddressFormat::requiredFields() const
 {
     return d->required;
 }
 
 AddressFormatFields AddressFormat::usedFields() const
 {
     return std::accumulate(d->elements.begin(), d->elements.end(), AddressFormatFields(AddressFormatField::NoField), [](auto lhs, const auto &rhs) {
         return lhs | rhs.field();
     });
 }
 
 AddressFormatFields AddressFormat::upperCaseFields() const
 {
     return d->upper;
 }
 
 QString AddressFormat::postalCodeRegularExpression() const
 {
     return d->postalCodeFormat;
 }
 
 QString AddressFormat::country() const
 {
     return d->country;
 }
 
 QList<AddressFormatElement> AddressFormat::elementsForQml() const
 {
     QList<AddressFormatElement> l;
     l.reserve(d->elements.size());
     std::copy(d->elements.begin(), d->elements.end(), std::back_inserter(l));
     return l;
 }
 
 static QString addressFormatRc()
 {
     Q_INIT_RESOURCE(kcontacts); // must be called outside of a namespace
     return QStringLiteral(":/org.kde.kcontacts/addressformatrc");
 }
 
 AddressFormat
 AddressFormatRepository::formatForCountry(const QString &countryCode, AddressFormatScriptPreference scriptPref, AddressFormatPreference formatPref)
 {
     static const KConfig entry(addressFormatRc(), KConfig::SimpleConfig);
     KConfigGroup group = entry.group(countryCode);
 
     AddressFormat format;
     auto fmt = AddressFormatPrivate::get(format);
     fmt->required = AddressFormatParser::parseFields(group.readEntry("Required", QString()));
     fmt->upper = AddressFormatParser::parseFields(group.readEntry("Upper", QString()));
 
     QString formatString;
     if (scriptPref == AddressFormatScriptPreference::Latin && formatPref == AddressFormatPreference::Business) {
         formatString = group.readEntry("LatinBusinessAddressFormat", QString());
     }
     if (formatString.isEmpty() && scriptPref == AddressFormatScriptPreference::Latin) {
         formatString = group.readEntry("LatinAddressFormat", QString());
     }
     if (formatString.isEmpty() && formatPref == AddressFormatPreference::Business) {
         formatString = group.readEntry("BusinessAddressFormat", QString());
     }
     if (formatString.isEmpty()) {
         formatString = group.readEntry("AddressFormat", QStringLiteral("%N%n%O%n%A%nPO BOX %P%n%C %S %Z"));
     }
     fmt->elements = AddressFormatParser::parseElements(formatString);
     fmt->postalCodeFormat = group.readEntry("PostalCodeFormat", QString());
     fmt->country = countryCode;
     return format;
 }
 
 AddressFormat AddressFormatRepository::formatForAddress(const Address &address, AddressFormatPreference formatPref)
 {
     KCountry c;
     if (address.country().size() == 2) {
         c = KCountry::fromAlpha2(address.country());
     }
     if (!c.isValid()) {
         c = KCountry::fromName(address.country());
     }
     // fall back to our own country
     if (!c.isValid()) {
         c = KCountry::fromQLocale(QLocale().territory());
     }
 
     const auto scriptPref = AddressFormatScript::detect(address) == AddressFormatScript::LatinLikeScript ? AddressFormatScriptPreference::Latin
                                                                                                          : AddressFormatScriptPreference::Local;
     return formatForCountry(c.alpha2(), scriptPref, formatPref);
 }
 
 #include "moc_addressformat.cpp"