callsignobjectlist.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_AVIATION_CALLSIGNOBJECTLIST_H
#define SWIFT_MISC_AVIATION_CALLSIGNOBJECTLIST_H
 
#include <QHash>
#include <QMap>
#include <QtGlobal>
 
#include "misc/aviation/callsignset.h"
#include "misc/predicates.h"
#include "misc/propertyindexvariantmap.h"
 
namespace swift::misc::aviation
{
    template <class OBJ, class CONTAINER>
    class ICallsignObjectList
    {
    public:
        bool containsCallsign(const CCallsign &callsign) const
        {
            return this->container().contains(&OBJ::getCallsign, callsign);
        }
 
        int applyIfCallsign(const CCallsign &callsign, const CPropertyIndexVariantMap &variantMap,
                            bool skipEqualValues = true)
        {
            return this->container().applyIf(&OBJ::getCallsign, callsign, variantMap, skipEqualValues);
        }
 
        swift::misc::aviation::CCallsignSet getCallsigns() const
        {
            CCallsignSet cs;
            for (const OBJ &obj : this->container()) { cs.push_back(obj.getCallsign()); }
            return cs;
        }
 
        QStringList getCallsignStrings(bool sorted = false) const
        {
            return this->getCallsigns().getCallsignStrings(sorted);
        }
 
        QString getCallsignsAsString(const QString &separator, bool sorted = false) const
        {
            if (this->container().isEmpty()) { return QString(); }
            const QStringList callsigns = this->getCallsignStrings(sorted);
            return callsigns.join(separator);
        }
 
        CONTAINER findByCallsign(const CCallsign &callsign) const
        {
            return this->container().findBy(&OBJ::getCallsign, callsign);
        }
 
        CONTAINER findByCallsigns(const CCallsignSet &callsigns) const
        {
            return this->container().findBy(predicates::MemberIsAnyOf(&OBJ::getCallsign, callsigns));
        }
 
        OBJ findFirstByCallsign(const CCallsign &callsign, const OBJ &ifNotFound = {}) const
        {
            return this->container().findFirstByOrDefault(&OBJ::getCallsign, callsign, ifNotFound);
        }
 
        OBJ findLastByCallsign(const CCallsign &callsign, const OBJ &ifNotFound = {}) const
        {
            for (auto current = container().end(); current != container().begin(); /* Do nothing */)
            {
                --current;
                if (current->getCallsign() == callsign) { return *current; }
            }
            return ifNotFound;
        }
 
        CONTAINER findBySuffix(const QString &suffix) const
        {
            CONTAINER r;
            if (suffix.isEmpty()) { return r; }
            const QString sfxUpper(suffix.trimmed().toUpper());
            r = this->container().findBy(
                [=](const OBJ &csObj) { return (csObj.getCallsign().getSuffix() == sfxUpper); });
            return r;
        }
 
        int firstIndexOfCallsign(const CCallsign &callsign)
        {
            for (int i = 0; i < this->container().size(); i++)
            {
                if (this->container()[i].getCallsign() == callsign) { return i; }
            }
            return -1;
        }
 
        int removeByCallsign(const CCallsign &callsign)
        {
            return this->container().removeIf(&OBJ::getCallsign, callsign);
        }
 
        int removeByCallsigns(const CCallsignSet &callsigns)
        {
            return this->container().removeIf([&](const OBJ &obj) { return callsigns.contains(obj.getCallsign()); });
        }
 
        QMap<QString, int> getSuffixesAndCount() const
        {
            QMap<QString, int> r; // sorted by key
            for (const OBJ &csObj : this->container())
            {
                const QString s = csObj.getCallsign().getSuffix();
                if (s.isEmpty()) { continue; }
                if (r.contains(s)) { r[s] = r[s] + 1; }
                else { r.insert(s, 1); }
            }
            return r;
        }
 
        QStringList getSuffixes() const
        {
            QStringList suffixes;
            for (const OBJ &csObj : this->container())
            {
                const QString s = csObj.getCallsign().getSuffix();
                if (s.isEmpty() || suffixes.contains(s, Qt::CaseInsensitive)) { continue; }
                suffixes << s;
            }
            return suffixes;
        }
 
        QHash<CCallsign, CONTAINER> splitPerCallsign() const
        {
            CONTAINER copyContainer(container());
            copyContainer.sortByCallsign();
            QHash<CCallsign, CONTAINER> result;
            CCallsign cs;
            for (const OBJ &csObj : copyContainer)
            {
                if (csObj.getCallsign().isEmpty())
                {
                    Q_ASSERT(false); // there should be no empty callsigns
                    continue;
                }
                if (cs != csObj.getCallsign())
                {
                    cs = csObj.getCallsign();
                    CONTAINER perCallsign({ csObj });
                    result.insert(cs, perCallsign);
                }
                else { result[cs].push_back(csObj); }
            }
            return result;
        }
 
        int replaceOrAddObjectByCallsign(const OBJ &otherObject)
        {
            const CCallsign cs(otherObject.getCallsign());
            if (cs.isEmpty()) { return 0; }
            CONTAINER &copy(this->container());
            copy.removeByCallsign(cs);
            copy.push_back(otherObject);
            return 1;
        }
 
        int replaceOrAddObjectsByCallsign(const CONTAINER &others)
        {
            if (others.isEmpty()) { return 0; }
            int c = 0;
            CONTAINER copy(this->container());
            for (const OBJ &obj : others)
            {
                const CCallsign cs(obj.getCallsign());
                if (cs.isEmpty()) { continue; }
                copy.removeByCallsign(cs);
                copy.push_back(obj);
                c++;
            }
            *this = copy;
            return c;
        }
 
        int incrementalUpdateOrAdd(const OBJ &objectBeforeChanges, const CPropertyIndexVariantMap &changedValues)
        {
            int c;
            const CCallsign cs = objectBeforeChanges.getCallsign();
            if (this->containsCallsign(cs))
            {
                if (changedValues.isEmpty()) { return 0; }
                c = this->container().applyIf(&OBJ::getCallsign, cs, changedValues);
            }
            else
            {
                c = 1;
                if (changedValues.isEmpty()) { this->container().push_back(objectBeforeChanges); }
                else
                {
                    OBJ objectAdded(objectBeforeChanges);
                    objectAdded.apply(changedValues);
                    this->container().push_back(objectAdded);
                }
            }
            return c;
        }
 
        void sortByCallsign() { container().sortBy(&OBJ::getCallsign); }
 
        QMap<CCallsign, OBJ> asCallsignMap() const
        {
            QMap<CCallsign, OBJ> map;
            for (const OBJ &obj : this->container()) { map.insert(obj.getCallsign(), obj); }
            return map;
        }
 
        QHash<CCallsign, OBJ> asCallsignHash() const
        {
            QHash<CCallsign, OBJ> hash;
            for (const OBJ &obj : this->container())
            {
                if (obj.getCallsign().isEmpty()) { continue; }
                hash.insert(obj.getCallsign(), obj);
            }
            return hash;
        }
 
        CONTAINER sortedByCallsign() const
        {
            CONTAINER copy(this->container());
            copy.sortByCallsign();
            return copy;
        }
 
    protected:
        ICallsignObjectList() {}
 
        const CONTAINER &container() const { return static_cast<const CONTAINER &>(*this); }
 
        CONTAINER &container() { return static_cast<CONTAINER &>(*this); }
    };
} // namespace swift::misc::aviation
 
#endif // SWIFT_MISC_AVIATION_CALLSIGNOBJECTLIST_H