[DeckList] Move decklist node classes into new folder

libcockatrice_deck_list/libcockatrice/deck_list/tree/abstract_deck_list_card_node.cpp

@@ -0,0 +1,62 @@
+#include "abstract_deck_list_card_node.h"
+
+bool AbstractDecklistCardNode::compare(AbstractDecklistNode *other) const
+{
+    switch (sortMethod) {
+        case ByNumber:
+            return compareNumber(other);
+        case ByName:
+            return compareName(other);
+        default:
+            return false;
+    }
+}
+
+bool AbstractDecklistCardNode::compareNumber(AbstractDecklistNode *other) const
+{
+    auto *other2 = dynamic_cast<AbstractDecklistCardNode *>(other);
+    if (other2) {
+        int n1 = getNumber();
+        int n2 = other2->getNumber();
+        return (n1 != n2) ? (n1 > n2) : compareName(other);
+    } else {
+        return true;
+    }
+}
+
+bool AbstractDecklistCardNode::compareName(AbstractDecklistNode *other) const
+{
+    auto *other2 = dynamic_cast<AbstractDecklistCardNode *>(other);
+    if (other2) {
+        return (getName() > other2->getName());
+    } else {
+        return true;
+    }
+}
+
+bool AbstractDecklistCardNode::readElement(QXmlStreamReader *xml)
+{
+    while (!xml->atEnd()) {
+        xml->readNext();
+        if (xml->isEndElement() && xml->name().toString() == "card")
+            return false;
+    }
+    return true;
+}
+
+void AbstractDecklistCardNode::writeElement(QXmlStreamWriter *xml)
+{
+    xml->writeEmptyElement("card");
+    xml->writeAttribute("number", QString::number(getNumber()));
+    xml->writeAttribute("name", getName());
+
+    if (!getCardSetShortName().isEmpty()) {
+        xml->writeAttribute("setShortName", getCardSetShortName());
+    }
+    if (!getCardCollectorNumber().isEmpty()) {
+        xml->writeAttribute("collectorNumber", getCardCollectorNumber());
+    }
+    if (!getCardProviderId().isEmpty()) {
+        xml->writeAttribute("uuid", getCardProviderId());
+    }
+}

libcockatrice_deck_list/libcockatrice/deck_list/tree/abstract_deck_list_card_node.h

@@ -0,0 +1,149 @@
+/**
+ * @file abstract_deck_list_card_node.h
+ * @brief Defines the AbstractDecklistCardNode base class, which adds
+ *        card-specific behavior on top of AbstractDecklistNode.
+ *
+ * This class is the intermediate abstract base between the generic
+ * AbstractDecklistNode and concrete card entries such as DecklistCardNode
+ * or DecklistModelCardNode.
+ */
+
+#ifndef COCKATRICE_ABSTRACT_DECK_LIST_CARD_NODE_H
+#define COCKATRICE_ABSTRACT_DECK_LIST_CARD_NODE_H
+
+#include "abstract_deck_list_node.h"
+
+/**
+ * @class AbstractDecklistCardNode
+ * @ingroup DeckModels
+ * @brief Abstract base class for all deck list nodes that represent
+ *        actual card entries.
+ *
+ * While AbstractDecklistNode provides the general interface for all
+ * nodes in the deck tree (zones, groups, cards), this subclass refines
+ * the interface to cover properties specific to *cards*:
+ * - Quantity (number of copies).
+ * - Name.
+ * - Set code and collector number.
+ * - Provider ID.
+ *
+ * ### Role in the hierarchy:
+ * - Leaf-oriented abstract class; no children of its own.
+ * - Serves as the base for concrete implementations:
+ *   - @c DecklistCardNode: Stores real card data in the deck tree.
+ *   - @c DecklistModelCardNode: Wraps a DecklistCardNode for use
+ *     in the Qt model layer.
+ *
+ * ### Responsibilities:
+ * - Defines getters/setters for all card-identifying attributes.
+ * - Provides comparison logic for sorting by name or number.
+ * - Implements XML serialization for saving/loading deck files.
+ *
+ * ### Ownership:
+ * - As with all nodes, owned by its parent InnerDecklistNode.
+ */
+class AbstractDecklistCardNode : public AbstractDecklistNode
+{
+public:
+    /**
+     * @brief Construct a new AbstractDecklistCardNode.
+     *
+     * @param _parent Optional parent node. If provided, this node
+     *        will be inserted into the parent’s children list.
+     * @param position Index at which to insert into parent’s children.
+     *        If -1, the node is appended to the end.
+     */
+    explicit AbstractDecklistCardNode(InnerDecklistNode *_parent = nullptr, int position = -1)
+        : AbstractDecklistNode(_parent, position)
+    {
+    }
+
+    /// @return The number of copies of this card in the deck.
+    [[nodiscard]] virtual int getNumber() const = 0;
+
+    /// @param _number Set the number of copies of this card.
+    virtual void setNumber(int _number) = 0;
+
+    /// @return The display name of this card.
+    [[nodiscard]] QString getName() const override = 0;
+
+    /// @param _name Set the display name of this card.
+    virtual void setName(const QString &_name) = 0;
+
+    /// @return The provider identifier for this card (e.g., UUID).
+    [[nodiscard]] virtual QString getCardProviderId() const override = 0;
+
+    /// @param _cardProviderId Set the provider identifier for this card.
+    virtual void setCardProviderId(const QString &_cardProviderId) = 0;
+
+    /// @return The abbreviated set code (e.g., "NEO").
+    [[nodiscard]] virtual QString getCardSetShortName() const override = 0;
+
+    /// @param _cardSetShortName Set the abbreviated set code.
+    virtual void setCardSetShortName(const QString &_cardSetShortName) = 0;
+
+    /// @return The collector number of the card within its set.
+    [[nodiscard]] virtual QString getCardCollectorNumber() const override = 0;
+
+    /// @param _cardSetNumber Set the collector number.
+    virtual void setCardCollectorNumber(const QString &_cardSetNumber) = 0;
+
+    /**
+     * @brief Get the height of this node in the tree.
+     *
+     * For card nodes, height is always 0 because they are leaf nodes
+     * and do not contain children.
+     *
+     * @return 0
+     */
+    [[nodiscard]] int height() const override
+    {
+        return 0;
+    }
+
+    /**
+     * @brief Compare this card node against another for sorting.
+     *
+     * Uses the node’s current @c sortMethod to determine how to compare:
+     * - ByName: Alphabetical comparison.
+     * - ByNumber: Numerical comparison.
+     * - Default: Falls back to implementation-defined behavior.
+     *
+     * @param other Another node to compare against.
+     * @return true if this node should sort before @p other.
+     */
+    bool compare(AbstractDecklistNode *other) const override;
+
+    /**
+     * @brief Compare this card node to another by quantity.
+     * @param other Node to compare against.
+     * @return true if this node’s number < other’s number.
+     */
+    bool compareNumber(AbstractDecklistNode *other) const;
+
+    /**
+     * @brief Compare this card node to another by name.
+     * @param other Node to compare against.
+     * @return true if this node’s name comes before other’s name.
+     */
+    bool compareName(AbstractDecklistNode *other) const;
+
+    /**
+     * @brief Deserialize this node’s properties from XML.
+     * @param xml QXmlStreamReader positioned at the element.
+     * @return true if parsing succeeded.
+     *
+     * This supports loading deck files from Cockatrice’s XML format.
+     */
+    bool readElement(QXmlStreamReader *xml) override;
+
+    /**
+     * @brief Serialize this node’s properties to XML.
+     * @param xml Writer to append this node’s XML element.
+     *
+     * This supports saving deck files to Cockatrice’s XML format.
+     */
+    void writeElement(QXmlStreamWriter *xml) override;
+};
+
+#endif // COCKATRICE_ABSTRACT_DECK_LIST_CARD_NODE_H

libcockatrice_deck_list/libcockatrice/deck_list/tree/abstract_deck_list_node.cpp

@@ -0,0 +1,24 @@
+#include "abstract_deck_list_node.h"
+
+#include "inner_deck_list_node.h"
+
+AbstractDecklistNode::AbstractDecklistNode(InnerDecklistNode *_parent, int position)
+    : parent(_parent), sortMethod(Default)
+{
+    if (parent) {
+        if (position == -1) {
+            parent->append(this);
+        } else {
+            parent->insert(position, this);
+        }
+    }
+}
+
+int AbstractDecklistNode::depth() const
+{
+    if (parent) {
+        return parent->depth() + 1;
+    } else {
+        return 0;
+    }
+}

libcockatrice_deck_list/libcockatrice/deck_list/tree/abstract_deck_list_node.h

@@ -0,0 +1,185 @@
+/**
+ * @file abstract_deck_list_node.h
+ * @brief Defines the AbstractDecklistNode base class used as the foundation
+ *        for all nodes in the deck list tree (zones, groups, and cards).
+ *
+ * The deck list is modeled as a tree:
+ * - The invisible root node is managed by DeckListModel.
+ * - Top-level children are zones (e.g. Mainboard, Sideboard).
+ * - Zones contain grouping nodes (e.g. by type, color, or mana cost).
+ * - Grouping nodes contain card nodes.
+ *
+ * This abstract base class provides the interface and shared functionality
+ * for all node types. Concrete subclasses (InnerDecklistNode,
+ * DecklistCardNode, DecklistModelCardNode, etc.) implement the specifics.
+ */
+
+#ifndef COCKATRICE_ABSTRACT_DECK_LIST_NODE_H
+#define COCKATRICE_ABSTRACT_DECK_LIST_NODE_H
+
+#include <QtCore/QXmlStreamWriter>
+
+/**
+ * @enum DeckSortMethod
+ * @ingroup DeckModels
+ * @brief Defines the different sort strategies a node may use
+ *        to order its children.
+ *
+ * Sorting behavior is typically set by the DeckListModel when the user
+ * requests sorting in the UI.
+ *
+ * - ByNumber: Sort numerically (often by collector number).
+ * - ByName:   Sort alphabetically by card name.
+ * - Default:  No explicit sorting; insertion order is preserved.
+ */
+enum DeckSortMethod
+{
+    ByNumber, ///< Sort by numeric properties (e.g. collector number).
+    ByName,   ///< Sort by card name (locale-aware comparison).
+    Default   ///< Leave in insertion order.
+};
+
+class InnerDecklistNode;
+
+/**
+ * @class AbstractDecklistNode
+ * @ingroup DeckModels
+ * @brief Base class for all nodes in the deck list tree.
+ *
+ * This class defines the common interface for every node in the
+ * deck representation: zones, groupings, and cards.
+ *
+ * Responsibilities:
+ * - Maintain a pointer to its parent (if any).
+ * - Track the sorting method to be used for child nodes.
+ * - Provide a consistent interface for retrieving basic identifying
+ *   properties (name, set, collector number, provider ID).
+ * - Define abstract methods for XML serialization, used when saving
+ *   or loading deck files.
+ *
+ * Lifetime / Ownership:
+ * - Nodes are arranged hierarchically under @c InnerDecklistNode parents.
+ * - The parent takes ownership of its children; destruction cascades.
+ * - The DeckListModel holds the invisible root node, which in turn
+ *   owns the entire hierarchy.
+ *
+ * Extension:
+ * - @c InnerDecklistNode is the concrete subclass representing
+ *   "folders" in the tree (zones, groups).
+ * - @c DecklistCardNode and @c DecklistModelCardNode represent
+ *   actual card entries.
+ */
+class AbstractDecklistNode
+{
+protected:
+    /**
+     * @brief Pointer to the parent node, or nullptr if this is the root.
+     *
+     * Ownership note: The parent is responsible for destroying this node
+     * when it is removed from the tree.
+     */
+    InnerDecklistNode *parent;
+
+    /**
+     * @brief Current sorting strategy for this node's children.
+     *
+     * Sorting is applied recursively by the DeckListModel when
+     * the view requests it.
+     */
+    DeckSortMethod sortMethod;
+
+public:
+    /**
+     * @brief Construct a new AbstractDecklistNode and insert it into its parent.
+     *
+     * @param _parent Parent node. May be nullptr if this is the root.
+     * @param position Optional index at which to insert into the parent's
+     *        children. If -1, the node is appended to the end.
+     *
+     * If a parent is provided, the constructor automatically appends
+     * or inserts this node into the parent’s child list.
+     */
+    explicit AbstractDecklistNode(InnerDecklistNode *_parent = nullptr, int position = -1);
+
+    /// Virtual destructor. Child classes must clean up their resources.
+    virtual ~AbstractDecklistNode() = default;
+
+    /**
+     * @brief Set the sort method for this node’s children.
+     * @param method The sorting strategy to use.
+     *
+     * Subclasses may override if they need to apply additional logic.
+     */
+    virtual void setSortMethod(DeckSortMethod method)
+    {
+        sortMethod = method;
+    }
+
+    /**
+     * @name Core identification properties
+     *
+     * These methods provide a standard way for the model to retrieve
+     * identifying information about a node, regardless of type.
+     * @{
+     */
+    [[nodiscard]] virtual QString getName() const = 0;
+    [[nodiscard]] virtual QString getCardProviderId() const = 0;
+    [[nodiscard]] virtual QString getCardSetShortName() const = 0;
+    [[nodiscard]] virtual QString getCardCollectorNumber() const = 0;
+    /// @}
+
+    /**
+     * @brief Whether this node is the "deck header" (deck metadata).
+     *
+     * This distinguishes special nodes that represent deck-level
+     * information rather than cards or groupings.
+     */
+    [[nodiscard]] virtual bool isDeckHeader() const = 0;
+
+    /// @return The parent node, or nullptr if this is the root.
+    [[nodiscard]] InnerDecklistNode *getParent() const
+    {
+        return parent;
+    }
+
+    /**
+     * @brief Compute the depth of this node in the tree.
+     * @return Distance from the root (root = 0, children = 1, etc.).
+     */
+    [[nodiscard]] int depth() const;
+
+    /**
+     * @brief Compute the "height" of this node.
+     *
+     * Height is defined by subclasses; it usually represents how
+     * many levels of descendants this node spans.
+     *
+     * For example:
+     * - A card node has height 1.
+     * - A group node containing cards has height 2.
+     */
+    [[nodiscard]] virtual int height() const = 0;
+
+    /**
+     * @brief Compare this node against another for sorting.
+     *
+     * The semantics of comparison depend on the node type and the
+     * current @c sortMethod.
+     *
+     * @param other The node to compare against.
+     * @return true if this node should come before @p other.
+     */
+    virtual bool compare(AbstractDecklistNode *other) const = 0;
+
+    /**
+     * @name XML serialization
+     * These methods support reading and writing decks from/to
+     * Cockatrice deck XML format.
+     * @{
+     */
+    virtual bool readElement(QXmlStreamReader *xml) = 0;
+    virtual void writeElement(QXmlStreamWriter *xml) = 0;
+    /// @}
+};
+
+#endif // COCKATRICE_ABSTRACT_DECK_LIST_NODE_H

libcockatrice_deck_list/libcockatrice/deck_list/tree/deck_list_card_node.cpp

@@ -0,0 +1,8 @@
+#include "deck_list_card_node.h"
+
+DecklistCardNode::DecklistCardNode(DecklistCardNode *other, InnerDecklistNode *_parent)
+    : AbstractDecklistCardNode(_parent), name(other->getName()), number(other->getNumber()),
+      cardSetShortName(other->getCardSetShortName()), cardSetNumber(other->getCardCollectorNumber()),
+      cardProviderId(other->getCardProviderId())
+{
+}

libcockatrice_deck_list/libcockatrice/deck_list/tree/deck_list_card_node.h

@@ -0,0 +1,171 @@
+/**
+ * @file deck_list_card_node.h
+ * @brief Defines the DecklistCardNode class, representing a single card entry
+ *        in the deck list tree.
+ *
+ * DecklistCardNode is the concrete data-bearing node that corresponds to
+ * an individual card entry in a deck. It stores the card’s name, quantity,
+ * set information, and provider ID. These nodes live inside an
+ * InnerDecklistNode (e.g., under Mainboard → Group → Card).
+ */
+
+#ifndef COCKATRICE_DECK_LIST_CARD_NODE_H
+#define COCKATRICE_DECK_LIST_CARD_NODE_H
+
+#include "abstract_deck_list_card_node.h"
+
+#include <libcockatrice/utility/card_ref.h>
+
+/**
+ * @class DecklistCardNode
+ * @ingroup DeckModels
+ * @brief Concrete node type representing an actual card entry in the deck.
+ *
+ * This class extends AbstractDecklistCardNode to hold all information
+ * needed to uniquely identify a card printing within the deck.
+ *
+ * ### Role in the hierarchy:
+ * - Child of an InnerDecklistNode (which groups cards by zone or criteria).
+ * - Leaf node in the deck tree; it does not contain further children.
+ *
+ * ### Data stored:
+ * - @c name: Card’s display name.
+ * - @c number: Quantity of this card in the deck.
+ * - @c cardSetShortName: Abbreviation of the set (e.g., "NEO" for Neon Dynasty).
+ * - @c cardSetNumber: Collector number within the set.
+ * - @c cardProviderId: External provider identifier (e.g., UUID or MTGJSON ID).
+ *
+ * ### Usage:
+ * - Constructed directly when building a deck list from user input or file.
+ * - Used by DeckListModel to present cards in Qt views.
+ * - Convertible to @c CardRef for database lookups or cross-references.
+ *
+ * ### Ownership:
+ * - Owned by its parent InnerDecklistNode.
+ * - Destroyed automatically when its parent is destroyed.
+ */
+class DecklistCardNode : public AbstractDecklistCardNode
+{
+    QString name;             ///< Display name of the card.
+    int number;               ///< Quantity of this card in the deck.
+    QString cardSetShortName; ///< Short set code (e.g., "NEO").
+    QString cardSetNumber;    ///< Collector number within the set.
+    QString cardProviderId;   ///< External provider identifier (e.g., UUID).
+
+public:
+    /**
+     * @brief Construct a new DecklistCardNode.
+     *
+     * @param _name Display name of the card.
+     * @param _number Quantity of this card (default = 1).
+     * @param _parent Parent node in the tree (zone or group). May be nullptr.
+     * @param position Index to insert into parent’s children. -1 = append.
+     * @param _cardSetShortName Short set code (e.g., "NEO").
+     * @param _cardSetNumber Collector number within the set.
+     * @param _cardProviderId External provider ID (e.g., UUID).
+     *
+     * On construction, if a parent is provided, this node is inserted into
+     * the parent’s children list automatically.
+     */
+    explicit DecklistCardNode(QString _name = QString(),
+                              int _number = 1,
+                              InnerDecklistNode *_parent = nullptr,
+                              int position = -1,
+                              QString _cardSetShortName = QString(),
+                              QString _cardSetNumber = QString(),
+                              QString _cardProviderId = QString())
+        : AbstractDecklistCardNode(_parent, position), name(std::move(_name)), number(_number),
+          cardSetShortName(std::move(_cardSetShortName)), cardSetNumber(std::move(_cardSetNumber)),
+          cardProviderId(std::move(_cardProviderId))
+    {
+    }
+
+    /**
+     * @brief Copy constructor with new parent assignment.
+     * @param other Existing DecklistCardNode to copy.
+     * @param _parent Parent node for the copy.
+     *
+     * Creates a deep copy of the card node’s properties, but attaches
+     * the new instance to a different parent in the tree.
+     */
+    explicit DecklistCardNode(DecklistCardNode *other, InnerDecklistNode *_parent);
+
+    /// @return The quantity of this card.
+    [[nodiscard]] int getNumber() const override
+    {
+        return number;
+    }
+
+    /// @param _number Set the quantity of this card.
+    void setNumber(int _number) override
+    {
+        number = _number;
+    }
+
+    /// @return The display name of this card.
+    [[nodiscard]] QString getName() const override
+    {
+        return name;
+    }
+
+    /// @param _name Set the display name of this card.
+    void setName(const QString &_name) override
+    {
+        name = _name;
+    }
+
+    /// @return The provider identifier for this card.
+    [[nodiscard]] QString getCardProviderId() const override
+    {
+        return cardProviderId;
+    }
+
+    /// @param _providerId Set the provider identifier for this card.
+    void setCardProviderId(const QString &_providerId) override
+    {
+        cardProviderId = _providerId;
+    }
+
+    /// @return The short set code (e.g., "NEO").
+    [[nodiscard]] QString getCardSetShortName() const override
+    {
+        return cardSetShortName;
+    }
+
+    /// @param _cardSetShortName Set the short set code.
+    void setCardSetShortName(const QString &_cardSetShortName) override
+    {
+        cardSetShortName = _cardSetShortName;
+    }
+
+    /// @return The collector number of this card within its set.
+    [[nodiscard]] QString getCardCollectorNumber() const override
+    {
+        return cardSetNumber;
+    }
+
+    /// @param _cardSetNumber Set the collector number.
+    void setCardCollectorNumber(const QString &_cardSetNumber) override
+    {
+        cardSetNumber = _cardSetNumber;
+    }
+
+    /// @return Always false; card nodes are not deck headers.
+    [[nodiscard]] bool isDeckHeader() const override
+    {
+        return false;
+    }
+
+    /**
+     * @brief Convert this node to a CardRef.
+     *
+     * @return A CardRef with the card’s name and provider ID, suitable
+     *         for database lookups or comparison with other card sources.
+     */
+    [[nodiscard]] CardRef toCardRef() const
+    {
+        return {name, cardProviderId};
+    }
+};
+
+#endif // COCKATRICE_DECK_LIST_CARD_NODE_H

libcockatrice_deck_list/libcockatrice/deck_list/tree/inner_deck_list_node.cpp

@@ -0,0 +1,199 @@
+#include "inner_deck_list_node.h"
+
+#include "deck_list_card_node.h"
+
+InnerDecklistNode::InnerDecklistNode(InnerDecklistNode *other, InnerDecklistNode *_parent)
+    : AbstractDecklistNode(_parent), name(other->getName())
+{
+    for (int i = 0; i < other->size(); ++i) {
+        auto *inner = dynamic_cast<InnerDecklistNode *>(other->at(i));
+        if (inner) {
+            new InnerDecklistNode(inner, this);
+        } else {
+            new DecklistCardNode(dynamic_cast<DecklistCardNode *>(other->at(i)), this);
+        }
+    }
+}
+
+InnerDecklistNode::~InnerDecklistNode()
+{
+    clearTree();
+}
+
+QString InnerDecklistNode::visibleNameFromName(const QString &_name)
+{
+    if (_name == DECK_ZONE_MAIN) {
+        return QObject::tr("Maindeck");
+    } else if (_name == DECK_ZONE_SIDE) {
+        return QObject::tr("Sideboard");
+    } else if (_name == DECK_ZONE_TOKENS) {
+        return QObject::tr("Tokens");
+    } else {
+        return _name;
+    }
+}
+
+void InnerDecklistNode::setSortMethod(DeckSortMethod method)
+{
+    sortMethod = method;
+    for (int i = 0; i < size(); i++) {
+        at(i)->setSortMethod(method);
+    }
+}
+
+QString InnerDecklistNode::getVisibleName() const
+{
+    return visibleNameFromName(name);
+}
+
+void InnerDecklistNode::clearTree()
+{
+    for (int i = 0; i < size(); i++)
+        delete at(i);
+    clear();
+}
+
+AbstractDecklistNode *InnerDecklistNode::findChild(const QString &_name)
+{
+    for (int i = 0; i < size(); i++) {
+        if (at(i)->getName() == _name) {
+            return at(i);
+        }
+    }
+    return nullptr;
+}
+
+AbstractDecklistNode *InnerDecklistNode::findCardChildByNameProviderIdAndNumber(const QString &_name,
+                                                                                const QString &_providerId,
+                                                                                const QString &_cardNumber)
+{
+    for (const auto &i : *this) {
+        if (!i || i->getName() != _name) {
+            continue;
+        }
+        if (_cardNumber != "" && i->getCardCollectorNumber() != _cardNumber) {
+            continue;
+        }
+        if (_providerId != "" && i->getCardProviderId() != _providerId) {
+            continue;
+        }
+        return i;
+    }
+    return nullptr;
+}
+
+int InnerDecklistNode::height() const
+{
+    return at(0)->height() + 1;
+}
+
+int InnerDecklistNode::recursiveCount(bool countTotalCards) const
+{
+    int result = 0;
+    for (int i = 0; i < size(); i++) {
+        auto *node = dynamic_cast<InnerDecklistNode *>(at(i));
+
+        if (node) {
+            result += node->recursiveCount(countTotalCards);
+        } else if (countTotalCards) {
+            result += dynamic_cast<AbstractDecklistCardNode *>(at(i))->getNumber();
+        } else {
+            result++;
+        }
+    }
+    return result;
+}
+
+bool InnerDecklistNode::compare(AbstractDecklistNode *other) const
+{
+    switch (sortMethod) {
+        case ByNumber:
+            return compareNumber(other);
+        case ByName:
+            return compareName(other);
+        default:
+            return false;
+    }
+}
+
+bool InnerDecklistNode::compareNumber(AbstractDecklistNode *other) const
+{
+    auto *other2 = dynamic_cast<InnerDecklistNode *>(other);
+    if (other2) {
+        int n1 = recursiveCount(true);
+        int n2 = other2->recursiveCount(true);
+        return (n1 != n2) ? (n1 > n2) : compareName(other);
+    } else {
+        return false;
+    }
+}
+
+bool InnerDecklistNode::compareName(AbstractDecklistNode *other) const
+{
+    auto *other2 = dynamic_cast<InnerDecklistNode *>(other);
+    if (other2) {
+        return (getName() > other2->getName());
+    } else {
+        return false;
+    }
+}
+
+bool InnerDecklistNode::readElement(QXmlStreamReader *xml)
+{
+    while (!xml->atEnd()) {
+        xml->readNext();
+        const QString childName = xml->name().toString();
+        if (xml->isStartElement()) {
+            if (childName == "zone") {
+                auto *newZone = new InnerDecklistNode(xml->attributes().value("name").toString(), this);
+                newZone->readElement(xml);
+            } else if (childName == "card") {
+                auto *newCard = new DecklistCardNode(
+                    xml->attributes().value("name").toString(), xml->attributes().value("number").toString().toInt(),
+                    this, -1, xml->attributes().value("setShortName").toString(),
+                    xml->attributes().value("collectorNumber").toString(), xml->attributes().value("uuid").toString());
+                newCard->readElement(xml);
+            }
+        } else if (xml->isEndElement() && (childName == "zone"))
+            return false;
+    }
+    return true;
+}
+
+void InnerDecklistNode::writeElement(QXmlStreamWriter *xml)
+{
+    xml->writeStartElement("zone");
+    xml->writeAttribute("name", name);
+    for (int i = 0; i < size(); i++)
+        at(i)->writeElement(xml);
+    xml->writeEndElement(); // zone
+}
+
+QVector<QPair<int, int>> InnerDecklistNode::sort(Qt::SortOrder order)
+{
+    QVector<QPair<int, int>> result(size());
+
+    // Initialize temporary list with contents of current list
+    QVector<QPair<int, AbstractDecklistNode *>> tempList(size());
+    for (int i = size() - 1; i >= 0; --i) {
+        tempList[i].first = i;
+        tempList[i].second = at(i);
+    }
+
+    // Sort temporary list
+    auto cmp = [order](const auto &a, const auto &b) {
+        return (order == Qt::AscendingOrder) ? (b.second->compare(a.second)) : (a.second->compare(b.second));
+    };
+
+    std::sort(tempList.begin(), tempList.end(), cmp);
+
+    // Map old indexes to new indexes and
+    // copy temporary list to the current one
+    for (int i = size() - 1; i >= 0; --i) {
+        result[i].first = tempList[i].first;
+        result[i].second = i;
+        replace(i, tempList[i].second);
+    }
+
+    return result;
+}

libcockatrice_deck_list/libcockatrice/deck_list/tree/inner_deck_list_node.h

@@ -0,0 +1,228 @@
+/**
+ * @file inner_deck_list_node.h
+ * @brief Defines the InnerDecklistNode class, which represents
+ *        structural nodes (zones and groups) in the deck tree.
+ *
+ * The deck tree consists of:
+ * - A root node (invisible).
+ * - Zones (Main, Sideboard, Tokens).
+ * - Optional grouping nodes (e.g., by type, color, or mana cost).
+ * - Card nodes as leaves.
+ *
+ * InnerDecklistNode implements the zone/group nodes and provides
+ * storage and management of child nodes.
+ */
+
+#ifndef COCKATRICE_INNER_DECK_LIST_NODE_H
+#define COCKATRICE_INNER_DECK_LIST_NODE_H
+
+#include "abstract_deck_list_node.h"
+
+/// Constant for the "main" deck zone name.
+#define DECK_ZONE_MAIN "main"
+/// Constant for the "sideboard" zone name.
+#define DECK_ZONE_SIDE "side"
+/// Constant for the "tokens" zone name.
+#define DECK_ZONE_TOKENS "tokens"
+
+/**
+ * @class InnerDecklistNode
+ * @brief Represents a container node in the deck list hierarchy
+ *        (zones and groupings).
+ *
+ * Unlike DecklistCardNode, which holds leaf card data, this class
+ * manages collections of child nodes, which may themselves be
+ * InnerDecklistNode or DecklistCardNode objects.
+ *
+ * ### Role in the hierarchy:
+ * - Root node (invisible): Holds zones.
+ * - Zone nodes: "main", "side", "tokens".
+ * - Grouping nodes: Created dynamically when grouping by type,
+ *   color, or mana cost.
+ * - Card nodes: Always children of an InnerDecklistNode.
+ *
+ * ### Design notes:
+ * - Inherits from AbstractDecklistNode (tree interface) and
+ *   QList<AbstractDecklistNode*> (storage of children).
+ *   This allows direct QList-style manipulation of children while
+ *   still presenting a polymorphic node interface.
+ *
+ * ### Responsibilities:
+ * - Store a display name.
+ * - Own and manage child nodes (insert, clear, find).
+ * - Provide recursive operations such as counting cards or computing height.
+ * - Implement sorting logic for reordering children.
+ * - Implement XML serialization for persistence.
+ *
+ * ### Ownership:
+ * - Owns all child nodes stored in the QList. The destructor
+ *   recursively deletes children.
+ */
+class InnerDecklistNode : public AbstractDecklistNode, public QList<AbstractDecklistNode *>
+{
+    QString name; ///< Internal identifier for this node (zone or group name).
+
+public:
+    /**
+     * @brief Construct a new InnerDecklistNode.
+     *
+     * @param _name Internal name (e.g., "main", "side", "tokens", or group label).
+     * @param _parent Parent node (may be nullptr for the root).
+     * @param position Optional index for insertion into parent. -1 = append.
+     */
+    explicit InnerDecklistNode(QString _name = QString(), InnerDecklistNode *_parent = nullptr, int position = -1)
+        : AbstractDecklistNode(_parent, position), name(std::move(_name))
+    {
+    }
+
+    /**
+     * @brief Copy constructor with parent reassignment.
+     * @param other Node to copy from (deep copy of children).
+     * @param _parent Parent node for the copy.
+     */
+    explicit InnerDecklistNode(InnerDecklistNode *other, InnerDecklistNode *_parent = nullptr);
+
+    /**
+     * @brief Destructor. Recursively deletes all child nodes.
+     */
+    ~InnerDecklistNode() override;
+
+    /**
+     * @brief Set the sorting method for this node and all children.
+     * @param method Sort method to apply recursively.
+     */
+    void setSortMethod(DeckSortMethod method) override;
+
+    /// @return The internal name of this node.
+    [[nodiscard]] QString getName() const override
+    {
+        return name;
+    }
+
+    /// @param _name Set the internal name of this node.
+    void setName(const QString &_name)
+    {
+        name = _name;
+    }
+
+    /**
+     * @brief Translate an internal name into a user-visible name.
+     *
+     * For example, the internal string "main" is presented as
+     * "Mainboard" in the UI.
+     *
+     * @param _name Internal identifier.
+     * @return Display-friendly string.
+     */
+    static QString visibleNameFromName(const QString &_name);
+
+    /**
+     * @brief Get this node’s display-friendly name.
+     * @return Human-readable name (zone/group name).
+     */
+    [[nodiscard]] virtual QString getVisibleName() const;
+
+    /// @return Always empty for container nodes.
+    [[nodiscard]] QString getCardProviderId() const override
+    {
+        return "";
+    }
+
+    /// @return Always empty for container nodes.
+    [[nodiscard]] QString getCardSetShortName() const override
+    {
+        return "";
+    }
+
+    /// @return Always empty for container nodes.
+    [[nodiscard]] QString getCardCollectorNumber() const override
+    {
+        return "";
+    }
+
+    /// @return Always true; InnerDecklistNode represents deck structure.
+    [[nodiscard]] bool isDeckHeader() const override
+    {
+        return true;
+    }
+
+    /**
+     * @brief Delete all children of this node, recursively.
+     */
+    void clearTree();
+
+    /**
+     * @brief Find a direct child node by name.
+     * @param _name Name to match.
+     * @return Pointer to child node, or nullptr if not found.
+     */
+    AbstractDecklistNode *findChild(const QString &_name);
+
+    /**
+     * @brief Find a child card node by name, provider ID, and collector number.
+     *
+     * Searches immediate children only.
+     *
+     * @param _name Card name to match.
+     * @param _providerId Optional provider ID to match.
+     * @param _cardNumber Optional collector number to match.
+     * @return Pointer to child node if found, nullptr otherwise.
+     */
+    AbstractDecklistNode *findCardChildByNameProviderIdAndNumber(const QString &_name,
+                                                                 const QString &_providerId = "",
+                                                                 const QString &_cardNumber = "");
+
+    /**
+     * @brief Compute the height of this node.
+     * @return Maximum depth of descendants + 1.
+     */
+    [[nodiscard]] int height() const override;
+
+    /**
+     * @brief Count cards recursively under this node.
+     * @param countTotalCards If true, sums up quantities of cards.
+     *        If false, counts unique card nodes.
+     * @return Total count.
+     */
+    [[nodiscard]] int recursiveCount(bool countTotalCards = false) const;
+
+    /**
+     * @brief Compare this node against another for sorting.
+     *
+     * Uses current @c sortMethod to determine the comparison.
+     *
+     * @param other Node to compare.
+     * @return true if this node should sort before @p other.
+     */
+    bool compare(AbstractDecklistNode *other) const override;
+
+    /// @copydoc compare(AbstractDecklistNode*) const
+    bool compareNumber(AbstractDecklistNode *other) const;
+
+    /// @copydoc compare(AbstractDecklistNode*) const
+    bool compareName(AbstractDecklistNode *other) const;
+
+    /**
+     * @brief Sort this node’s children recursively.
+     *
+     * @param order Ascending or descending.
+     * @return A QVector of (oldIndex, newIndex) pairs indicating
+     *         how children were reordered.
+     */
+    QVector<QPair<int, int>> sort(Qt::SortOrder order = Qt::AscendingOrder);
+
+    /**
+     * @brief Deserialize this node and its children from XML.
+     * @param xml Reader positioned at this element.
+     * @return true if parsing succeeded.
+     */
+    bool readElement(QXmlStreamReader *xml) override;
+
+    /**
+     * @brief Serialize this node and its children to XML.
+     * @param xml Writer to append elements to.
+     */
+    void writeElement(QXmlStreamWriter *xml) override;
+};
+
+#endif // COCKATRICE_INNER_DECK_LIST_NODE_H