Turn Card, Deck_List, Protocol, RNG, Server, Settings and Utility into libraries and remove cockatrice_common.

Took 6 hours 3 minutes

Took 31 seconds

libcockatrice_card/libcockatrice/card/card_set/card_set.cpp

@@ -0,0 +1,81 @@
+#include "card_set.h"
+
+#include <libcockatrice/settings/cache_settings.h>
+
+const char *CardSet::TOKENS_SETNAME = "TK";
+
+CardSet::CardSet(const QString &_shortName,
+                 const QString &_longName,
+                 const QString &_setType,
+                 const QDate &_releaseDate,
+                 const CardSet::Priority _priority)
+    : shortName(_shortName), longName(_longName), releaseDate(_releaseDate), setType(_setType), priority(_priority)
+{
+    loadSetOptions();
+}
+
+CardSetPtr CardSet::newInstance(const QString &_shortName,
+                                const QString &_longName,
+                                const QString &_setType,
+                                const QDate &_releaseDate,
+                                const Priority _priority)
+{
+    CardSetPtr ptr(new CardSet(_shortName, _longName, _setType, _releaseDate, _priority));
+    // ptr->setSmartPointer(ptr);
+    return ptr;
+}
+
+QString CardSet::getCorrectedShortName() const
+{
+    // For Windows machines.
+    QSet<QString> invalidFileNames;
+    invalidFileNames << "CON"
+                     << "PRN"
+                     << "AUX"
+                     << "NUL"
+                     << "COM1"
+                     << "COM2"
+                     << "COM3"
+                     << "COM4"
+                     << "COM5"
+                     << "COM6"
+                     << "COM7"
+                     << "COM8"
+                     << "COM9"
+                     << "LPT1"
+                     << "LPT2"
+                     << "LPT3"
+                     << "LPT4"
+                     << "LPT5"
+                     << "LPT6"
+                     << "LPT7"
+                     << "LPT8"
+                     << "LPT9";
+
+    return invalidFileNames.contains(shortName) ? shortName + "_" : shortName;
+}
+
+void CardSet::loadSetOptions()
+{
+    sortKey = SettingsCache::instance().cardDatabase().getSortKey(shortName);
+    enabled = SettingsCache::instance().cardDatabase().isEnabled(shortName);
+    isknown = SettingsCache::instance().cardDatabase().isKnown(shortName);
+}
+
+void CardSet::setSortKey(unsigned int _sortKey)
+{
+    sortKey = _sortKey;
+    SettingsCache::instance().cardDatabase().setSortKey(shortName, _sortKey);
+}
+
+void CardSet::setEnabled(bool _enabled)
+{
+    enabled = _enabled;
+    SettingsCache::instance().cardDatabase().setEnabled(shortName, _enabled);
+}
+
+void CardSet::setIsKnown(bool _isknown)
+{
+    isknown = _isknown;
+    SettingsCache::instance().cardDatabase().setIsKnown(shortName, _isknown);
+}

libcockatrice_card/libcockatrice/card/card_set/card_set.h

@@ -0,0 +1,116 @@
+#ifndef COCKATRICE_CARD_SET_H
+#define COCKATRICE_CARD_SET_H
+
+#include <QDate>
+#include <QList>
+#include <QSharedPointer>
+#include <QString>
+
+class CardInfo;
+using CardInfoPtr = QSharedPointer<CardInfo>;
+
+class CardSet;
+using CardSetPtr = QSharedPointer<CardSet>;
+
+class CardSet : public QList<CardInfoPtr>
+{
+public:
+    enum Priority
+    {
+        PriorityFallback = 0,
+        PriorityPrimary = 10,
+        PrioritySecondary = 20,
+        PriorityReprint = 30,
+        PriorityOther = 40,
+        PriorityLowest = 100,
+    };
+
+    static const char *TOKENS_SETNAME;
+
+private:
+    QString shortName, longName;
+    unsigned int sortKey;
+    QDate releaseDate;
+    QString setType;
+    Priority priority;
+    bool enabled, isknown;
+
+public:
+    explicit CardSet(const QString &_shortName = QString(),
+                     const QString &_longName = QString(),
+                     const QString &_setType = QString(),
+                     const QDate &_releaseDate = QDate(),
+                     const Priority _priority = PriorityFallback);
+
+    static CardSetPtr newInstance(const QString &_shortName = QString(),
+                                  const QString &_longName = QString(),
+                                  const QString &_setType = QString(),
+                                  const QDate &_releaseDate = QDate(),
+                                  const Priority _priority = PriorityFallback);
+
+    QString getCorrectedShortName() const;
+
+    QString getShortName() const
+    {
+        return shortName;
+    }
+    QString getLongName() const
+    {
+        return longName;
+    }
+    QString getSetType() const
+    {
+        return setType;
+    }
+    QDate getReleaseDate() const
+    {
+        return releaseDate;
+    }
+    Priority getPriority() const
+    {
+        return priority;
+    }
+
+    void setLongName(const QString &_longName)
+    {
+        longName = _longName;
+    }
+    void setSetType(const QString &_setType)
+    {
+        setType = _setType;
+    }
+    void setReleaseDate(const QDate &_releaseDate)
+    {
+        releaseDate = _releaseDate;
+    }
+    void setPriority(const Priority _priority)
+    {
+        priority = _priority;
+    }
+
+    void loadSetOptions();
+    int getSortKey() const
+    {
+        return sortKey;
+    }
+    void setSortKey(unsigned int _sortKey);
+
+    bool getEnabled() const
+    {
+        return enabled;
+    }
+    void setEnabled(bool _enabled);
+
+    bool getIsKnown() const
+    {
+        return isknown;
+    }
+    void setIsKnown(bool _isknown);
+
+    bool getIsKnownIgnored() const
+    {
+        return longName.length() + setType.length() + releaseDate.toString().length() == 0;
+    }
+};
+
+#endif // COCKATRICE_CARD_SET_H

libcockatrice_card/libcockatrice/card/card_set/card_set_comparator.h

@@ -0,0 +1,66 @@
+/**
+ * @file card_set_comparator.h
+ * @ingroup Cards
+ * @brief TODO: Document this.
+ */
+
+#ifndef SET_PRIORITY_COMPARATOR_H
+#define SET_PRIORITY_COMPARATOR_H
+
+#include "../card_info.h"
+
+class SetPriorityComparator
+{
+public:
+    /*
+     * Returns true if a has higher download priority than b
+     * Enabled sets have priority over disabled sets
+     * Both groups follow the user-defined order
+     */
+    inline bool operator()(const CardSetPtr &a, const CardSetPtr &b) const
+    {
+        if (a->getEnabled()) {
+            return !b->getEnabled() || a->getSortKey() < b->getSortKey();
+        } else {
+            return !b->getEnabled() && a->getSortKey() < b->getSortKey();
+        }
+    }
+};
+
+class SetReleaseDateComparator
+{
+public:
+    /*
+     * Returns true if a has higher download priority than b
+     * Enabled sets have priority over disabled sets
+     * Both groups follow the user-defined order
+     */
+    inline bool operator()(const CardSetPtr &a, const CardSetPtr &b) const
+    {
+        if (a->getEnabled()) {
+            return !b->getEnabled() || a->getReleaseDate() < b->getReleaseDate();
+        } else {
+            return !b->getEnabled() && a->getReleaseDate() < b->getReleaseDate();
+        }
+    }
+};
+
+class CardSetPriorityComparator
+{
+public:
+    /*
+     * Returns true if a has higher download priority than b
+     * Enabled sets have priority over disabled sets
+     * Both groups follow the user-defined order
+     */
+    inline bool operator()(const PrintingInfo &a, const PrintingInfo &b) const
+    {
+        if (a.getSet()->getEnabled()) {
+            return !b.getSet()->getEnabled() || a.getSet()->getSortKey() < b.getSet()->getSortKey();
+        } else {
+            return !b.getSet()->getEnabled() && a.getSet()->getSortKey() < b.getSet()->getSortKey();
+        }
+    }
+};
+
+#endif // SET_PRIORITY_COMPARATOR_H

libcockatrice_card/libcockatrice/card/card_set/card_set_list.cpp

@@ -0,0 +1,127 @@
+#include "card_set_list.h"
+
+class CardSetList::KeyCompareFunctor
+{
+public:
+    inline bool operator()(const CardSetPtr &a, const CardSetPtr &b) const
+    {
+        if (a.isNull() || b.isNull()) {
+            // qCWarning(CardInfoLog) << "SetList::KeyCompareFunctor a or b is null";
+            return false;
+        }
+
+        return a->getSortKey() < b->getSortKey();
+    }
+};
+
+void CardSetList::sortByKey()
+{
+    std::sort(begin(), end(), KeyCompareFunctor());
+}
+
+int CardSetList::getEnabledSetsNum()
+{
+    int num = 0;
+    for (int i = 0; i < size(); ++i) {
+        CardSetPtr set = at(i);
+        if (set && set->getEnabled()) {
+            ++num;
+        }
+    }
+    return num;
+}
+
+int CardSetList::getUnknownSetsNum()
+{
+    int num = 0;
+    for (int i = 0; i < size(); ++i) {
+        CardSetPtr set = at(i);
+        if (set && !set->getIsKnown() && !set->getIsKnownIgnored()) {
+            ++num;
+        }
+    }
+    return num;
+}
+
+QStringList CardSetList::getUnknownSetsNames()
+{
+    QStringList sets = QStringList();
+    for (int i = 0; i < size(); ++i) {
+        CardSetPtr set = at(i);
+        if (set && !set->getIsKnown() && !set->getIsKnownIgnored()) {
+            sets << set->getShortName();
+        }
+    }
+    return sets;
+}
+
+void CardSetList::enableAllUnknown()
+{
+    for (int i = 0; i < size(); ++i) {
+        CardSetPtr set = at(i);
+        if (set && !set->getIsKnown() && !set->getIsKnownIgnored()) {
+            set->setIsKnown(true);
+            set->setEnabled(true);
+        } else if (set && set->getIsKnownIgnored() && !set->getEnabled()) {
+            set->setEnabled(true);
+        }
+    }
+}
+
+void CardSetList::enableAll()
+{
+    for (int i = 0; i < size(); ++i) {
+        CardSetPtr set = at(i);
+
+        if (set == nullptr) {
+            // qCWarning(CardInfoLog) << "enabledAll has null";
+            continue;
+        }
+
+        if (!set->getIsKnownIgnored()) {
+            set->setIsKnown(true);
+        }
+
+        set->setEnabled(true);
+    }
+}
+
+void CardSetList::markAllAsKnown()
+{
+    for (int i = 0; i < size(); ++i) {
+        CardSetPtr set = at(i);
+        if (set && !set->getIsKnown() && !set->getIsKnownIgnored()) {
+            set->setIsKnown(true);
+            set->setEnabled(false);
+        } else if (set && set->getIsKnownIgnored() && !set->getEnabled()) {
+            set->setEnabled(true);
+        }
+    }
+}
+
+void CardSetList::guessSortKeys()
+{
+    defaultSort();
+    for (int i = 0; i < size(); ++i) {
+        CardSetPtr set = at(i);
+        if (set.isNull()) {
+            // qCWarning(CardInfoLog) << "guessSortKeys set is null";
+            continue;
+        }
+        set->setSortKey(i);
+    }
+}
+
+void CardSetList::defaultSort()
+{
+    std::sort(begin(), end(), [](const CardSetPtr &a, const CardSetPtr &b) {
+        // Sort by priority, then by release date, then by short name
+        if (a->getPriority() != b->getPriority()) {
+            return a->getPriority() < b->getPriority(); // lowest first
+        } else if (a->getReleaseDate() != b->getReleaseDate()) {
+            return a->getReleaseDate() > b->getReleaseDate(); // most recent first
+        } else {
+            return a->getShortName() < b->getShortName(); // alphabetically
+        }
+    });
+}

libcockatrice_card/libcockatrice/card/card_set/card_set_list.h

@@ -0,0 +1,26 @@
+#ifndef COCKATRICE_CARD_SET_LIST_H
+#define COCKATRICE_CARD_SET_LIST_H
+
+#include "card_set.h"
+
+#include <QList>
+#include <QStringList>
+
+class CardSetList : public QList<CardSetPtr>
+{
+private:
+    class KeyCompareFunctor;
+
+public:
+    void sortByKey();
+    void guessSortKeys();
+    void enableAllUnknown();
+    void enableAll();
+    void markAllAsKnown();
+    int getEnabledSetsNum();
+    int getUnknownSetsNum();
+    QStringList getUnknownSetsNames();
+    void defaultSort();
+};
+
+#endif // COCKATRICE_CARD_SET_LIST_H