deck_list.h

Go to the documentation of this file.

 
#ifndef DECKLIST_H
#define DECKLIST_H
 
#include "deck_list_memento.h"
#include "deck_list_node_tree.h"
#include "libcockatrice/protocol/pb/move_card_to_zone.pb.h"
#include "libcockatrice/utility/card_ref.h"
#include "sideboard_plan.h"
#include "tree/inner_deck_list_node.h"
 
#include <QList>
#include <QMap>
#include <QSet>
#include <QString>
#include <QStringList>
#include <functional>
#include <libcockatrice/utility/playmat_params.h>
 
class DecklistCardNode;
class QIODevice;
class QTextStream;
class QXmlStreamReader;
class QXmlStreamWriter;

class DeckList
{
public:
    struct Metadata
    {
        QString name;                
        QString comments;            
        QString gameFormat;          
        CardRef bannerCard;          
        QStringList tags;            
        QString lastLoadedTimestamp; 
        PlaymatInfo playmat;         

        bool isEmpty() const;

        bool readElement(QXmlStreamReader *xml, const QString &childName);

        void write(QXmlStreamWriter *xml) const;
    };
 
private:
    Metadata metadata;                           
    QMap<QString, SideboardPlan> sideboardPlans; 
    DecklistNodeTree tree;                       

    mutable QString cachedDeckHash;


    bool seekToNextElement(QXmlStreamReader *xml);

    void readDeckBody(QXmlStreamReader *xml);
 
public:
    void setName(const QString &_name = QString())
    {
        metadata.name = _name;
    }
    void setComments(const QString &_comments = QString())
    {
        metadata.comments = _comments;
    }
    void setTags(const QStringList &_tags = QStringList())
    {
        metadata.tags = _tags;
    }
    void addTag(const QString &_tag)
    {
        metadata.tags.append(_tag);
    }
    void clearTags()
    {
        metadata.tags.clear();
    }
    void setBannerCard(const CardRef &_bannerCard = {})
    {
        metadata.bannerCard = _bannerCard;
    }
    void setPlaymat(const PlaymatInfo &_playmat = {})
    {
        metadata.playmat = _playmat;
    }
    void setLastLoadedTimestamp(const QString &_lastLoadedTimestamp = QString())
    {
        metadata.lastLoadedTimestamp = _lastLoadedTimestamp;
    }
    void setGameFormat(const QString &_gameFormat = QString())
    {
        metadata.gameFormat = _gameFormat;
    }


    explicit DeckList();
    explicit DeckList(const QString &nativeString);
    DeckList(const Metadata &metadata,
             const DecklistNodeTree &tree,
             const QMap<QString, SideboardPlan> &sideboardPlans = {});

    DecklistNodeTree *getTree()
    {
        return &tree;
    }

    const Metadata &getMetadata() const
    {
        return metadata;
    }
    QString getName() const
    {
        return metadata.name;
    }
    QString getComments() const
    {
        return metadata.comments;
    }
    QStringList getTags() const
    {
        return metadata.tags;
    }
    CardRef getBannerCard() const
    {
        return metadata.bannerCard;
    }
    PlaymatInfo getPlaymat() const
    {
        return metadata.playmat;
    }
    QString getLastLoadedTimestamp() const
    {
        return metadata.lastLoadedTimestamp;
    }
    QString getGameFormat() const
    {
        return metadata.gameFormat;
    }

 
    bool isBlankDeck() const
    {
        return metadata.isEmpty() && getCardList().isEmpty();
    }

    QList<MoveCard_ToZone> getCurrentSideboardPlan() const;
    void setCurrentSideboardPlan(const QList<MoveCard_ToZone> &plan);
    const QMap<QString, SideboardPlan> &getSideboardPlans() const
    {
        return sideboardPlans;
    }


    bool readElement(QXmlStreamReader *xml);
    void write(QXmlStreamWriter *xml) const;
    bool loadFromXml(QXmlStreamReader *xml);
    bool loadFromString_Native(const QString &nativeString);
    QString writeToString_Native() const;
    bool loadFromFile_Native(QIODevice *device);
    bool saveToFile_Native(QIODevice *device) const;

    bool loadFromStream_Plain(QTextStream &stream,
                              bool preserveMetadata,
                              const std::function<QString(const QString &)> &cardNameNormalizer);
    bool loadFromFile_Plain(QIODevice *device, const std::function<QString(const QString &)> &cardNameNormalizer);
    bool saveToStream_Plain(QTextStream &stream, bool prefixSideboardCards, bool slashTappedOutSplitCards) const;
    bool
    saveToFile_Plain(QIODevice *device, bool prefixSideboardCards = true, bool slashTappedOutSplitCards = false) const;
    QString writeToString_Plain(bool prefixSideboardCards = true, bool slashTappedOutSplitCards = false) const;

    void cleanList(bool preserveMetadata = false);
    bool isEmpty() const
    {
        return tree.isEmpty() && metadata.isEmpty() && sideboardPlans.isEmpty();
    }
    QStringList getCardList(const QSet<QString> &restrictToZones = {}) const;
    QList<CardRef> getCardRefList(const QSet<QString> &restrictToZones = {}) const;
    QList<const DecklistCardNode *> getCardNodes(const QSet<QString> &restrictToZones = {}) const;
    QList<const InnerDecklistNode *> getZoneNodes(const QSet<QString> &restrictToZones = {}) const;
    int getSideboardSize() const;
 
    DecklistCardNode *addCard(const QString &cardName,
                              const QString &zoneName,
                              int position = -1,
                              const QString &cardSetName = QString(),
                              const QString &cardSetCollectorNumber = QString(),
                              const QString &cardProviderId = QString(),
                              const bool formatLegal = true);

    QString getDeckHash() const;
    void refreshDeckHash();

    void forEachCard(const std::function<void(InnerDecklistNode *, DecklistCardNode *)> &func) const;
    DeckListMemento createMemento(const QString &reason) const;
    void restoreMemento(const DeckListMemento &m);
};
 
#endif