Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Printable View

Show 50 post(s) from this thread on one page

30th December 2016, 08:41
Nizars

Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML
Hi!

I have been using Qt the last couple of months for a class project and I am really loving it especially the QML part of it. It really is exactly what I would like to work with. However, I have gotten stuck at a certain obsticle the last couple of weeks and I would really appreciate some help with it.

The application that I am building is basically an interface to manage, sort and filter through PokÃ©mon cards in the users collection. The user creates a new PokÃ©mon cards album and populates it with PokÃ©mon Cards.

Here is how the UI looks like:
https://i.imgur.com/yf716Ea.png

For example:
The user creates two albums, one called "Favorites" and another called "Wishlist". The user can then add cards to those Albums. Once that is done, the user will be able to view the available albums in a tab or a page and clicking on an album will open up a view that display the cards in that album.

I have found different ways to go about this implementation. One of them uses a TreeItem class and TreeModel class to create this nested QList of objects. The problem is that I will need to have different classes with different properties and children depending on where they are in the Tree. Here is a diagram I made to show what I mean:
https://i.imgur.com/eWr8cc9.jpg

Since the Card objects won't exist outside of Albums, I have decided to pass them to the Albums directly rather than using pointers. However, this means that appending a card to an Album will demand a copy constructor if I use the following method:
Code:

avoid Album::addCard(const Card &scarf) { BeginInsertRows(); m_cards << card; EndInsertRows(); }
The problem here is that I keep running into problems with the creating the Copy constructor and any methods that I need to add to the class to make the constructor work.
So here is how the approach that I took looks like:

main.cpp:
I included the three header files for the classes App, Album and Card and registered them using qmlregistertype. I also created an instance of the App class and set it as root context property to use the models later on.

App:
This class basically fulfills the uppermost parent in the tree. It has no properties such as name and so on. Just the minimal tree root data methods to add and remove Albums to and from it on run time in it's QList<Album> m_album private member. It also has a NameRole to get the name of the Albums it contains.

Album:
It is added to an App object instance. It points to it's parent through a private App* m_parentApp variable. It has a QString m_name and it can add cards to it's QList<Card>m_cards private list. It also has several Roles used to retrieve information about cards in it using the data method.

Card:
It is added to Albums, has no list of children. Points to it's parent Album. Has many variables such as Name, ID, ImageURL and so on.

All the classes inherit QAbstractListModel publicly. Not sure if they really should but that's what I have found people recommending on threads.

The problem with creating the copy constructor (Album(const Album &source);) is that when I am adding an Album to an App (m_albums << album) is this:
I am not really sure how to go about iteratating through the children appended to the object being copied.

I created a for() loop that ends at m_cards.count(). Then I noticed that I needed a way to access the card data in the Album being copied for each iteration but I have found no way to make it work. Using the source.data(index, role) expects a QmlIndex rather than an int. I tried dynamic_casting, not sure if I should but that didn't work either so I thought that I should create a new method that retrieves the Card from the Album by value or reference so that my copy constructor works but haven't had any success there.
I tried:
Code:

Card getCard(int row) { Return m_cards.at(row);
}
But that didn't work, I tried using Card* and Card& as well as m_cards[index.row()] but that didn't work.
The only reason I am doing this is so that my copy constructor which is automatically called when appending an album to and App or a Card to an Album can do something like this:
Code:

For all the children in the objects QList: This->name = source.m_cards.name();
I would appreciate some help with this. Feel free to give any feedback about the approach or suggest a different too if you think that something else would be better.

Thanks. :)
30th December 2016, 10:44
anda_skoa

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

There are multiple options for this.

1) You could have an internal data structure and have a model that presents the album "view" on the data and models that present the card "view" of the data.
Depending on whether you can show multiple albums at the same time, you might need more than one instance of the latter.

2) Another option is to make some of the data classes themselves into models themselves, e.g. the "Album" class and the "App" class.

3) The "App" class could also be just a normal QObject derived class and have the "Album" models as a list property.

Option (1) requires separate classes for data and models, but also allows the data classes to be copyable.
I.e. more classes and thus more core, but treating data separately from the QML adapter to the data.

Options (2) and (3) need at least the "Album" class as a QAbstractListModel subclass, so a QList<Album*> as the container in "App".

When you write "all classes inherit QAbstractListModel" it looks like your chosen approach is (2), but do you also mean "Card" is a list model?

Cheers,
_
30th December 2016, 11:32
Nizars

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Hi Anda,

Thanks for reading the problem I am having and I appreciate the overview of the different options I have.

My goal is to develop the application further and add the ability to search through the albums, sort by a specific variable and possibly even drag and drop a card to a different Album.

The more important function however is the ability to save the "session" to a local file and load from it on start up. It could be a parent class to App called AppManager that has the methods ExportLibrary and ImportLibrary to and from a local file. I have not decided on a format for the data yet, I am really open for anything.

I am mentioning this to help narrow down the more appropriate path to take for the data structure. Once I have gotten the current obsticle fixed and learned how to implement it, I will change the root context property from App to AppManager and have it provide the App instance to the application.

I assume that this narrows down my options to option 1 for the most suitable data structure which is having the data classes separate from the from the models.

The Card class shouldn't inherit publicly from QAbstractListModel. That was a mistake from my part. It however should be registered and made available to the QML to help instanciate Card objects for the Albums.

What do you think, does it sound right?

Cheers.
30th December 2016, 14:09
anda_skoa

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

I don't see anything that would narrow your option down to just (1), however, it is often benefitial to not design data structures and data handling with just the UI's needs in mind.

Lets look at this with a simplied example, an address book:

1) for that I would have
* a Contact class that can hold all data for a single address book entry
* an AddressBook class that has a list or maybe even a hash of Contact objects and which would have methods to add/remove/change/get/list contacts

2a) a list model that gets a pointer to an AddressBook and provides the list of contacts, contact details as roles

2b) an Import/Export class or classes that also get an AddressBook pointer or reference and implement data I/O

3) optionally, a Contact adapter/editor class that serves as an QML adapter for modifying a single contact. It would get a Contact object and provide its data as separate Q_PROPERTY fields, it can provide methods to check for validity of the data, etc.

(2a) and (2b) are different usages of the data but can still work on the same data. the base classes only need to ensure they can provide all the functionality required for these two use cases.

For your application I wonder if you really want cards nested inside albums.
I.e. is an Album not just a "view" of cards, a selection from the whole?
For example could a user have "All my cards", "All time favorites", "Favorite Water Pokemons", with the same "Vaporeon" card being in all three?

Cheers,
_
30th December 2016, 14:42
Nizars

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

You make a good point!
I didn't really think of that. The thing is, for now at least and to narrow down my project, I have decided to work only with one set of Pokemon cards. Those cards exist in <cardID>.json files in a resource. Those JSON documents contain all the variable values for the cards such name, hp, attacks and so on. The card images exist in another folder in the resources as <cardID>.jpg. I have done this so that I have something to work with and not risk spending a month or two working with network, ssl, cache, json classes and risk not having anything to present as the deadline aproaches. I do like the project I am working with and I am planning to add those functionalities in the future, maybe even a function that adds cards by scanning them with a phone camera. The JSON documents are retreived from: pokemontcg.io but that is something that I won't touch until the main application fully works.

My line of thinking has been that when the user wants to add a card to an album. He or she will type the name or the id of the card and the program creates an instance of that card in the album. If he doesn't add it to the album and decided just to see it, it will be deleted once he exits the view. I also thought of having an instance of all the cards pre-loaded in a hidden default album that the App uses to display the cards before the user adds them to his or her Album.

You make a good point about a Card being available in more than one album. I guess there should be a default "All my cards" Album. I guess cards in that Album determines what cards are made available to the other albums. I assume that this would be a bit problematic if the user wants to create a "My wishlist" or "To buy" Album. There is also the problem of duplicate cards.

I will try to rethink the relationships between the Albums and between the Cards and Albums. I think that having an Album as an isolated container of cards from other Cards in other Albums might make the implementation a bit easier assuming that the user will manually add Cards to Albums and not expect them to be shared among the Albums. I can however create a "view" that shows all the cards in all the albums or multiple Albums.

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Just sketching some ideas here:

Code:

class Card
{
    QString id;
    QString name;
    // ....
};
 
class CardManager : public QObject
{
    Q_OBJECT
 
public:
    // returns an invalid card if ID is not found, e.g. Card object with empty "id"
    Card addCardById(const QString &id);
    Card addCardByName(const QString &name);
 
    Card card(const QString &id) const;
    QList<Card> cards() const;
 
    int count() const;
 
signals:
    void cardAdded(const QString &id);
    void cardRemoved(const QString &id);
 
private:
    QList<Card> m_cards;
};

Code:

class Album
{
    QString id;
    QString name;
    QStringList cardIDs;
};
 
class AlbumManager : public QObject
{
    Q_OBJECT
public:
    Album createAlbum(const QString &name);
 
    Album album(const QString &id) const;
 
    QList<Album> albums() const;
 
    int count() const;
 
    void addCard(const QString &albumId, const QString &cardId);
    void removeCard(const QString &albumId, const QString &cardId);
 
signals:
    void albumAdded(const QString &id);
    void albumRemoved(const QString &id);
 
    void cardAdded(const QString &albumId, const QStringList &cardIDs);
    void cardRemoved(const QString &albumId, const QStringList &cardIDs);
};

Code:

class AbstractCardModel : public QAbstractListModel
{
    Q_OBJECT
public:
    enum Roles {
        IdRole = Qt::UserRole + 1,
        NameRole,
        // ....
    }
 
    explicit AbstractCardModel(CardManager *cardManager, QObject *parent = 0);
 
    // this uses cardForIndex to get the card, then uses role to return the actual data
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
 
protected:
    QHash<int, QByteArray> roleNames() const;
 
    virtual Card cardForIndex(const QModelIndex &index) const = 0;
 
protected:
    CardManager *m_cardManager;
};

Code:

// for showing the cards of a single album
class AlbumCardsModel : public AbstractCardsModel
{
    Q_OBJECT
public:
    AlbumCardsModel(AlbumManager *albumManager, CardManager *cardManager, QObject *parent = 0);
 
    void showAlbum(const QString &albumId);
 
    int rowCount(const QModelIndex &parent) const;
 
protected:
    Card cardForIndex(const QModelIndex &index) const;
 
private slots:
    // gets connected to m_albumManager's albumRemoved() signal
    void onAlbumRemoved(const QString &albumId);
 
    void onCardAdded(const QString &albumId, const QString cardId);
    void onCardRemoved(const QString &albumId, const QString cardId);
 
private:
    AlbumManager *m_albumManager;
    Album m_album;
};
 
void AlbumCardsModel::showAlbum(const QString &albumId)
{
    beginResetModel();
 
    m_album = m_albumManager->album(albumId);
 
    endResetModel();
}
 
int AlbumCardsModel::rowCount(const QModelIndex&) const
{
    return m_album.cardIDs.count();
}
 
Card AlbumCardsModel::cardForIndex(const QModelIndex &index) const
{
    return m_cardManager->card(m_album.cardIDs.at(index.row());
}
 
void AlbumCardsModel::onAlbumRemoved(const QString &albumId)
{
    if (albumId != m_album.id) return;
 
    beginResetModel();
    m_album = Album();
    endResetModel();
}
 
void AlbumCardsModel::onCardAdded(const QString &albumId, const QString &cardId)
{
    if (albumId != m_album.id) return;
 
    const Album updatedAlbum = m_albumManager->album(albumId);
    const int row = updatedAlbum.cardIDs.indexOf(cardId);
 
    beginInsertRows(QModelIndex(), row, row);
 
    m_album = updatedAlbum;
 
    endInsertRows();
}
 
void AlbumCardsModel::onCardRemoved(const QString &albumId, const QString &cardId)
{
    if (albumId != m_album.id) return;
 
    const Album updatedAlbum = m_albumManager->album(albumId);
    const int row = m_album.cardIDs.indexOf(cardId);
 
    beginRemoveRows(QModelIndex(), row, row);
 
    m_album = updatedAlbum;
 
    endRemoveRows();
}

Cheers,
_

30th December 2016, 20:04
Nizars

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

I really appreciate your time and all the help you are offering me on this!

I have a quick question for you while I finish making changes to my classes.

What is the role of a <class>Manager class? I am just trying to understand how it fits in.
Say I want to to add copy constractors and assignment opperators for the App, Album and Card classes, where would those be implemented? in their respective classes? or in the their accompanying <class>Manager classes?
What about the Setter and Getter class methods such as "QString getCardName() const;"? Same with the default and overloaded constructors? should I even have a default constructor in the original class?

I have noticed that you combine each class and it's Manager class in the same document. Is there a reason or a benifit behind this practise? or is this simple down to preference and time saving?
I have created three different classes for each of the "core" classes. An Album class, an AlbumsManager class and an AlbumModel class. I am totally open to changing it to the template you wrote if it makes a difference.
31st December 2016, 00:58
d_stranz

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Yes, anda_skoa has been very generous with his help on this one and has given you a well-thought-out and flexible design.

If you use the Card and Album classes as anda_skoa has defined them in his code, you don't actually need an explicit copy constructor (or even an assignment operator) because C++ will implement default ones for you. Usually default constructor / assignment does a bitwise copy of the right-hand side instance (i.e. the instance you are copying from), except when the class being copied contains member variables which themselves have copy / assignment operators, which QString and QStringList do (and which fundamental types like int, float, etc. also have). If you add anything to the definitions of these classes which does not have explicit copy / assignment, you'll either have to make copy and assignment methods for them, or implement them in the Card or Album class. For example, if you add a pointer variable, you'll probably want to either wrap it in a smart pointer (which has copy / assignment), make a deep copy of the contents of the instance pointed to, or add another "manager" which is in charge of the lifetime of these pointers (rather than delete them in the Card or Album destructor).

Combining the Card and CardManager class in the same file is basically just for convenience. More importantly, only the CardManager should be allowed to create Card instances, because then it will automatically add them to the list of Card instances it is managing. Likewise for Album and AlbumManager. You can't have a standalone, unmanaged Card or Album. But on the other hand, anda_skoa's design allows for cards that belong to no album as well as cards that belong to multiple albums.

You'll probably only have one instance each of the AlbumManager and CardManager classes, but the design also anticipates that you might want to expand to handle multiple users, each one of whom will have their own card and album collections, so you'd need a card and album manager for each of them.

The AlbumManager and CardManager classes are the GUI-independent classes that are used by the AlbumCardsModel. This model is the interface to the views; when either the CardManager or AlbumManager make changes to their content, they emit signals that the model listens for so it can in turn update the views. You might have several instances of AlbumCardsModel - one for interfacing to one or more views of different albums.

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Thanks Stanz for your feedback and for the clarifications, I really appreciate it.

I have been working with this project all day so I will need to take a break rest my eyes and shoulders a bit. I have come quite a bit now with the classes. There are a few errors left and I am sure that there is unnecessary, repeated or misplaced code too. I will read through it all again tomorrow and try to learn the proper implementations and correct the code.

For now, here is the code I've written so far in case you want to have a look at it. I don't expect any of you to go through it and make corrections, you have done more than enough. But if you want to point out something that I have misunderstood I would gladly have a look at it again.

Code:

// AbstractCardModel.h
#include "cardsmanager.h"
#include "card.h"
 
class AbstractCardModel : public QAbstractListModel
{
    Q_OBJECT
public:
    enum AlbumRoles { CardIDRole = Qt::UserRole + 1, NameRole, ImageURLRole, SubtypeRole, SupertypeRole, NumberRole, ArtistRole, RarityRole, SeriesRole, SetRole,  SetCodeRole, ConditionRole, StatusRole};
    explicit AbstractCardModel(CardsManager *cardsManager, QObject *parent = 0);
 
    // this uses cardForIndex to get the card, then uses role to return the actual data
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
 
protected:
    QHash<int, QByteArray> roleNames() const;
    virtual Card cardForIndex(const QModelIndex &index) const = 0;
 
protected:
    CardsManager *m_cardsManager;
};
 
#endif //ABSTRACTCARDMODEL_H

Code:

// AbstractCardModel.cpp
#include "abstractcardmodel.h"
 
AbstractCardModel::AbstractCardModel(CardsManager *cardsManager, QObject *parent)/*: QObject(parent)*/
{
    this->m_cardsManager = cardsManager;
}
 
QVariant AbstractCardModel::data(const QModelIndex &index, int role) const
{
//    if (index.row() < 0 || index.row() >= this->m_cards.count())
//        return QVariant();
 
    const Card &card = cardForIndex(index);
    if (role == CardIDRole)
        return card.getCardID();
    else if (role == NameRole)
        return card.getName();
    else if (role == ImageURLRole)
        return card.getImageURL();
    else if (role == SubtypeRole)
        return card.getSubtype();
    else if (role == SupertypeRole)
        return card.getSupertype();
    else if (role == NumberRole)
        return card.getNumber();
    else if (role == ArtistRole)
        return card.getArtist();
    else if (role == RarityRole)
        return card.getRarity();
    else if (role == SeriesRole)
        return card.getSeries();
    else if (role == SetRole)
        return card.getSet();
    else if (role == SetCodeRole)
        return card.getSetCode();
    else if (role == ConditionRole)
        return card.getCondition();
    else if (role == StatusRole)
        return card.getStatus();
    return QVariant();
}

Code:

// Album.h
class Album
{
private:
    QList<Card> cards;
    QString albumId;
    QString albumName;
    int nrOfCards;
 
protected:
    QHash<QString, int> nameToId() const;
 
public:
    // Default Constructor
    Album(/*QObject *parent = 0*/);
 
    // Overloaded Constructor
    Album(QString newAlbumName);
 
    // Copy Constructor
    Album(const Album& source);
 
    // Assignment Opperator
    Album& operator=(const Album& source);
 
    // ALBUM GETTERS
    QString getAlbumName() const;
    QString getAlbumId() const;
    int getNrOfCards() const;
 
    // ALBUM SETTERS
    void setAlbumName(const QString newAlbumName);
    void setAlbumId(const QString newAlbumId);
    void setNrOfCards(const int newNrOfCards);
 
    // CARDS IN ALBUM
    void addCard(const Card& source);
    void addCardById(const QString &id);
    void addCardByName(const QString &newName);
 
    void removeCard(const int index);
    Card/*&*/ getCard(const int index);
 
    // Destructor
    ~Album();
};

Code:

// Album.cpp
#include "album.h"
 
// Default Constructor
Album::Album(/*QObject *parent*/)/*:QAbstractListModel(parent)*/
{
    this->albumName = "Default Album Name";
    this->albumId = "DefaultAlbumID";
    this->nrOfCards = 0;
}
 
// Overloaded Constructor
Album::Album(QString newAlbumName)
{
    this->albumName = newAlbumName;
    this->albumId = "DefaultAlbumID";
    this->nrOfCards = 0;
}
 
// Copy Constructor
Album::Album(const Album& source)
{
    this->albumName = source.albumName;
    this->albumId = source.albumId;
    this->nrOfCards = source.nrOfCards;
    for(int i = 0; i < source.nrOfCards; i++)
    {
        this->addCard(Card(source.cards[i]));
    }
}
 
// Assignment Opperator
Album& Album::operator =(const Album& source)
{
    if(this != &source)
    {
        this->albumName = source.albumName;
        this->albumId = source.albumId;
        this->nrOfCards = source.nrOfCards;
        for(int i = 0; i < source.nrOfCards; i++)
        {
            this->addCard(Card(source.cards[i]));
        }
    }
    return *this;
}
 
// ALBUM GETTERS
QString Album::getAlbumName() const
{
    return albumName;
}
 
QString Album::getAlbumId() const
{
    return albumId;
}
 
int Album::getNrOfCards() const
{
    return cards.count();
}
 
// ALBUM SETTERS
void Album::setAlbumName(const QString newAlbumName)
{
    this->albumName = newAlbumName;
}
 
void Album::setAlbumId(const QString newAlbumId)
{
    this->albumId = newAlbumId;
}
 
void Album::setNrOfCards(const int newNrOfCards)
{
    this->nrOfCards = newNrOfCards;
}
 
 
// CARDS IN ALBUM
void Album::addCard(const Card& source)
{
    cards.append(source);
    this->nrOfCards = cards.count();
}
 
void Album::removeCard(const int index)
{
    cards.removeAt(index);
    this->nrOfCards = cards.count();
}
 
void Album::addCardById(const QString &id)
{
    // Card info
    int number;
    QString nrString;
    QString name;
    QString cardId;
    QString subtype;
    QString supertype;
    QString artist;
    QString rarity;
    QString series;
    QString set;
    QString setCode;
    QString imageUrl;
    QString status;
    QString condition;
 
    // Build file name
    QString fileName = ":/cards/Resources/JSON/xy7-";
    fileName.append(id);
    fileName.append(".json");
 
    // Open file
    QFile file(fileName);
    if(!file.open(QFile::ReadOnly | QFile::Text))
    {
        qDebug() << "Error: Could not open file for reading";
    }
 
    // Save file information in fileText
    QTextStream in(&file);
    QString fileText = in.readAll();
 
    // Close file
    file.close();
 
    // Create card jsonObject from fileText
    QJsonDocument jsonDocument = QJsonDocument::fromJson(fileText.toUtf8());
    QJsonObject rootObject = jsonDocument.object();
    QJsonValue value = rootObject.value(QString("card"));
    QJsonObject cardRootValues = value.toObject();
 
    // Set values for card variables
    name = cardRootValues.value("name").toString();
    cardId = cardRootValues.value("id").toString();
    subtype = cardRootValues.value("subtype").toString();
    supertype = cardRootValues.value("supertype").toString();
    nrString = cardRootValues.value("number").toString();
    number = nrString.toInt();
    artist = cardRootValues.value("artist").toString();
    rarity = cardRootValues.value("rarity").toString();
    series = cardRootValues.value("series").toString();
    set = cardRootValues.value("set").toString();
    setCode = cardRootValues.value("setCode").toString();
    imageUrl = cardRootValues.value("imageURL").toString();
 
    this->addCard(Card(cardId, name, imageUrl, subtype, supertype, number, artist, rarity, series, set, setCode, condition, status));
}
 
void Album::addCardByName(const QString &newName)
{
    // Card info
    QString status;
    QString condition;
 
    // Build file name
    QString fileName = ":/cards/Resources/JSON/xy7-";
    QString id = nameToId().value(newName);
    fileName.append(id);
    fileName.append(".json");
 
    // Open file
    QFile file(fileName);
    if(!file.open(QFile::ReadOnly | QFile::Text))
    {
        qDebug() << "Error: Could not open file for reading";
        return;
    }
 
    // Save file information in fileText
    QTextStream in(&file);
    QString fileText = in.readAll();
 
    // Close file
    file.close();
 
    // Create card jsonObject from fileText
    QJsonDocument jsonDocument = QJsonDocument::fromJson(fileText.toUtf8());
    QJsonObject rootObject = jsonDocument.object();
    QJsonValue value = rootObject.value(QString("card"));
    QJsonObject cardRootValues = value.toObject();
 
    // Set values for card variables
    QString name = cardRootValues.value("name").toString();
    QString cardId = cardRootValues.value("id").toString();
    QString subtype = cardRootValues.value("subtype").toString();
    QString supertype = cardRootValues.value("supertype").toString();
    QString nrString = cardRootValues.value("number").toString();
    int number = nrString.toInt();
    QString artist = cardRootValues.value("artist").toString();
    QString rarity = cardRootValues.value("rarity").toString();
    QString series = cardRootValues.value("series").toString();
    QString set = cardRootValues.value("set").toString();
    QString setCode = cardRootValues.value("setCode").toString();
    QString imageUrl = cardRootValues.value("imageURL").toString();
 
    // Create Card instance from variables
    this->addCard(Card(cardId, name, imageUrl, subtype, supertype, number, artist, rarity, series, set, setCode, condition, status));
}
 
 
Card/*&*/ Album::getCard(const int index)
{
    return this->cards[index];
}
 
QHash<QString, int> Album::nameToId() const {
    QHash<QString, int> name;
    name["Oddish"] = 1;
    name["Gloom"] = 2;
    name["Vileplume"] = 3;
    name["Bellossom"] = 4;
    name["Spinarak"] = 5;
    name["Ariados"] = 6;
    name["Sceptile-EX"] = 7;
    name["M Sceptile-EX"] = 8;
    name["Combee"] = 9;
    name["Vespiquen"] = 10;
    name["Vespiquen"] = 11;
    name["Virizion"] = 12;
    name["Flareon"] = 13;
    name["Entei"] = 14;
    name["Entei"] = 15;
    name["Larvesta"] = 16;
    name["Volcarona"] = 17;
    name["Volcarona"] = 18;
    name["Magikarp"] = 19;
    name["Gyarados"] = 20;
    name["Gyarados"] = 21;
    name["Vaporeon"] = 22;
    name["Relicanth"] = 23;
    name["Regice"] = 24;
    name["Kyurem-EX"] = 25;
    name["Jolteon"] = 26;
    name["Ampharos-EX"] = 27;
    name["M Ampharos-EX"] = 28;
    name["Rotom"] = 29;
    name["Unown"] = 30;
    name["Baltoy"] = 31;
    name["Baltoy"] = 32;
    name["Claydol"] = 33;
    name["Golett"] = 34;
    name["Golurk"] = 35;
    name["Hoopa-EX"] = 36;
    name["Machamp-EX"] = 37;
    name["Wooper"] = 38;
    name["Quagsire"] = 39;
    name["Regirock"] = 40;
    name["Golurk"] = 41;
    name["Tyranitar-EX"] = 42;
    name["M Tyranitar-EX"] = 43;
    name["Sableye"] = 44;
    name["Inkay"] = 45;
    name["Malamar"] = 46;
    name["Beldum"] = 47;
    name["Metang"] = 48;
    name["Metagross"] = 49;
    name["Metagross"] = 50;
    name["Registeel"] = 51;
    name["Ralts"] = 52;
    name["Kirlia"] = 53;
    name["Gardevoir"] = 54;
    name["Cottonee"] = 55;
    name["Whimsicott"] = 56;
    name["Giratina-EX"] = 57;
    name["Goomy"] = 58;
    name["Sliggoo"] = 59;
    name["Goodra"] = 60;
    name["Meowth"] = 61;
    name["Persian"] = 62;
    name["Eevee"] = 63;
    name["Porygon"] = 64;
    name["Porygon2"] = 65;
    name["Porygon-Z"] = 66;
    name["Porygon-Z"] = 67;
    name["Lugia-EX"] = 68;
    name["Ace Trainer"] = 69;
    name["Ampharos Spirit Link"] = 70;
    name["Eco Arm"] = 71;
    name["Energy Recycler"] = 72;
    name["Faded Town"] = 73;
    name["Forest of Giant Plants"] = 74;
    name["Hex Maniac"] = 75;
    name["Level Ball"] = 76;
    name["Lucky Helmet"] = 77;
    name["Lysandre"] = 78;
    name["Paint Roller"] = 79;
    name["Sceptile Spirit Link"] = 80;
    name["Tyranitar Spirit Link"] = 81;
    name["Dangerous Energy"] = 82;
    name["Flash Energy"] = 83;
    name["Sceptile-EX"] = 84;
    name["M Sceptile-EX"] = 85;
    name["Kyurem-EX"] = 86;
    name["Ampharos-EX"] = 87;
    name["M Ampharos-EX"] = 88;
    name["Hoopa-EX"] = 89;
    name["Machamp-EX"] = 90;
    name["Tyranitar-EX"] = 91;
    name["M Tyranitar-EX"] = 92;
    name["Giratina-EX"] = 93;
    name["Lugia-EX"] = 94;
    name["Steven"] = 95;
    name["Primal Kyogre-EX"] = 96;
    name["Primal Groudon-EX"] = 97;
    name["M Rayquaza-EX"] = 98;
    name["Energy Retrieval"] = 99;
    name["Trainers' Mail"] = 100;
    return name;
}
 
 
// Destructor
Album::~Album()
{
 
}

Code:

// AlbumCardsModel.h
class AlbumCardsModel : public AbstractCardModel
{
    Q_OBJECT
public:
    enum AlbumRoles { AlbumNameRole = Qt::UserRole + 1};
    AlbumCardsModel(AlbumsManager *newAlbumsManager, CardsManager *newCardsManager, QObject *parent = 0);
    void showAlbum(const QString &albumId);
    int rowCount(const QModelIndex &parent) const;
 
protected:
    Card cardForIndex(const QModelIndex &index) const;
 
private slots:
    // gets connected to m_albumManager's albumRemoved() signal
    void onAlbumRemoved(const QString &albumId);
    void onCardAdded(const QString &albumId, const QString cardId);
    void onCardRemoved(const QString &albumId, const QString cardId);
 
private:
    AlbumsManager *m_albumsManager;
    Album m_album;
};

Code:

// AlbumCardsModel.cpp
#include "albumcardsmodel.h"
 
AlbumCardsModel::AlbumCardsModel(AlbumsManager *newAlbumsManager, CardsManager *newCardsManager, QObject *parent)/*: QObject(parent)*/
{
    this->m_albumsManager = newAlbumsManager;
    this->m_cardsManager = newCardsManager;
}
 
 
void AlbumCardsModel::showAlbum(const QString &albumId)
{
    beginResetModel();
    m_album = m_albumsManager->album(albumId);
    endResetModel();
}
 
int AlbumCardsModel::rowCount(const QModelIndex&) const
{
    return m_album.getNrOfCards();
}
 
Card AlbumCardsModel::cardForIndex(const QModelIndex &index) const
{
    return m_cardManager->card(m_album.cardIDs.at(index.row()));
}
 
void AlbumCardsModel::onAlbumRemoved(const QString &albumId)
{
    if (albumId != m_album.getAlbumId()) return;
 
    beginResetModel();
    m_album = Album();
    endResetModel();
}
 
void AlbumCardsModel::onCardAdded(const QString &albumId, const QString &cardId)
{
//    if (albumId != m_album.getAlbumId()) return;
 
//    const Album updatedAlbum = m_albumManager->album(albumId);
//    const int row = updatedAlbum.cardIDs.indexOf(cardId);
 
//    beginInsertRows(QModelIndex(), row, row);
 
//    this->m_album = updatedAlbum;
 
//    endInsertRows();
}
 
void AlbumCardsModel::onCardRemoved(const QString &albumId, const QString &cardId)
{
//    if (albumId != m_album.getAlbumId()) return;
 
//    const Album updatedAlbum = m_albumManager->album(albumId);
//    const int row = m_album.cardIDs.indexOf(cardId);
 
//    beginRemoveRows(QModelIndex(), row, row);
 
//    m_album = updatedAlbum;
 
//    endRemoveRows();
}

Code:

// AlbumsManager.h
 
class Card;
class AlbumsManager : public QObject
{
    Q_OBJECT
public:
    // Default Constructor
    AlbumsManager(QObject* parent = 0);
 
    Album createAlbum(const QString &name);
 
    Album album(const QString &id) const;
    QList<Album> albums() const;
 
    int count() const;
 
    void addAlbum(const Album& source);
    void removeAlbum(const int index);
 
    void addCard(const QString &albumId, const QString &cardId);
    void removeCard(const QString &albumId, const QString &cardId);
 
signals:
    void albumAdded(const QString &id);
    void albumRemoved(const QString &id);
 
    void cardAdded(const QString &albumId, const QStringList &cardIDs);
    void cardRemoved(const QString &albumId, const QStringList &cardIDs);
 
private:
    QList<Album> m_albums;
};

Code:

// AlbumsManager.cpp
#include "albumsmanager.h"
 
AlbumsManager::AlbumsManager(QObject *parent): QObject(parent)
{
 
}
 
 
Album AlbumsManager::createAlbum(const QString &name)
{
    Album* alb = new Album(name);
    return *alb;
}
 
// CARDS IN ALBUM
void AlbumsManager::addAlbum(const Album& source)
{
    m_albums.append(source);
}
 
void AlbumsManager::removeAlbum(const int index)
{
    m_albums.removeAt(index);
}
 
Album AlbumsManager::album(const QString &id) const
{
    bool albumFound = false;
    int albumMatch;
    for(int i = 0; i < this->count(); i++)
    {
        if(m_albums[i].getAlbumId() == id)
        {
            albumFound = true;
            albumMatch = i;
        }
    }
 
    if(albumFound == true)
    {
        return this->m_albums[albumMatch];
    }
    else
    {
        return Album();
    }
}
 
 
QList<Album> AlbumsManager::albums() const
{
    return this->m_albums;
}
 
 
int AlbumsManager::count() const
{
    return this->m_albums.count();
}
 
 
void AlbumsManager::addCard(const QString &albumId, const QString &cardId)
{
    bool albumFound = false;
    int albumMatch;
    for(int i = 0; i < this->count(); i++)
    {
        if(m_albums[i].getAlbumId() == albumId)
        {
            albumFound = true;
            albumMatch = i;
        }
    }
 
    if(albumFound == true)
    {
        this->m_albums[albumMatch].addCardById(cardId);
    }
}
 
void AlbumsManager::removeCard(const QString &albumId, const QString &cardId)
{
 
}

Code:

// App.h
class App
{
    Q_OBJECT
 
public:
    // Roles
    enum AlbumRoles { albumNameRole = Qt::UserRole + 1 };
 
    // Constructor
    explicit App(QObject *parent = 0);
 
    // Destructor
    ~App();
 
    // Append
    void addAlbum(const Album &album);
 
    // Position
    int rowCount(const QModelIndex & parent = QModelIndex()) const;
 
    // Data from child items
    QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
 
protected:
    // Role names
    QHash<int, QByteArray> roleNames() const;
 
private:
    // Children
    QList<Album> m_albums;
};

Code:

// App.cpp
#include "app.h"
 
App::App(QObject *parent)/*: QObject(parent)*/
{
 
}
 
// Append
void App::addAlbum(const Album &album)
{
    m_albums.append(album);
}
 
// Position
int App::rowCount(const QModelIndex & parent) const {
    Q_UNUSED(parent);
    return m_albums.count();
}
 
// Data
QVariant App::data(const QModelIndex & index, int role) const {
    if (index.row() < 0 || index.row() >= m_albums.count())
        return QVariant();
 
    const Album &album = m_albums[index.row()];
    if (role == albumNameRole)
        return album.getAlbumName();
    return QVariant();
}
 
QHash<int, QByteArray> App::roleNames() const {
    QHash<int, QByteArray> roles;
    roles[albumNameRole] = "name";
    return roles;
}

Code:

// Card.h
class Card
{
private:
    QString cardID;
    QString name;
    QString imageURL;
    QString subtype;
    QString supertype;
    int number;
    QString artist;
    QString rarity;
    QString series;
    QString set;
    QString setCode;
    QString condition;
    QString status;
 
public:
    // Default Constructor
    Card();
 
    // Overloaded Constructor
    Card(const QString &cardID, const QString &name, const QString &imageURL, const QString &subtype, const QString &supertype, const int &number, const QString &artist, const QString &rarity, const QString &series, const QString &set, const QString &setCode, const QString &condition, const QString &status);
 
    // Copy Constructor
    Card(const Card& source);
 
    // Assignment Opperator
    Card& operator=(const Card& source);
 
    // GETTERS
    QString getCardID() const;
    QString getName() const;
    QString getImageURL() const;
    QString getSubtype() const;
    QString getSupertype() const;
    int getNumber() const;
    QString getArtist() const;
    QString getRarity() const;
    QString getSeries() const;
    QString getSet() const;
    QString getSetCode() const;
    QString getCondition() const;
    QString getStatus() const;
 
 
    // SETTERS
    void setCardID(const QString newCardID);
    void setName(const QString newName);
    void setImageURL(const QString newImageURL);
    void setSubtype(const QString newSubtype);
    void setSupertype(const QString newSupertype);
    void setNumber(const int newNumber);
    void setArtist(const QString newArtist);
    void setRarity(const QString newRarity);
    void setSeries(const QString newSeries);
    void setSet(const QString newSet);
    void setSetCode(const QString newSetCode);
    void setCondition(const QString newCondition);
    void setStatus(const QString newStatus);
 
    // Destructor
    ~Card();
};

Code:

// Card.cpp
#include "card.h"
 
// Default Constructor
Card::Card()
{
    this->cardID = "Default Card ID";
    this->name = "Default Card Name";
    this->imageURL = "Default Card Image URL";
    this->subtype = "Default Card Subtype";
    this->supertype = "Default Card Supertype";
    this->number = 1;
    this->artist = "Default Card Artist";
    this->rarity = "Default Card Rarity";
    this->series = "Default Card Series";
    this->set = "Default Card Set";
    this->setCode = "Default Card Set Code";
    this->condition = "Default Card Condition";
    this->status = "Default Card Status";
}
 
// Overloaded Constructor
Card::Card(const QString &newCardID, const QString &newName, const QString &newImageURL, const QString &newSubtype, const QString &newSupertype, const int &newNumber, const QString &newArtist, const QString &newRarity, const QString &newSeries, const QString &newSet, const QString &newSetCode, const QString &newCondition, const QString &newStatus)
{
    this->cardID = newCardID;
    this->name = newName;
    this->imageURL = newImageURL;
    this->subtype = newSubtype;
    this->supertype = newSupertype;
    this->number = newNumber;
    this->artist = newArtist;
    this->rarity = newRarity;
    this->series = newSeries;
    this->set = newSet;
    this->setCode = newSetCode;
    this->condition = newCondition;
    this->status = newStatus;
}
 
// Copy Constructor
Card::Card(const Card& source)
{
    this->cardID = source.cardID;
    this->name = source.name;
    this->imageURL = source.imageURL;
    this->subtype = source.subtype;
    this->supertype = source.supertype;
    this->number = source.number;
    this->artist = source.artist;
    this->rarity = source.artist;
    this->series = source.series;
    this->set = source.set;
    this->setCode = source.setCode;
    this->condition = source.condition;
    this->status = source.status;
}
 
// Assignment Opperator
Card& Card::operator=(const Card& source)
{
    if(this != &source)
    {
        this->cardID = source.cardID;
        this->name = source.name;
        this->imageURL = source.imageURL;
        this->subtype = source.subtype;
        this->supertype = source.supertype;
        this->number = source.number;
        this->artist = source.artist;
        this->rarity = source.artist;
        this->series = source.series;
        this->set = source.set;
        this->setCode = source.setCode;
        this->condition = source.condition;
        this->status = source.status;
    }
    return *this;
}
 
// GETTERS
QString Card::getCardID() const
{
    return this->cardID;
}
 
QString Card::getName() const
{
    return this->name;
}
 
QString Card::getImageURL() const
{
    return this->imageURL;
}
 
QString Card::getSubtype() const
{
    return this->subtype;
}
 
QString Card::getSupertype() const
{
    return this->supertype;
}
 
int Card::getNumber() const
{
    return this->number;
}
 
QString Card::getArtist() const
{
    return this->artist;
}
 
QString Card::getRarity() const
{
    return this->rarity;
}
 
QString Card::getSeries() const
{
    return this->series;
}
 
QString Card::getSet() const
{
    return this->set;
}
 
QString Card::getSetCode() const
{
    return this->setCode;
}
 
QString Card::getCondition() const
{
    return this->condition;
}
 
QString Card::getStatus() const
{
    return this->status;
}
 
// SETTERS
void Card::setCardID(const QString newCardID)
{
    this->cardID = newCardID;
}
 
void Card::setName(const QString newName)
{
    this->name = newName;
}
 
void Card::setImageURL(const QString newImageURL)
{
    this->imageURL = newImageURL;
}
 
void Card::setSubtype(const QString newSubtype)
{
    this->subtype = newSubtype;
}
 
void Card::setSupertype(const QString newSupertype)
{
    this->supertype = newSupertype;
}
 
void Card::setNumber(const int newNumber)
{
    this->number = newNumber;
}
 
void Card::setArtist(const QString newArtist)
{
    this->artist = newArtist;
}
 
void Card::setRarity(const QString newRarity)
{
    this->rarity = newRarity;
}
 
void Card::setSeries(const QString newSeries)
{
    this->series = newSeries;
}
 
void Card::setSet(const QString newSet)
{
    this->set = newSet;
}
 
void Card::setSetCode(const QString newSetCode)
{
    this->setCode = newSetCode;
}
 
void Card::setCondition(const QString newCondition)
{
    this->condition = newCondition;
}
 
void Card::setStatus(const QString newStatus)
{
    this->status = newStatus;
}
 
// Destructor
Card::~Card()
{
 
}

Code:

// CardsManager.h
class CardsManager : public QObject
{
    Q_OBJECT
 
public:
    // returns an invalid card if ID is not found, e.g. Card object with empty "id"
    Card addCardById(const QString &id);
    Card addCardByName(const QString &newName);
 
    Card card(const QString &id) const;
    QList<Card> cards() const;
 
    int count() const;
 
signals:
    void cardAdded(const QString &id);
    void cardRemoved(const QString &id);
 
protected:
    QHash<QString, int> nameToId() const;
 
private:
    QList<Card> m_cards;
};

Code:

// CardsManager.cpp
#include "cardsmanager.h"
 
Card CardsManager::addCardById(const QString &id)
{
    // Card info
    int number;
    QString nrString;
    QString name;
    QString cardId;
    QString subtype;
    QString supertype;
    QString artist;
    QString rarity;
    QString series;
    QString set;
    QString setCode;
    QString imageUrl;
    QString status;
    QString condition;
 
    // Build file name
    QString fileName = ":/cards/Resources/JSON/xy7-";
    fileName.append(id);
    fileName.append(".json");
 
    // Open file
    QFile file(fileName);
    if(!file.open(QFile::ReadOnly | QFile::Text))
    {
        qDebug() << "Error: Could not open file for reading";
        return Card();
    }
 
    // Save file information in fileText
    QTextStream in(&file);
    QString fileText = in.readAll();
 
    // Close file
    file.close();
 
    // Create card jsonObject from fileText
    QJsonDocument jsonDocument = QJsonDocument::fromJson(fileText.toUtf8());
    QJsonObject rootObject = jsonDocument.object();
    QJsonValue value = rootObject.value(QString("card"));
    QJsonObject cardRootValues = value.toObject();
 
    // Set values for card variables
    name = cardRootValues.value("name").toString();
    cardId = cardRootValues.value("id").toString();
    subtype = cardRootValues.value("subtype").toString();
    supertype = cardRootValues.value("supertype").toString();
    nrString = cardRootValues.value("number").toString();
    number = nrString.toInt();
    artist = cardRootValues.value("artist").toString();
    rarity = cardRootValues.value("rarity").toString();
    series = cardRootValues.value("series").toString();
    set = cardRootValues.value("set").toString();
    setCode = cardRootValues.value("setCode").toString();
    imageUrl = cardRootValues.value("imageURL").toString();
 
    // Create Card instance from variables
    Card* crdPntr = nullptr;
    crdPntr = new Card(cardId, name, imageUrl, subtype, supertype, number, artist, rarity, series, set, setCode, condition, status);
 
    return *crdPntr;
}
 
Card CardsManager::addCardByName(const QString &newName)
{
    // Card info
    int number;
    QString nrString;
    QString name;
    QString cardId;
    QString subtype;
    QString supertype;
    QString artist;
    QString rarity;
    QString series;
    QString set;
    QString setCode;
    QString imageUrl;
    QString status;
    QString condition;
 
    // Build file name
    QString fileName = ":/cards/Resources/JSON/xy7-";
    QString id = nameToId().value(newName);
    fileName.append(id);
    fileName.append(".json");
 
    // Open file
    QFile file(fileName);
    if(!file.open(QFile::ReadOnly | QFile::Text))
    {
        qDebug() << "Error: Could not open file for reading";
        return Card();
    }
 
    // Save file information in fileText
    QTextStream in(&file);
    QString fileText = in.readAll();
 
    // Close file
    file.close();
 
    // Create card jsonObject from fileText
    QJsonDocument jsonDocument = QJsonDocument::fromJson(fileText.toUtf8());
    QJsonObject rootObject = jsonDocument.object();
    QJsonValue value = rootObject.value(QString("card"));
    QJsonObject cardRootValues = value.toObject();
 
    // Set values for card variables
    name = cardRootValues.value("name").toString();
    cardId = cardRootValues.value("id").toString();
    subtype = cardRootValues.value("subtype").toString();
    supertype = cardRootValues.value("supertype").toString();
    nrString = cardRootValues.value("number").toString();
    number = nrString.toInt();
    artist = cardRootValues.value("artist").toString();
    rarity = cardRootValues.value("rarity").toString();
    series = cardRootValues.value("series").toString();
    set = cardRootValues.value("set").toString();
    setCode = cardRootValues.value("setCode").toString();
    imageUrl = cardRootValues.value("imageURL").toString();
 
    // Create Card instance from variables
    Card* crdPntr = nullptr;
    crdPntr = new Card(cardId, name, imageUrl, subtype, supertype, number, artist, rarity, series, set, setCode, condition, status);
 
    return *crdPntr;
}
 
Card CardsManager::card(const QString &id) const
{
   return Card(id,"Gloom","http://s3.amazonaws.com/pokemontcg/xy7/2.png","Stage 1","PokÃ©mon",2,"Masakazu Fukuda","Uncommon","XY","Ancient Origins","xy7","Mint","In my collection");
 
}
 
QList<Card> CardsManager::cards() const
{
    return m_cards;
}
 
int CardsManager::count() const
{
    return this->m_cards.count();
}
 
QHash<QString, int> CardsManager::nameToId() const {
    QHash<QString, int> name;
    name["Oddish"] = 1;
    name["Gloom"] = 2;
    name["Vileplume"] = 3;
    name["Bellossom"] = 4;
    name["Spinarak"] = 5;
    name["Ariados"] = 6;
    name["Sceptile-EX"] = 7;
    name["M Sceptile-EX"] = 8;
    name["Combee"] = 9;
    name["Vespiquen"] = 10;
    name["Vespiquen"] = 11;
    name["Virizion"] = 12;
    name["Flareon"] = 13;
    name["Entei"] = 14;
    name["Entei"] = 15;
    name["Larvesta"] = 16;
    name["Volcarona"] = 17;
    name["Volcarona"] = 18;
    name["Magikarp"] = 19;
    name["Gyarados"] = 20;
    name["Gyarados"] = 21;
    name["Vaporeon"] = 22;
    name["Relicanth"] = 23;
    name["Regice"] = 24;
    name["Kyurem-EX"] = 25;
    name["Jolteon"] = 26;
    name["Ampharos-EX"] = 27;
    name["M Ampharos-EX"] = 28;
    name["Rotom"] = 29;
    name["Unown"] = 30;
    name["Baltoy"] = 31;
    name["Baltoy"] = 32;
    name["Claydol"] = 33;
    name["Golett"] = 34;
    name["Golurk"] = 35;
    name["Hoopa-EX"] = 36;
    name["Machamp-EX"] = 37;
    name["Wooper"] = 38;
    name["Quagsire"] = 39;
    name["Regirock"] = 40;
    name["Golurk"] = 41;
    name["Tyranitar-EX"] = 42;
    name["M Tyranitar-EX"] = 43;
    name["Sableye"] = 44;
    name["Inkay"] = 45;
    name["Malamar"] = 46;
    name["Beldum"] = 47;
    name["Metang"] = 48;
    name["Metagross"] = 49;
    name["Metagross"] = 50;
    name["Registeel"] = 51;
    name["Ralts"] = 52;
    name["Kirlia"] = 53;
    name["Gardevoir"] = 54;
    name["Cottonee"] = 55;
    name["Whimsicott"] = 56;
    name["Giratina-EX"] = 57;
    name["Goomy"] = 58;
    name["Sliggoo"] = 59;
    name["Goodra"] = 60;
    name["Meowth"] = 61;
    name["Persian"] = 62;
    name["Eevee"] = 63;
    name["Porygon"] = 64;
    name["Porygon2"] = 65;
    name["Porygon-Z"] = 66;
    name["Porygon-Z"] = 67;
    name["Lugia-EX"] = 68;
    name["Ace Trainer"] = 69;
    name["Ampharos Spirit Link"] = 70;
    name["Eco Arm"] = 71;
    name["Energy Recycler"] = 72;
    name["Faded Town"] = 73;
    name["Forest of Giant Plants"] = 74;
    name["Hex Maniac"] = 75;
    name["Level Ball"] = 76;
    name["Lucky Helmet"] = 77;
    name["Lysandre"] = 78;
    name["Paint Roller"] = 79;
    name["Sceptile Spirit Link"] = 80;
    name["Tyranitar Spirit Link"] = 81;
    name["Dangerous Energy"] = 82;
    name["Flash Energy"] = 83;
    name["Sceptile-EX"] = 84;
    name["M Sceptile-EX"] = 85;
    name["Kyurem-EX"] = 86;
    name["Ampharos-EX"] = 87;
    name["M Ampharos-EX"] = 88;
    name["Hoopa-EX"] = 89;
    name["Machamp-EX"] = 90;
    name["Tyranitar-EX"] = 91;
    name["M Tyranitar-EX"] = 92;
    name["Giratina-EX"] = 93;
    name["Lugia-EX"] = 94;
    name["Steven"] = 95;
    name["Primal Kyogre-EX"] = 96;
    name["Primal Groudon-EX"] = 97;
    name["M Rayquaza-EX"] = 98;
    name["Energy Retrieval"] = 99;
    name["Trainers' Mail"] = 100;
    return name;
}

Added after 7 minutes:

Maybe I shouldn't have dumped all that code. Either way, here is how the UI looks like for now:
https://streamable.com/1k11j

Thanks again for all the help!

Added after 5 minutes:

https://www.youtube.com/watch?v=OMYC2o7vr0M

31st December 2016, 01:51
d_stranz

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Looks nice. There are some refinements I'd make to the code, but otherwise it looks good and I don't see any obvious errors.

Edit - one error: Album:: operator=() needs to clear the existing list of cards before assigning the new list of cards. You can do this by simply writing "thisList = newList;" - you don't need to iterate over the incoming list of cards and add them one by one with a copy constructor. The list assignment operator will do all that. You've already assigned "nrOfCards" in the previous line, so going through addCard for each card you are copying is just extra work for nothing. Since you are always setting nrOfCards to card.count(), why even bother with this variable? It's something that could get out of sync if you forget to update it in some place where you change the card list. Just return card.count() whenever you need the number of cards.
31st December 2016, 01:53
Nizars

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Thank you Stanz! :)
31st December 2016, 08:38
anda_skoa

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML
Quote:

Originally Posted by Nizars

What is the role of a <class>Manager class? I am just trying to understand how it fits in.

One reason is to separate data from handling the data, i.e. the Card and Album class are only concerned about their data, not about anything else.

The main reason, however, is to provide the necessary change notification on operations that add/remove/change data.
This is the part from one of my earlier comments about "keeping the needs of the UI in mind". I.e. a model will need to be get notification somehow that cards have been added or albums have changed.

That requires an "active" object, e.g. something having signals and we don't want these in the data classes.
So adding a card to an Album needs to go through the AlbumManager, otherwise you could end up with an Album that has cards the model does not know about.

Quote:

Originally Posted by Nizars

Say I want to to add copy constractors and assignment opperators for the App, Album and Card classes, where would those be implemented? in their respective classes?

Yes

Quote:

Originally Posted by Nizars

What about the Setter and Getter class methods such as "QString getCardName() const;"? Same with the default and overloaded constructors? should I even have a default constructor in the original class?

Yes, in the data classes.
As d_stranz said, no need for copy constructor or assignment operator as the default implementation generated by the compiler will do nicely for such easy classes.

Definitely have a default constructor, e.g. for use cases like this
Code:

Card card; if (m_cardManager != 0) card = m_cardManager->card(someId); if (!card.isValid()) return;
Quote:

Originally Posted by Nizars

I have noticed that you combine each class and it's Manager class in the same document. Is there a reason or a benifit behind this practise? or is this simple down to preference and time saving?

Just as a hint on how they go together.
In a real project I would put each class declaration into a separate header.

Quote:

Originally Posted by Nizars

I have created three different classes for each of the "core" classes. An Album class, an AlbumsManager class and an AlbumModel class. I am totally open to changing it to the template you wrote if it makes a difference.

I think this is basically the setup I sketched, only with an additional helper class for Card models in case you want more than just "cards of one album".
E.g. a AllCardsModel could also simply derive from AbstractCardsModel and would only need to provide rowCount() and cardForIndex()

Cheers,
_

Added after 32 minutes:

Quote:

Originally Posted by Nizars

For now, here is the code I've written so far in case you want to have a look at it. I don't expect any of you to go through it and make corrections, you have done more than enough. But if you want to point out something that I have misunderstood I would gladly have a look at it again.

As d_stranz said, the "nrOfCards" in Album is questionable.
It can't mean the number of cards inside the Album because it can be set individually and the number of cards is always m_cards.count().
So what do you need it for?

One other problematic thing is that you are creating instances of objects on the heap and then discard the pointer, leaking memory.
E.g.
Code:

Card* crdPntr = nullptr; crdPntr = new Card(cardId, name, imageUrl, subtype, supertype, number, artist, rarity, series, set, setCode, condition, status); return *crdPntr;
The memory "crdPntr" points to won't be addressable after the return and will be lost until the program ends.
There is no need here to create the Card instance on the hea
Quote:
Originally Posted by Nizars

Code:

AbstractCardModel::AbstractCardModel(CardsManager *cardsManager, QObject *parent)/*: QObject(parent)*/
Pass the parent to the QAbstractListModel constructor
Quote:
Originally Posted by Nizars

Code:

QVariant AbstractCardModel::data(const QModelIndex &index, int role) const { // if (index.row() < 0 || index.row() >= this->m_cards.count()) // return QVariant(); const Card &card = cardForIndex(index); if (role == CardIDRole) return card.getCardID(); else if (role == NameRole)
This would be more efficient with a "switch(role)"
Quote:
Originally Posted by Nizars

Code:

// Album.h class Album { private: QList<Card> cards;
This is ok in your case because your Cards never change their content. If Cards would be changable your Album could easily end up with old copied of the Cards.
Which is why I used just the list of IDs, so the cards would have to be fetched from the CardsManager when needed which should always have the latest version.

But again, ok in your case since your cards never change.
Quote:
Originally Posted by Nizars

Code:

QHash<QString, int> nameToId() const;
That seems to map card names to ids, so it is definitely in the wrong class.
Album doesn't need to know that.
Quote:
Originally Posted by Nizars

Code:

// CARDS IN ALBUM void addCard(const Card& source); void addCardById(const QString &id); void addCardByName(const QString &newName);
The last two are not in the correct class, they would create Card objects without the CardManager knowing about them.
Quote:
Originally Posted by Nizars

Code:

Album::Album(/*QObject *parent*/)/*:QAbstractListModel(parent)*/ { this->albumName = "Default Album Name"; this->albumId = "DefaultAlbumID";
A default constructed Album should be invalid so that methods returning Album can indicate they haven't found the one they were asked for.
Most easiest way to do that is to have all fields empty, especially the ID.
Quote:
Originally Posted by Nizars

Code:

// Overloaded Constructor Album::Album(QString newAlbumName) { this->albumName = newAlbumName; this->albumId = "DefaultAlbumID";
That allows you to create two albums with different names and the same ID.
IDs are usually unique, otherwise they become useless for lookup.
Quote:
Originally Posted by Nizars

Code:

// AlbumCardsModel.cpp #include "albumcardsmodel.h" AlbumCardsModel::AlbumCardsModel(AlbumsManager *newAlbumsManager, CardsManager *newCardsManager, QObject *parent)/*: QObject(parent)*/ { this->m_albumsManager = newAlbumsManager; this->m_cardsManager = newCardsManager; }
This also needs to connect to the manager signals
Quote:
Originally Posted by Nizars

Code:

void addCard(const QString &albumId, const QString &cardId); void removeCard(const QString &albumId, const QString &cardId);
Since you have Card objects in your Album you need to pass "Card" here as the second argument or pass a CardManager to the AlbumManager.
Otherwise you will end up creating cards that the card manager knows nothing about.

Cheers,
_
31st December 2016, 11:16
Nizars

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

I wish I can thank the both of you enough. I really appreciate all the help I have gotten from you. It really means a lot to me. I will go through everything again today but hopefully won't get glued to the screen all day today too, the gf will definitely not like that.

Once again, I wish I can thank the both of you enough. Happy new year guys! :)
31st December 2016, 13:29
Nizars

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML
The only error that I can see right now is from:
Code:

class AlbumCardsModel : public AbstractCardModel { Q_OBJECT public: //.. AlbumCardsModel(AlbumsManager *newAlbumsManager, CardsManager *newCardsManager, QObject *parent = 0); //.. private: AlbumsManager *m_albumsManager; Album m_album; };
Code:

AlbumCardsModel::AlbumCardsModel(AlbumsManager *newAlbumsManager, CardsManager *newCardsManager, QObject *parent) { this->m_albumsManager = newAlbumsManager; this->m_cardsManager = newCardsManager; }
Code:

albumcardsmodel.cpp:4: error: C2512: 'AbstractCardModel': no appropriate default constructor available
I am not really sure how to implement this constructor. If i pass :QObject(parent) it tells me that it is not a member or a base class. I am not sure whether I should pass the other two pointers somewhere else too.
Same thing with your comment about connecting the signals. Not sure how to go about it but I will go through the wikis and documentations for those classes and try to understand the mechanisms at work here better.
I think After this I will just have to register the types in main and set a couple of them as root context properties. I will experiment with that until I figure out the proper configuartion to go with.
31st December 2016, 16:27
d_stranz

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML
In all of your constructors, you are ignoring the construction of the base class where there is one. So for example:
Code:

// This: AbstractCardModel::AbstractCardModel(CardsManager *cardsManager, QObject *parent)/*: QObject(parent)*/ { this->m_cardsManager = cardsManager; } // should be this: AbstractCardModel::AbstractCardModel(CardsManager *cardsManager, QObject *parent) : QAbstractItemModel( parent ) { this->m_cardsManager = cardsManager; }
Quote:

albumcardsmodel.cpp:4: error: C2512: 'AbstractCardModel': no appropriate default constructor available

This problem is the source of this compile error. Because you are not calling the base class constructor, C++ is trying to construct a default one. It can't because the only constructor it can find for AbstractCardModel takes two arguments, a pointer to a CardsManager and a QObject pointer to the parent. So change the constructor to read:
Code:

AlbumCardsModel::AlbumCardsModel( AlbumsManager * albumsManager, CardsManager *cardsManager, QObject *parent) : AbstractCardModel( cardsManager, parent ) //...
At run-time (especially for the models) this could cause problems because your classes would be created with default base class implementations as well as parentless (because you are not telling your base class who the parent is, so Qt never links it up).

You should make sure that all of your constructors for QObject-derived classes (i.e. all of those that contain the Q_OBJECT macro) pass "parent" up to their base classes, and that all of those constructors have a "QObject * parent" argument, even if it defaults to "0".

Note that Qt does not allow copy constructors or assignment operators for QObject-based classes.
2nd January 2017, 12:26
Nizars

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Hi guys, I hope you had a good new year's.

I have learned a lot from the suggested methods and I am thankful for all your help.
The classes are now complete and I am now integrating them through main.cpp.

I have a few questions about this bit.
Which classes do I register using: QmlRegisterType?
I have registered the core classes App, Album & Card as well as AlbumsManager & CardsManager.
When it comes the Models I have registered AlbumCardsModel. I didn't register AbstractCardsModel because it is a pure virtual class.

I have also instaciated a CardsManager class, an AlbumsManager class and an AlbumCardsModel class which I provided pointers to the cardsManager and the albumsManager instances.
All three have also been set as context properties.

Through the QML side, I am able to create new Albums in albumsManager and add Cards to them but I am not able to get anything from AlbumCardsModel to show up. I believe that this is because of two things, the pointers I provided it's constructor in main.cpp gets deleted when the app starts or that I am unable to use it properly in the QML side. I get an error that the model: albumCardsModel in my ListView is undefined.
2nd January 2017, 14:32
anda_skoa

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Quote:

Originally Posted by Nizars

Which classes do I register using: QmlRegisterType?

Only those which you need to use as element types in QML.
In your case most likely none.

Quote:

Originally Posted by Nizars

I have also instaciated a CardsManager class, an AlbumsManager class and an AlbumCardsModel class which I provided pointers to the cardsManager and the albumsManager instances.
All three have also been set as context properties.

sounds good

Quote:

Originally Posted by Nizars

Through the QML side, I am able to create new Albums in albumsManager and add Cards to them but I am not able to get anything from AlbumCardsModel to show up. I believe that this is because of two things, the pointers I provided it's constructor in main.cpp gets deleted when the app starts or that I am unable to use it properly in the QML side. I get an error that the model: albumCardsModel in my ListView is undefined.

Hmm.
Things you creating in the main() function are usually not deleted until the program ends.

Did you do the setContextProperty() calls before loading the main QML file?
Have you checked the "id" argument (first argument) with the id you are using on the QML side?

Cheers,
_

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Thanks for your reply.
You are right about not needed the Card and Album classes defined since I wouldn't be directly using them in the Front-end.

I have been messing around with different configurations to diagnose the methods and understand what is going on when I instanciate objects. I will post the updated code below.

AbstractCardsModel:

Code:

#ifndef ABSTRACTCARDMODEL_H
#define ABSTRACTCARDMODEL_H
#include <QString>
#include <QObject>
#include <QAbstractListModel>
#include "cardsmanager.h"
#include "card.h"
 
class AbstractCardModel : public QAbstractListModel
{
    Q_OBJECT
public:
    // Card roles
    enum AlbumRoles { CardIDRole = Qt::UserRole + 1, NameRole, ImageURLRole, SubtypeRole, SupertypeRole, NumberRole, ArtistRole, RarityRole, SeriesRole, SetRole,  SetCodeRole, ConditionRole, StatusRole};
 
    // Default Constructor
    AbstractCardModel(QObject* parent = 0);
 
    // Overloaded Constructor
    AbstractCardModel(CardsManager *cardsManager, QObject *parent = 0);
 
    // Copy Constructor
    AbstractCardModel(const AbstractCardModel& source);
 
    // Assignment Operator
    AbstractCardModel& operator=(const AbstractCardModel& source);
 
    // this uses cardForIndex to get the card, then uses role to return the actual data
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
 
    // Default Destructor
    ~AbstractCardModel();
 
protected:
    QHash<int, QByteArray> roleNames() const;
 
    virtual Card cardForIndex(const QModelIndex &index) const = 0;
 
protected:
    CardsManager *m_cardsManager;
};
 
#endif //ABSTRACTCARDMODEL_H

Code:

#include "abstractcardmodel.h"
 
// Default Constructor
AbstractCardModel::AbstractCardModel(QObject* parent): QAbstractListModel(parent)
{
    // For debugging purposes
    qDebug() << "[AbstractCardModel] [called] [Default constructor]";
    this->m_cardsManager = nullptr;
}
 
// Overloaded Constructor
AbstractCardModel::AbstractCardModel(CardsManager *cardsManager, QObject *parent): QAbstractListModel(parent)
{
    // For debugging purposes
    qDebug() << "[AbstractCardModel] [called] [Overloaded constructor]";
    this->m_cardsManager = cardsManager;
}
 
// Copy Constructor
AbstractCardModel::AbstractCardModel(const AbstractCardModel& source)
{
    qDebug() << "[AbstractCardModel] [called] [Copy Constructor]";
    this->m_cardsManager = source.m_cardsManager;
}
 
// Assignment Operator
AbstractCardModel& AbstractCardModel::operator=(const AbstractCardModel& source)
{
    qDebug() << "[AbstractCardModel] [called] [Assignment Operator]";
    if(this != &source)
    {
        this->m_cardsManager = source.m_cardsManager;
    }
    return *this;
}
 
QVariant AbstractCardModel::data(const QModelIndex &index, int role) const
{
    // For debugging purposes
    qDebug() << "[AbstractCardModel] [called] >> data(const QModelIndex &index, int role)";
    if (index.row() < 0 || index.row() >= this->m_cardsManager->count())
        return QVariant();
 
    const Card &card = cardForIndex(index);
    if (role == CardIDRole)
        return card.getCardID();
    else if (role == NameRole)
        return card.getName();
    else if (role == ImageURLRole)
        return card.getImageURL();
    else if (role == SubtypeRole)
        return card.getSubtype();
    else if (role == SupertypeRole)
        return card.getSupertype();
    else if (role == NumberRole)
        return card.getNumber();
    else if (role == ArtistRole)
        return card.getArtist();
    else if (role == RarityRole)
        return card.getRarity();
    else if (role == SeriesRole)
        return card.getSeries();
    else if (role == SetRole)
        return card.getSet();
    else if (role == SetCodeRole)
        return card.getSetCode();
    else if (role == ConditionRole)
        return card.getCondition();
    else if (role == StatusRole)
        return card.getStatus();
    return QVariant();
}
 
// Role names
QHash<int, QByteArray> AbstractCardModel::roleNames() const
{
    // For debugging purposes
    qDebug() << "[AbstractCardModel] [called] >> roleNames()";
    QHash<int, QByteArray> roles;
    roles[CardIDRole] = "cardID";
    roles[NameRole] = "name";
    roles[ImageURLRole] = "imageURL";
    roles[SubtypeRole] = "subtype";
    roles[SupertypeRole] = "supertype";
    roles[NumberRole] = "number";
    roles[ArtistRole] = "artist";
    roles[RarityRole] = "rarity";
    roles[SeriesRole] = "series";
    roles[SetRole] = "set";
    roles[SetCodeRole] = "setCode";
    roles[ConditionRole] = "condition";
    roles[StatusRole] = "status";
    return roles;
}
 
// Default Destructor
AbstractCardModel::~AbstractCardModel()
{
    // For debugging purposes
    qDebug() << "[AbstractCardModel] [called] [Default Destructor]";
}

Album:

Code:

#ifndef ALBUM_H
#define ALBUM_H
#include <QDebug>
#include <QObject>
#include <QString>
#include <QVariant>
#include <QList>
#include <QAbstractListModel>
#include <QQmlListProperty>
#include <QModelIndex>
#include "card.h"
 
class Album : public QObject
{
private:
    QStringList cardIDs; // Holds list of all the card IDs that are in the Album
    int albumId; // Holds a unique Album ID given to it from the AlbumsManager
    QString albumName; // Holds the user specified name for the Album
 
public:
    // Default Constructor
    Album(QObject* parent = 0);
 
    // Overloaded Constructor
    Album(QString newAlbumName, int albumId, QObject* parent = 0);
 
    // Copy Constructor
    Album(const Album& source);
 
    // Assignment Operator
    Album& operator=(const Album& source);
 
    // ALBUM GETTERS
    QString getAlbumName() const;
    int getAlbumId() const;
    int getNrOfCards() const;
 
    // ALBUM SETTERS
    void setAlbumName(const QString newAlbumName);
    void setAlbumId(const int newAlbumId);
 
    // CARDS IN ALBUM
    void addCard(const QString& cardID);
    void removeCard(const QString& cardID);
    QString getCardID(const int index);
    QStringList getCardIDs() const;
 
    // Destructor
    ~Album();
};
 
#endif // ALBUM_H

Code:

#include "album.h"
 
// Default Constructor
Album::Album(QObject* parent): QObject(parent)
{
    // For debugging purposes
    qDebug() << "[Album] [called] [albumId:" << albumId << "] [Default constructor]";
}
 
// Overloaded Constructor
Album::Album(QString newAlbumName, int albumId, QObject* parent): QObject(parent)
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] [Overloaded constructor] || newAlbumName: " << newAlbumName << ", albumId: " << albumId;
    this->albumName = newAlbumName;
    this->albumId = albumId;
}
 
// Copy Constructor
Album::Album(const Album& source)
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] [Copy constructor] || albumId: " << albumId;
    this->albumName = source.albumName;
    this->albumId = source.albumId;
    for(int i = 0; i < source.getNrOfCards(); i++)
    {
        this->addCard(source.cardIDs[i]);
    }
}
 
// Assignment Operator
Album& Album::operator =(const Album& source)
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] [Assignment opperator] || albumId: " << albumId;
    if(this != &source)
    {
        this->albumName = source.albumName;
        this->albumId = source.albumId;
        for(int i = 0; i < source.getNrOfCards(); i++)
        {
            this->addCard(source.cardIDs[i]);
        }
    }
    return *this;
}
 
// ALBUM GETTERS
QString Album::getAlbumName() const
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] >> getAlbumName() || returned: albumName: " << albumName;
    return albumName;
}
 
int Album::getAlbumId() const
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] >> getAlbumId() || returned: albumId: " << albumId;
    return albumId;
}
 
int Album::getNrOfCards() const
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] >> getNrOfCards() || returned count: " << cardIDs.count();
    return this->cardIDs.count();
}
 
// ALBUM SETTERS
void Album::setAlbumName(const QString newAlbumName)
{
    qDebug() << "[Album] [albumId:" << albumId << "] [called] >> setAlbumName(const QString newAlbumName) || newAlbumName: " << newAlbumName;
    this->albumName = newAlbumName;
}
 
void Album::setAlbumId(const int newAlbumId)
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] >> setAlbumId(const int newAlbumId) || newAlbumId: " << newAlbumId;
    this->albumId = newAlbumId;
}
 
 
// CARDS IN ALBUM
void Album::addCard(const QString& cardID)
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] >> addCard(const QString& cardID): cardID: " << cardID;
    this->cardIDs.append(cardID);
}
 
void Album::removeCard(const QString& cardID)
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] >> removeCard(const QString& cardID): cardID: " << cardID;
    for(int i = 0; i < this->cardIDs.count(); i++)
    {
        if(cardIDs[i] == cardID)
        {
            qDebug() << "[Album] [update] [albumId:" << albumId << "] >> removeCard(const QString& cardID) || Card match found at i: " << i;
            this->cardIDs.removeAt(i);
            return;
        }
    }
}
 
 
QString/*&*/ Album::getCardID(const int index)
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] >> getCardID(const int index) || index: " << index << ", Returning cardId: " << cardIDs[index];
    return this->cardIDs[index];
}
 
QStringList Album::getCardIDs() const
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] >> getCardIDs()";
    return this->cardIDs;
}
 
 
// Destructor
Album::~Album()
{
    qDebug() << "[Album] [called] [albumId:" << albumId << "] [Destructor]";
}

AlbumCardsModel:

Code:

#ifndef ALBUMCARDSMODEL_H
#define ALBUMCARDSMODEL_H
#include <QObject>
#include <QString>
#include <QVariant>
#include <QDebug>
#include <QList>
#include <QAbstractListModel>
#include <QQmlListProperty>
#include <QModelIndex>
#include "abstractcardmodel.h"
#include "albumsmanager.h"
 
 
class AlbumCardsModel : public AbstractCardModel
{
    Q_OBJECT
public:
    // Album name role
    enum AlbumRoles { AlbumNameRole = Qt::UserRole + 1};
 
    // Default Constructor
    AlbumCardsModel(QObject *parent = 0);
 
    AlbumCardsModel(AlbumsManager *albumsManager, CardsManager *cardsManager, QObject *parent = 0);
 
    // Show a specific Album
    Q_INVOKABLE void showAlbum(const int &albumId);
 
    // Get the
    int rowCount(const QModelIndex &parent) const;
 
protected:
    // Get the card object at the specified position in the Album
    Card cardForIndex(const QModelIndex &index) const;
 
private slots:
    // gets connected to m_albumManager's albumRemoved() signal
    void onAlbumRemoved(const int &albumId);
    void onCardAdded(const int &albumId, const QString &cardId);
    void onCardRemoved(const int &albumId, const QString &cardId);
 
private:
    AlbumsManager *m_albumsManager; // Points to the Album's AlbumsManager
    Album m_album; // Holds the Album it provides the View with
};
 
#endif // ALBUMCARDSMODEL_H

Code:

#include "albumcardsmodel.h"
AlbumCardsModel::AlbumCardsModel(QObject *parent)
    : AbstractCardModel(parent)
{
    qDebug() << "[AlbumCardsModel] [called] [Default Constructor]";
    this->m_albumsManager = nullptr;
    this->m_cardsManager = nullptr;
}
 
 
AlbumCardsModel::AlbumCardsModel( AlbumsManager* albumsManager, CardsManager* cardsManager, QObject *parent)
    : AbstractCardModel(cardsManager, parent)
{
    qDebug() << "[AlbumCardsModel] [called] [Overloaded Constructor]";
    this->m_albumsManager = albumsManager;
    this->m_cardsManager = cardsManager;
}
 
// Show a specific Album
void AlbumCardsModel::showAlbum(const int &albumId)
{
    qDebug() << "[AlbumCardsModel] [called] >> showAlbum(const int &albumId) || albumId: " << albumId;
    // Get the requested Album from AlbumsManager and set it as the current active one.
    beginResetModel();
    m_album = m_albumsManager->album(albumId);
    endResetModel();
}
 
// Get the number of Cards in the Active Album
int AlbumCardsModel::rowCount(const QModelIndex&) const
{
    qDebug() << "[AlbumCardsModel] [called] >> rowCount(const QModelIndex&)";
    return m_album.getCardIDs().count();
}
 
// Get the card object at the specified position in the Album
Card AlbumCardsModel::cardForIndex(const QModelIndex &index) const
{
    qDebug() << "[AlbumCardsModel] [called] >> cardForIndex(const QModelIndex &index)";
    return m_cardsManager->card(m_album.getCardIDs().at(index.row()));
}
 
// Receives a signal from the AlbumsManager when an Album is removed
void AlbumCardsModel::onAlbumRemoved(const int &albumId)
{
    qDebug() << "[AlbumCardsModel] [called] [from signal] >> onAlbumRemoved(const int &albumId) || albumId: " << albumId;
    // Do not proceed if the signaled Album change is not the active one
    if (albumId != m_album.getAlbumId()) return;
 
    qDebug() << "[AlbumCardsModel] [update] >> onAlbumRemoved(const int &albumId) || albumId from signal matches current albumId.";
 
    // replace the Model's active Album with a Default Album
    beginResetModel();
    m_album = Album();
    endResetModel();
    qDebug() << "[AlbumCardsModel] [update] >> onAlbumRemoved(const int &albumId) || Current album replaced with default constructed album.";
}
 
// Receives a signal from the AlbumsManager when a Card is added to an Album
void AlbumCardsModel::onCardAdded(const int &albumId, const QString &cardId)
{
    qDebug() << "[AlbumCardsModel] [called] [from signal] >> onCardAdded(const int &albumId, const QString &cardId) || albumId: " << albumId << ", cardId: " << cardId;
    // Do not proceed if the signaled Album change is not the active one
    if (albumId != m_album.getAlbumId()) return;
 
    qDebug() << "[AlbumCardsModel] [update] >> onCardAdded(const int &albumId, const QString &cardId) || albumId from signal matches current albumId";
 
    // Retreive the updated Album from the AlbumsManager
    const Album updatedAlbum = m_albumsManager->album(albumId);
    const int row = updatedAlbum.getCardIDs().indexOf(cardId);
 
    // replace the Model's active Album with the updated Album
    beginInsertRows(QModelIndex(), row, row);
    m_album = updatedAlbum;
    endInsertRows();
    qDebug() << "[AlbumCardsModel] [update] >> onCardAdded(const int &albumId, const QString &cardId) || current album updated";
}
 
// Receives a signal from the AlbumsManager when a Card is removed from an Album
void AlbumCardsModel::onCardRemoved(const int &albumId, const QString &cardId)
{
    qDebug() << "[AlbumCardsModel] [called] [from signal] >> onCardRemoved(const int &albumId, const QString &cardId) || albumId: " << albumId << ", cardId: " << cardId;
    // Do not proceed if the signaled Album change is not the active one
    if (albumId != m_album.getAlbumId()) return;
 
    qDebug() << "[AlbumCardsModel] [update] >> onCardRemoved(const int &albumId, const QString &cardId): albumId from signal matches current albumId";
 
    // Retreive the updated Album from the AlbumsManager
    const Album updatedAlbum = m_albumsManager->album(albumId);
    const int row = updatedAlbum.getCardIDs().indexOf(cardId);
 
    // replace the Model's active Album with the updated Album
    beginRemoveRows(QModelIndex(), row, row);
    m_album = updatedAlbum;
    endRemoveRows();
    qDebug() << "[AlbumCardsModel] [update] >> onCardRemoved(const int &albumId, const QString &cardId): current album updated";
}

AlbumsManager:

Code:

#ifndef ALBUMSMANAGER_H
#define ALBUMSMANAGER_H
#include "album.h"
#include "card.h"
#include <QObject>
#include <QString>
#include <QVariant>
#include <QList>
#include <QDebug>
#include <QAbstractListModel>
#include <QQmlListProperty>
#include <QModelIndex>
 
/* This class manages the Albums used by the program.
 * It contains all instances of Album objects and provides
 * signals to views when a change to any of them has been
 * made in order to refresh the views.
 * AlbumsManager enherits from QAbstractList model to better manage
 * the row insertion & removal in it's list of Albums. */
 
class AlbumsManager/* : public QAbstractListModel*/ : public QObject
{
    Q_OBJECT // Used to register Type
 
public:
    // Default Constructor
    AlbumsManager(QObject* parent = 0);
 
    // Copy Constructor
    AlbumsManager(const AlbumsManager& source);
 
    // Assignment Operator
    AlbumsManager& operator=(const AlbumsManager& source);
 
    // Retreives a specific Album from it's list
    Album album(const int &id) const;
 
    // Retreives all Albums in it's list
    QList<Album> albums() const;
 
    // Gets the nr. of Albums in it's list
    Q_INVOKABLE int count() const;
 
    // Creates a new Album and adds it to the list
    Q_INVOKABLE void createAlbum(const QString &name);
 
    // Add or remove specific Card to specified Album
    Q_INVOKABLE void addCard(const int &albumId, const QString &cardId);
    Q_INVOKABLE void removeCard(const int &albumId, const QString &cardId);
 
    // Default Destructor
    ~AlbumsManager();
 
signals:
    // Signals to notify Model classes on changes
    void albumAdded(const int &id);
    void albumRemoved(const int &id);
    void cardAdded(const int &albumId, const QStringList &cardIDs);
    void cardRemoved(const int &albumId, const QStringList &cardIDs);
 
private:
    int m_albumId; // Provides unique IDs for Album creation by incrementation
    QList<int> m_albumIDs; // Holds list of used Album IDs
    QList<Album> m_albums; // Holds instances of Album objects it manages
};
 
#endif // ALBUMSMANAGER_H

Code:

#include "albumsmanager.h"
 
// Default Constructor
AlbumsManager::AlbumsManager(QObject* parent): /*QAbstractListModel(parent)*/ QObject(parent)
{
    // Instanciate variable used for providing unique Album IDs
    this->m_albumId = 0;
 
    // For debugging purposes
    qDebug() << "[AlbumsManager] [called] [constructor] || m_albumId set to: " << m_albumId;
}
 
// Copy Constructor
AlbumsManager::AlbumsManager(const AlbumsManager& source)
{
    qDebug() << "[AlbumsManager] [called] [Copy Constructor]";
    this->m_albumId = source.m_albumId;
    this->m_albumIDs = source.m_albumIDs;
    this->m_albums = source.m_albums;
}
 
// Assignment Operator
AlbumsManager& AlbumsManager::operator=(const AlbumsManager& source)
{
    qDebug() << "[AlbumsManager] [called] [Assignment Operator]";
    if(this != &source)
    {
        this->m_albumId = source.m_albumId;
        this->m_albumIDs = source.m_albumIDs;
        this->m_albums = source.m_albums;
    }
    return *this;
}
 
 
// Retreives a specific Album from it's list
Album AlbumsManager::album(const int &id) const
{
    // For debugging purposes
    qDebug() << "[AlbumsManager] [called] >> album(const int &id) || id: " << id;
 
    // Find if an album in the list matches the provided Album ID
    int albumMatch;
    bool albumFound = false;
    for(int i = 0; i < this->count(); i++)
    {
        if(m_albums[i].getAlbumId() == id)
        {
            albumFound = true;
            albumMatch = i;
        }
    }
 
    // If a match has been found, return the matching Album
    if(albumFound == true)
    {
        // For debugging purposes
        qDebug() << "[AlbumsManager] [update] >> album(const int &id) || Match found: " << albumMatch;
        qDebug() << "[AlbumsManager] [update] >> album(const int &id) || Returning Album Object";
        return this->m_albums[albumMatch];
    }
 
    // If no match found, return a Default Album instance with no ID
    else
    {
        // For debugging purposes
        qDebug() << "[AlbumsManager] [update] >> album(const int &id) ||  No match found.";
        qDebug() << "[AlbumsManager] [update] >> album(const int &id) ||  Returning New Default Constructed Album() object";
        return Album();
    }
}
 
// Retreives an Album Objects list of all the Albums in it's list
QList<Album> AlbumsManager::albums() const
{
    // For debugging purposes
    qDebug() << "[AlbumsManager] [called] >> albums()";
 
    return this->m_albums;
}
 
// Gets the nr. of Albums in it's list
int AlbumsManager::count() const
{
    // For debugging purposes
    qDebug() << "[AlbumsManager] [called] >> count() || returned: " << m_albums.count();
 
    return this->m_albums.count();
}
 
// Create new Album and Add it to the Album list this class manages
void AlbumsManager::createAlbum(const QString &name)
{
    // For debugging purposes
    qDebug() << "[AlbumsManager] [called] >> createAlbum(const QString &name) || name: " + name;
 
    // Create new ID for the new album
    this->m_albumId++;
    this->m_albumIDs.append(m_albumId);
        qDebug() << "[AlbumsManager] [update] >> createAlbum(const QString &name) || Assigning albumId: " << m_albumId << " to newAlbum";
        qDebug() << "[AlbumsManager] [update] >> createAlbum(const QString &name) || calling Overloaded Album constructor, name: " << name << ", m_albumId: " << m_albumId;
 
    // Create album using new ID and user specified Album name
    Album newAlbum(name,m_albumId);
 
    // Add the new Album to the end of the Albums list
    m_albums << newAlbum;
    qDebug() << "[AlbumsManager] [update] >> createAlbum(const QString &name) || newAlbum appended to m_albums";
 
 
    // Send signal to notify views about the change
    albumAdded(m_albumId);
 
//    // return the new Album
//    return newAlbum;
}
 
// Add a specific Card to a specified Album
void AlbumsManager::addCard(const int &albumId, const QString &cardId)
{
    // For debugging purposes
    qDebug() << "[AlbumsManager] [called] >> addCard(const int &albumId, const QString &cardId) || albumId: " << albumId << ", cardId: " << cardId;
 
    // Find if an album in the list matches the provided Album ID
    bool albumFound = false;
    int albumMatch;
    for(int i = 0; i < this->count(); i++)
    {
        if(m_albums[i].getAlbumId() == albumId)
        {
            albumFound = true;
            albumMatch = i;
        }
    }
 
    // If a match has been found add specified card to it and send a signal to Models about the new change.
    if(albumFound == true)
    {
        qDebug() << "[AlbumsManager] [update] >> addCard(const int &albumId, const QString &cardId) || A matching Album was found.";
        this->m_albums[albumMatch].addCard(cardId);
        cardAdded(albumId, m_albums[albumMatch].getCardIDs());
    }
    else
    {
        qDebug() << "[AlbumsManager] [update] >> addCard(const int &albumId, const QString &cardId) || No matching Albums were found";
    }
}
 
// Remove a specific Card from a specified Album
void AlbumsManager::removeCard(const int &albumId, const QString &cardId)
{
    // For debugging purposes
    qDebug() << "[AlbumsManager] [called] >> removeCard(const int &albumId, const QString &cardId) || albumId: " << albumId << ", cardId: " << cardId;
 
    // Find if an album in the list matches the provided Album ID
    bool albumFound = false;
    int albumMatch;
    for(int i = 0; i < this->count(); i++)
    {
        if(m_albums[i].getAlbumId() == albumId)
        {
            albumFound = true;
            albumMatch = i;
        }
    }
 
    // If a match has been found remove specified card from it and send a signal to Models about the new change
    if(albumFound == true)
    {
        qDebug() << "[AlbumsManager] [update] >> removeCard(const int &albumId, const QString &cardId) || A matching Album was found";
        this->m_albums[albumMatch].removeCard(cardId);
        cardRemoved(albumId, m_albums[albumMatch].getCardIDs());
    }
    else
    {
        qDebug() << "[AlbumsManager] [update] >> removeCard(const int &albumId, const QString &cardId) || No matching Albums were found";
    }
}
 
// Default Destructor
AlbumsManager::~AlbumsManager()
{
    // For debugging purposes
    qDebug() << "[AlbumsManager] [called] [Destructor].";
}

App:

Code:

#ifndef APP_H
#define APP_H
#include <QObject>
#include <QDebug>
#include <QString>
#include <QVariant>
#include <QList>
#include "album.h"
#include "card.h"
#include "albumsmanager.h"
#include "cardsmanager.h"
#include "albumcardsmodel.h"
#include "abstractcardmodel.h"
class App: public QObject
{
    Q_OBJECT
 
public:
    // Constructor
    explicit App(QObject *parent = 0);
 
    // Roles
    enum AlbumRoles { albumNameRole = Qt::UserRole + 1 };
 
    // Getters
    AlbumsManager* getAlbumsManagerPointer();
    CardsManager* getCardsManagerPointer();
    AlbumCardsModel* getAlbumCardsModelPointer();
 
    // Append
    void addAlbum(const Album &album);
 
    // Position
    int rowCount(const QModelIndex & parent = QModelIndex()) const;
 
    // Data from child items
    QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
 
    // Destructor
    ~App();
 
protected:
    // Role names
    QHash<int, QByteArray> roleNames() const;
 
private:
    // Children
    QList<Album> m_albums;
 
    // New
    AlbumsManager m_albumsManager;
    CardsManager m_cardsManager;
    AlbumCardsModel m_albumCardsModel;
 
    AlbumsManager* m_albumsManagerPointer;
    CardsManager* m_cardsManagerPointer;
    AlbumCardsModel* m_albumCardsModelPointer;
 
};
 
#endif // APP_H

Code:

#include "app.h"
 
// Default Constructor
App::App(QObject *parent): QObject(parent)
{
    // For debugging purposes
    qDebug() << "[App] [called] [Default Constructor]";
    this->m_albumsManager = AlbumsManager();
    this->m_albumsManagerPointer = &m_albumsManager;
 
    this->m_cardsManager = CardsManager();
    this->m_cardsManagerPointer = &m_cardsManager;
 
    this->m_albumCardsModel = AlbumCardsModel(m_albumsManagerPointer, m_cardsManagerPointer);
    this->m_albumCardsModelPointer = &m_albumCardsModel;
}
 
// Getters
 
AlbumsManager* App::getAlbumsManagerPointer()
{
    return this->m_albumsManagerPointer;
}
 
CardsManager* App::getCardsManagerPointer()
{
    return this->m_cardsManagerPointer;
}
 
AlbumCardsModel* App::getAlbumCardsModelPointer()
{
    return this->m_albumCardsModelPointer;
}
 
// Append
void App::addAlbum(const Album &album)
{
    // For debugging purposes
    qDebug() << "[App] [called] >> addAlbum(const Album &album) || albumId: " << album.getAlbumId();
 
    m_albums.append(album);
}
 
// Position
int App::rowCount(const QModelIndex & parent) const
{
    // For debugging purposes
    qDebug() << "[App] [called] >> rowCount(const QModelIndex & parent) || Returning count: " << m_albums.count();
 
    Q_UNUSED(parent);
    return m_albums.count();
}
 
// Data
QVariant App::data(const QModelIndex & index, int role) const
{
    // For debugging purposes
    qDebug() << "[App] [called] >> data(const QModelIndex & index, int role)";
 
    if (index.row() < 0 || index.row() >= m_albums.count())
        return QVariant();
 
    const Album &album = m_albums[index.row()];
    if (role == albumNameRole)
        return album.getAlbumName();
    return QVariant();
}
 
QHash<int, QByteArray> App::roleNames() const
{
    // For debugging purposes
    qDebug() << "[App] [called] >> roleNames()";
 
    QHash<int, QByteArray> roles;
    roles[albumNameRole] = "albumName";
    return roles;
}
 
App::~App()
{
    // For debugging purposes
    qDebug() << "[App] [called] [Default Destructor]";
}

Card:

Code:

#ifndef CARD_H
#define CARD_H
#include <QString>
#include <QObject>
#include <QDebug>
 
class Card : public QObject
{
private:
    QString cardID;
    QString name;
    QString imageURL;
    QString subtype;
    QString supertype;
    int number;
    QString artist;
    QString rarity;
    QString series;
    QString set;
    QString setCode;
    QString condition;
    QString status;
 
public:
    // Default Constructor
    Card(QObject* parent = 0);
 
    // Overloaded Constructor
    Card(const QString &cardID, const QString &name, const QString &imageURL, const QString &subtype, const QString &supertype, const int &number, const QString &artist, const QString &rarity, const QString &series, const QString &set, const QString &setCode, const QString &condition, const QString &status, QObject* parent = 0);
 
    // Copy Constructor
    Card(const Card& source);
 
    // Assignment Opperator
    Card& operator=(const Card& source);
 
    // GETTERS
    QString getCardID() const;
    QString getName() const;
    QString getImageURL() const;
    QString getSubtype() const;
    QString getSupertype() const;
    int getNumber() const;
    QString getArtist() const;
    QString getRarity() const;
    QString getSeries() const;
    QString getSet() const;
    QString getSetCode() const;
    QString getCondition() const;
    QString getStatus() const;
 
 
    // SETTERS
    void setCardID(const QString newCardID);
    void setName(const QString newName);
    void setImageURL(const QString newImageURL);
    void setSubtype(const QString newSubtype);
    void setSupertype(const QString newSupertype);
    void setNumber(const int newNumber);
    void setArtist(const QString newArtist);
    void setRarity(const QString newRarity);
    void setSeries(const QString newSeries);
    void setSet(const QString newSet);
    void setSetCode(const QString newSetCode);
    void setCondition(const QString newCondition);
    void setStatus(const QString newStatus);
 
    // Destructor
    ~Card();
};
 
#endif // CARD_H

Code:

#include "card.h"
 
// Default Constructor
Card::Card(QObject* parent): QObject(parent)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [Default Constructor]";
}
 
// Overloaded Constructor
Card::Card(const QString &newCardID, const QString &newName, const QString &newImageURL, const QString &newSubtype, const QString &newSupertype, const int &newNumber, const QString &newArtist, const QString &newRarity, const QString &newSeries, const QString &newSet, const QString &newSetCode, const QString &newCondition, const QString &newStatus, QObject* parent): QObject(parent)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [Overloaded Constructor] || newCardID: " << newCardID << ", newName: " << newName << ", newImageURL: " << newImageURL << ", newSubtype: " << newSubtype << ", newSupertype: " << newSupertype << ", newNumber: " << newNumber << ", newArtist: " << newArtist << ", newRarity: " << newRarity << ", newSeries: " << newSeries << ", newSet: " << newSet << ", newSetCode: " << newSetCode << ", newCondition: " << newCondition << ", newStatus: " << newStatus;
 
    this->cardID = newCardID;
    this->name = newName;
    this->imageURL = newImageURL;
    this->subtype = newSubtype;
    this->supertype = newSupertype;
    this->number = newNumber;
    this->artist = newArtist;
    this->rarity = newRarity;
    this->series = newSeries;
    this->set = newSet;
    this->setCode = newSetCode;
    this->condition = newCondition;
    this->status = newStatus;
}
 
// Copy Constructor
Card::Card(const Card& source)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] [Copy Constructor]";
 
    this->cardID = source.cardID;
    this->name = source.name;
    this->imageURL = source.imageURL;
    this->subtype = source.subtype;
    this->supertype = source.supertype;
    this->number = source.number;
    this->artist = source.artist;
    this->rarity = source.rarity;
    this->series = source.series;
    this->set = source.set;
    this->setCode = source.setCode;
    this->condition = source.condition;
    this->status = source.status;
}
 
// Assignment Opperator
Card& Card::operator=(const Card& source)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] [Assignment opperator] || source.cardID: " << source.cardID << ", source.name: " << source.name << ", source.imageURL: " << source.imageURL << ", source.subtype: " << source.subtype << ", source.supertype: " << source.supertype << ", source.number: " << source.number << ", source.artist: " << source.artist << ", source.rarity: " << source.rarity << ", source.series: " << source.series << ", source.set: " << source.set << ", source.setCode: " << source.setCode << ", source.condition: " << source.condition << ", source.status: " << source.status;
 
    if(this != &source)
    {
        this->cardID = source.cardID;
        this->name = source.name;
        this->imageURL = source.imageURL;
        this->subtype = source.subtype;
        this->supertype = source.supertype;
        this->number = source.number;
        this->artist = source.artist;
        this->rarity = source.artist;
        this->series = source.series;
        this->set = source.set;
        this->setCode = source.setCode;
        this->condition = source.condition;
        this->status = source.status;
    }
    return *this;
}
 
// GETTERS
QString Card::getCardID() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getCardID() || cardID: " << cardID;
 
    return this->cardID;
}
 
QString Card::getName() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getName() || name: " << name;
 
    return this->name;
}
 
QString Card::getImageURL() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getImageURL() || imageURL: " << imageURL;
 
    return this->imageURL;
}
 
QString Card::getSubtype() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getSubtype() || subtype: " << subtype;
 
    return this->subtype;
}
 
QString Card::getSupertype() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getSupertype() || supertype: " << supertype;
 
    return this->supertype;
}
 
int Card::getNumber() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getNumber() || number: " << number;
 
    return this->number;
}
 
QString Card::getArtist() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getArtist() || artist: " << artist;
 
    return this->artist;
}
 
QString Card::getRarity() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getRarity() || rarity: " << rarity;
 
    return this->rarity;
}
 
QString Card::getSeries() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getSeries() || series: " << series;
 
    return this->series;
}
 
QString Card::getSet() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getSet() || set: " << set;
 
    return this->set;
}
 
QString Card::getSetCode() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getSetCode() || setCode: " << setCode;
 
    return this->setCode;
}
 
QString Card::getCondition() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getCondition() || condition: " << condition;
 
    return this->condition;
}
 
QString Card::getStatus() const
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> getStatus() || status: " << status;
 
    return this->status;
}
 
// SETTERS
void Card::setCardID(const QString newCardID)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setCardID(const QString newCardID) || newCardID: " << newCardID;
 
    this->cardID = newCardID;
}
 
void Card::setName(const QString newName)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setName(const QString newName) || newName: " << newName;
 
    this->name = newName;
}
 
void Card::setImageURL(const QString newImageURL)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setImageURL(const QString newImageURL) || newImageURL: " << newImageURL;
 
    this->imageURL = newImageURL;
}
 
void Card::setSubtype(const QString newSubtype)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setSubtype(const QString newSubtype) || newSubtype: " << newSubtype;
 
    this->subtype = newSubtype;
}
 
void Card::setSupertype(const QString newSupertype)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setSupertype(const QString newSupertype) || newSupertype: " << newSupertype;
 
    this->supertype = newSupertype;
}
 
void Card::setNumber(const int newNumber)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setNumber(const int newNumber) || newNumber: " << newNumber;
 
    this->number = newNumber;
}
 
void Card::setArtist(const QString newArtist)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setArtist(const QString newArtist) || newArtist: " << newArtist;
 
    this->artist = newArtist;
}
 
void Card::setRarity(const QString newRarity)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setRarity(const QString newRarity) || newRarity: " << newRarity;
 
    this->rarity = newRarity;
}
 
void Card::setSeries(const QString newSeries)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setSeries(const QString newSeries) || newSeries: " << newSeries;
 
    this->series = newSeries;
}
 
void Card::setSet(const QString newSet)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setSet(const QString newSet) || newSet: " << newSet;
 
    this->set = newSet;
}
 
void Card::setSetCode(const QString newSetCode)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setSetCode(const QString newSetCode) || setCode: " << setCode;
 
    this->setCode = newSetCode;
}
 
void Card::setCondition(const QString newCondition)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setCondition(const QString newCondition) || newCondition: " << newCondition;
 
    this->condition = newCondition;
}
 
void Card::setStatus(const QString newStatus)
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] >> setStatus(const QString newStatus) || newStatus: " << newStatus;
 
    this->status = newStatus;
}
 
// Destructor
Card::~Card()
{
    // For debugging purposes
    qDebug() << "[Card] [called] [cardID:" << cardID << "] [Destructor]";
}

CardsManager:

Code:

#ifndef CARDSMANAGER_H
#define CARDSMANAGER_H
#include <QObject>
#include <QString>
#include <QFile>
#include <QDebug>
#include <QTextStream>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QAbstractListModel>
#include "card.h"
 
class CardsManager /*: public QAbstractListModel*/ : public QObject
{
    Q_OBJECT
 
public:
    // Default Constructor
    CardsManager(QObject* parent = 0);
 
    // Copy Constructor
    CardsManager(const CardsManager& source);
 
    // Assignment Operator
    CardsManager& operator=(const CardsManager& source);
 
    // returns an invalid card if ID is not found, e.g. Card object with empty "id"
    Card addCardById(const QString &id);
    Card addCardByName(const QString &newName);
 
    Card card(const QString &id) const;
    QList<Card> cards() const;
 
    int count() const;
 
signals:
    void cardAdded(const QString &id);
    void cardRemoved(const QString &id);
 
protected:
    QHash<QString, int> nameToId() const;
 
private:
    QList<Card> m_cards;
};
 
#endif // CARDSMANAGER_H

Code:

#include "cardsmanager.h"
 
// Default Constructor
CardsManager::CardsManager(QObject* parent): QObject(parent)
{
    // For debugging purposes
    qDebug() << "[CardsManager] [called] [Default constructor]";
}
 
// Copy Constructor
CardsManager::CardsManager(const CardsManager& source)
{
    qDebug() << "[CardsManager] [called] [Copy Constructor]";
    this->m_cards = source.m_cards;
}
 
// Assignment Operator
CardsManager& CardsManager::operator=(const CardsManager& source)
{
    qDebug() << "[CardsManager] [called] [Assignment Operator]";
    if(this != &source)
    {
        this->m_cards = source.m_cards;
    }
    return *this;
}
 
Card CardsManager::addCardById(const QString &id)
{
    // For debugging purposes
    qDebug() << "[CardsManager] [called] >> addCardById(const QString &id) || id: " << id;
 
    // Card info
    int number;
    QString nrString;
    QString name;
    QString cardId;
    QString subtype;
    QString supertype;
    QString artist;
    QString rarity;
    QString series;
    QString set;
    QString setCode;
    QString imageUrl;
    QString status = "Not specified";
    QString condition = "Not specified";
 
    // Build file name
    QString fileName = ":/cards/Resources/JSON/xy7-";
    fileName.append(id);
    fileName.append(".json");
 
    // Open file
    QFile file(fileName);
    if(!file.open(QFile::ReadOnly | QFile::Text))
    {
        // For debugging purposes
        qDebug() << "[CardsManager] [update] >> addCardById(const QString &id) || Error: Could not open file for reading. fileName: " << fileName;
        // For debugging purposes
        qDebug() << "[CardsManager] [update] >> addCardById(const QString &id) || Returning Card()";
        return Card();
    }
 
    // Save file information in fileText
    QTextStream in(&file);
    QString fileText = in.readAll();
 
    // Close file
    file.close();
 
    // Create card jsonObject from fileText
    QJsonDocument jsonDocument = QJsonDocument::fromJson(fileText.toUtf8());
    QJsonObject rootObject = jsonDocument.object();
    QJsonValue value = rootObject.value(QString("card"));
    QJsonObject cardRootValues = value.toObject();
 
    // Set values for card variables
    name = cardRootValues.value("name").toString();
    cardId = cardRootValues.value("id").toString();
    subtype = cardRootValues.value("subtype").toString();
    supertype = cardRootValues.value("supertype").toString();
    nrString = cardRootValues.value("number").toString();
    number = nrString.toInt();
    artist = cardRootValues.value("artist").toString();
    rarity = cardRootValues.value("rarity").toString();
    series = cardRootValues.value("series").toString();
    set = cardRootValues.value("set").toString();
    setCode = cardRootValues.value("setCode").toString();
    imageUrl = cardRootValues.value("imageURL").toString();
 
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardById(const QString &id) || Calling Overloaded Card Constructor";
 
    // Create Card instance from variables
    Card newCard(cardId, name, imageUrl, subtype, supertype, number, artist, rarity, series, set, setCode, condition, status);
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardById(const QString &id) || newCard created. cardId: " << cardId << ", name: " << name << ", imageUrl: " << imageUrl << ", subtype: " << subtype << ", supertype: " << supertype << ", number: " << number << ", artist: " << artist << ", rarity: " << rarity << ", series: " << series << ", set: " << set << ", setCode: " << setCode << ", condition: " << condition << ", status: " << status;
 
 
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardById(const QString &id) || Adding card: " << cardId << " to m_cards.";
 
    // Add newly created Card to Card's list
    m_cards << newCard;
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardById(const QString &id) || Card: " << cardId << " added to m_cards.";
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardById(const QString &id) || Calling cardAdded signal for Card: " << cardId << ", returning the card object.";
 
    cardAdded(cardId);
    return newCard;
}

CardsManager.cpp continuation:

Code:

Card CardsManager::addCardByName(const QString &newName)
{
    // For debugging purposes
    qDebug() << "[CardsManager] [called] >> addCardByName(const QString &newName) || newName: " << newName;
 
    // Card info
    int number;
    QString nrString;
    QString name;
    QString cardId;
    QString subtype;
    QString supertype;
    QString artist;
    QString rarity;
    QString series;
    QString set;
    QString setCode;
    QString imageUrl;
    QString status;
    QString condition;
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || calling nameToId().value(newName)";
 
    // Build file name
    QString fileName = ":/cards/Resources/JSON/xy7-";
    QString id = nameToId().value(newName);
    fileName.append(id);
    fileName.append(".json");
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || nameToId().value(newName) returned id: " << id;
    qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || fileName built, fileName: " << fileName;
 
    // Open file
    QFile file(fileName);
    if(!file.open(QFile::ReadOnly | QFile::Text))
    {
        // For debugging purposes
        qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || Error: Could not open file for reading. fileName: " << fileName;
        // For debugging purposes
        qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || Returning Card()";
        return Card();
    }
 
    // Save file information in fileText
    QTextStream in(&file);
    QString fileText = in.readAll();
 
    // Close file
    file.close();
 
    // Create card jsonObject from fileText
    QJsonDocument jsonDocument = QJsonDocument::fromJson(fileText.toUtf8());
    QJsonObject rootObject = jsonDocument.object();
    QJsonValue value = rootObject.value(QString("card"));
    QJsonObject cardRootValues = value.toObject();
 
    // Set values for card variables
    name = cardRootValues.value("name").toString();
    cardId = cardRootValues.value("id").toString();
    subtype = cardRootValues.value("subtype").toString();
    supertype = cardRootValues.value("supertype").toString();
    nrString = cardRootValues.value("number").toString();
    number = nrString.toInt();
    artist = cardRootValues.value("artist").toString();
    rarity = cardRootValues.value("rarity").toString();
    series = cardRootValues.value("series").toString();
    set = cardRootValues.value("set").toString();
    setCode = cardRootValues.value("setCode").toString();
    imageUrl = cardRootValues.value("imageURL").toString();
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || Calling Overloaded Card Constructor";
 
    // Create Card instance from variables
    Card newCard(cardId, name, imageUrl, subtype, supertype, number, artist, rarity, series, set, setCode, condition, status);
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || newCard created. cardId: " << cardId << ", name: " << name << ", imageUrl: " << imageUrl << ", subtype: " << subtype << ", supertype: " << supertype << ", number: " << number << ", artist: " << artist << ", rarity: " << rarity << ", series: " << series << ", set: " << set << ", setCode: " << setCode << ", condition: " << condition << ", status: " << status;
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || Adding card: " << cardId << " to m_cards.";
 
    // Add created Card to Card List
    m_cards << newCard;
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || Card: " << cardId << " added to m_cards.";
 
    // For debugging purposes
    qDebug() << "[CardsManager] [update] >> addCardByName(const QString &newName) || Calling cardAdded signal for Card: " << cardId << ", returning the card object.";
 
    cardAdded(cardId);
    return newCard;
}
 
Card CardsManager::card(const QString &id) const
{
    // For debugging purposes
    qDebug() << "[CardsManager] [called] >> card(const QString &id) || id: " << id;
 
    bool matchFound = false;
    int match = -1;
    for(int i = 0; i < m_cards.count(); i++)
    {
        if(m_cards[i].getCardID() == id)
        {
            matchFound = true;
            match = i;
        }
    }
    if(matchFound == true)
    {
        // For debugging purposes
        qDebug() << "[CardsManager] [update] >> card(const QString &id) || Matching card found, returning Card from list m_cards[match], match: " << match;
        return m_cards[match];
    }
    else
    {
        // For debugging purposes
        qDebug() << "[CardsManager] [update] >> card(const QString &id) || No matching card found, returning Card().";
        return Card();
    }
}
 
QList<Card> CardsManager::cards() const
{
    // For debugging purposes
    qDebug() << "[CardsManager] [called] >> cards() || Returning m_cards";
    return m_cards;
}
 
int CardsManager::count() const
{
    // For debugging purposes
    qDebug() << "[CardsManager] [called] >> count() || Returning count: " << m_cards.count();
    return this->m_cards.count();
}
 
QHash<QString, int> CardsManager::nameToId() const
{
    // For debugging purposes
    qDebug() << "[CardsManager] [called] >> nameToId()";
 
    QHash<QString, int> name;
    name["Oddish"] = 1;
    name["Gloom"] = 2;
    name["Vileplume"] = 3;
    name["Bellossom"] = 4;
    name["Spinarak"] = 5;
    name["Ariados"] = 6;
    name["Sceptile-EX"] = 7;
    name["M Sceptile-EX"] = 8;
    name["Combee"] = 9;
    name["Vespiquen"] = 10;
    name["Vespiquen"] = 11;
    name["Virizion"] = 12;
    name["Flareon"] = 13;
    name["Entei"] = 14;
    name["Entei"] = 15;
    name["Larvesta"] = 16;
    name["Volcarona"] = 17;
    name["Volcarona"] = 18;
    name["Magikarp"] = 19;
    name["Gyarados"] = 20;
    name["Gyarados"] = 21;
    name["Vaporeon"] = 22;
    name["Relicanth"] = 23;
    name["Regice"] = 24;
    name["Kyurem-EX"] = 25;
    name["Jolteon"] = 26;
    name["Ampharos-EX"] = 27;
    name["M Ampharos-EX"] = 28;
    name["Rotom"] = 29;
    name["Unown"] = 30;
    name["Baltoy"] = 31;
    name["Baltoy"] = 32;
    name["Claydol"] = 33;
    name["Golett"] = 34;
    name["Golurk"] = 35;
    name["Hoopa-EX"] = 36;
    name["Machamp-EX"] = 37;
    name["Wooper"] = 38;
    name["Quagsire"] = 39;
    name["Regirock"] = 40;
    name["Golurk"] = 41;
    name["Tyranitar-EX"] = 42;
    name["M Tyranitar-EX"] = 43;
    name["Sableye"] = 44;
    name["Inkay"] = 45;
    name["Malamar"] = 46;
    name["Beldum"] = 47;
    name["Metang"] = 48;
    name["Metagross"] = 49;
    name["Metagross"] = 50;
    name["Registeel"] = 51;
    name["Ralts"] = 52;
    name["Kirlia"] = 53;
    name["Gardevoir"] = 54;
    name["Cottonee"] = 55;
    name["Whimsicott"] = 56;
    name["Giratina-EX"] = 57;
    name["Goomy"] = 58;
    name["Sliggoo"] = 59;
    name["Goodra"] = 60;
    name["Meowth"] = 61;
    name["Persian"] = 62;
    name["Eevee"] = 63;
    name["Porygon"] = 64;
    name["Porygon2"] = 65;
    name["Porygon-Z"] = 66;
    name["Porygon-Z"] = 67;
    name["Lugia-EX"] = 68;
    name["Ace Trainer"] = 69;
    name["Ampharos Spirit Link"] = 70;
    name["Eco Arm"] = 71;
    name["Energy Recycler"] = 72;
    name["Faded Town"] = 73;
    name["Forest of Giant Plants"] = 74;
    name["Hex Maniac"] = 75;
    name["Level Ball"] = 76;
    name["Lucky Helmet"] = 77;
    name["Lysandre"] = 78;
    name["Paint Roller"] = 79;
    name["Sceptile Spirit Link"] = 80;
    name["Tyranitar Spirit Link"] = 81;
    name["Dangerous Energy"] = 82;
    name["Flash Energy"] = 83;
    name["Sceptile-EX"] = 84;
    name["M Sceptile-EX"] = 85;
    name["Kyurem-EX"] = 86;
    name["Ampharos-EX"] = 87;
    name["M Ampharos-EX"] = 88;
    name["Hoopa-EX"] = 89;
    name["Machamp-EX"] = 90;
    name["Tyranitar-EX"] = 91;
    name["M Tyranitar-EX"] = 92;
    name["Giratina-EX"] = 93;
    name["Lugia-EX"] = 94;
    name["Steven"] = 95;
    name["Primal Kyogre-EX"] = 96;
    name["Primal Groudon-EX"] = 97;
    name["M Rayquaza-EX"] = 98;
    name["Energy Retrieval"] = 99;
    name["Trainers' Mail"] = 100;
    return name;
}

main.cpp:

Code:

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlEngine>
#include <QQmlContext>
#include "app.h"
#include "album.h"
#include "card.h"
#include "albumsmanager.h"
#include "cardsmanager.h"
#include "abstractcardmodel.h"
#include "albumcardsmodel.h"
 
int main(int argc, char *argv[])
{
 
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
    QGuiApplication app(argc, argv);
 
    // Core classes
    qmlRegisterType<App>("PokeApp.Classes.Core", 1, 0, "App");
    qmlRegisterType<Album>("PokeApp.Classes.Core", 1, 0, "Album");
    qmlRegisterType<Card>("PokeApp.Classes.Core", 1, 0, "Card");
 
    // Manager classes
    qmlRegisterType<AlbumsManager>("PokeApp.Classes.Core", 1, 0, "AlbumsManager");
    qmlRegisterType<CardsManager>("PokeApp.Classes.Core", 1, 0, "CardsManager");
 
    // App engine
    QQmlApplicationEngine engine;
    engine.load(QUrl(QLatin1String("qrc:/main.qml")));
 
    App mainApp;
 
    // Context properties
    QQmlContext *ctxt1 = engine.rootContext();
    ctxt1->setContextProperty("albumCardsModel", mainApp.getAlbumCardsModelPointer());
    QQmlContext *ctxt2 = engine.rootContext();
    ctxt2->setContextProperty("albumsManager", mainApp.getAlbumsManagerPointer());
    QQmlContext *ctxt3 = engine.rootContext();
    ctxt3->setContextProperty("cardsManager", mainApp.getCardsManagerPointer());
 
 
    return app.exec();
}

main.qml:

Code:

import QtQuick 2.7
import QtQuick.Controls 2.0
import QtQuick.Layouts 1.0
import PokeApp.Classes.Core 1.0
 
ApplicationWindow {
    visible: true
    width: 640
    height: 480
    title: qsTr("Hello World")
 
    Rectangle {
        id: rec1
        anchors.top: parent.top
        height: 50
        width: parent.width
        color: 'LightBlue'
        MouseArea {
            anchors.fill: parent
            onClicked: albumsManager.createAlbum("My favorites");
        }
    }
 
    TextInput {
        id: text1
        width: parent.width
        anchors.top: rec1.bottom
        anchors.left: parent.left
        height: 50
        visible: true
        color: 'Blue'
    }
    Button {
        id: button1
        text: "Add card"
        anchors.top: text1.bottom
        width: parent.width
        height: 50
        visible: true
        onClicked:
        {
            albumsManager.addCard(1,text1.text)
        }
    }
 
    ListView {
        id: listview1
        model: albumCardsModel
        height: 200
        width: parent.width
        anchors.top: button1.bottom
        delegate: Text {
                text: "Card\n" +
                         "Name: " + albumCardsModel.name + ".\n" +
                         "ID: " + albumCardsModel.cardID + ".\n" +
                         "Image URL: " + albumCardsModel.imageURL + ".\n" +
                         "Subtype: " + albumCardsModel.subtype + ".\n" +
                         "Supertype: " + albumCardsModel.supertype + ".\n" +
                         "Number: " + albumCardsModel.number + ".\n" +
                         "Artist: " + albumCardsModel.artist + ".\n" +
                         "Rarity: " + albumCardsModel.rarity + ".\n" +
                         "Series: " + albumCardsModel.series + ".\n" +
                         "Set: " + albumCardsModel.set + ".\n" +
                         "Set code: " + albumCardsModel.setCode + ".\n" +
                         "Condition: " + albumCardsModel.condition + ".\n" +
                         "Status: " + albumCardsModel.status + ".\n"
            }
        }
}

Added after 6 minutes:

Run time qDebug() output:

https://www.youtube.com/watch?v=LmrYQMyXto4

Added after 4 minutes:

Clicking the top blue banner adds a new Album to AlbumsManager with the name "My Favorites".
The code used for this is:

Code:

MouseArea {
            anchors.fill: parent
            onClicked: albumsManager.createAlbum("My favorites");
        }

Pressing the button takes the text from the text fields and uses it as the requested Card ID and adds the card to AlbumID 1 in AlbumsManager.
The code used for this is:

Code:

onClicked:
        {
            albumsManager.addCard(1,text1.text)
        }

I beleive that I have not properly set the ListView model or that the signals aren't connected properly.

Added after 9 minutes:

Application output:

Running the app:

Code:

QML debugging is enabled. Only use this in a safe environment.
qrc:/main.qml:48: ReferenceError: albumCardsModel is not defined
[AlbumsManager] [called] [constructor] || m_albumId set to:  0
[CardsManager] [called] [Default constructor]
[AbstractCardModel] [called] [Default constructor]
[Album] [called] [albumId: 0 ] [Default constructor]
[AlbumCardsModel] [called] [Default Constructor]
[App] [called] [Default Constructor]
[AlbumsManager] [called] [constructor] || m_albumId set to:  0
[AlbumsManager] [called] [Assignment Operator]
[AlbumsManager] [called] [Destructor].
[CardsManager] [called] [Default constructor]
[CardsManager] [called] [Assignment Operator]
[AbstractCardModel] [called] [Overloaded constructor]
[Album] [called] [albumId: 1469051904 ] [Default constructor]
[AlbumCardsModel] [called] [Overloaded Constructor]
[AbstractCardModel] [called] [Assignment Operator]
[Album] [called] [albumId: 0 ] [Assignment opperator] || albumId:  0
[Album] [called] [albumId: 1469051904 ] >> getNrOfCards() || returned count:  0
[Album] [called] [albumId: 1469051904 ] [Destructor]
[AbstractCardModel] [called] [Default Destructor]
[AlbumCardsModel] [called] >> rowCount(const QModelIndex&)
[Album] [called] [albumId: 1469051904 ] >> getCardIDs()

Clicking the "Create Album Banner":

Code:

"[AlbumsManager] [called] >> createAlbum(const QString &name) || name: My favorites"
[AlbumsManager] [update] >> createAlbum(const QString &name) || Assigning albumId:  1  to newAlbum
[AlbumsManager] [update] >> createAlbum(const QString &name) || calling Overloaded Album constructor, name:  "My favorites" , m_albumId:  1
[Album] [called] [albumId: 1 ] [Overloaded constructor] || newAlbumName:  "My favorites" , albumId:  1
[Album] [called] [albumId: -842150451 ] [Copy constructor] || albumId:  -842150451
[Album] [called] [albumId: 1 ] >> getNrOfCards() || returned count:  0
[AlbumsManager] [update] >> createAlbum(const QString &name) || newAlbum appended to m_albums
[Album] [called] [albumId: 1 ] [Destructor]

Clicking the "Add Card Button" with "14" in the "Text Field":

Code:

[AlbumsManager] [called] >> addCard(const int &albumId, const QString &cardId) || albumId:  1 , cardId:  "14"
[AlbumsManager] [called] >> count() || returned:  1
[Album] [called] [albumId: 1 ] >> getAlbumId() || returned: albumId:  1
[AlbumsManager] [called] >> count() || returned:  1
[AlbumsManager] [update] >> addCard(const int &albumId, const QString &cardId) || A matching Album was found.
[Album] [called] [albumId: 1 ] >> addCard(const QString& cardID): cardID:  "14"
[Album] [called] [albumId: 1 ] >> getCardIDs()

Closing the app:

Code:

[App] [called] [Default Destructor]
[Album] [called] [albumId: 1469051904 ] [Destructor]
[AbstractCardModel] [called] [Default Destructor]
[AlbumsManager] [called] [Destructor].
[Album] [called] [albumId: 1 ] [Destructor]

By the way, I am thinking of putting the whole project with the complete UI once it is complete for other people to use it as an example reference if they need one. :)

Added after 20 minutes:

Me right now:
http://i.imgur.com/e16qOEj.gif

2nd January 2017, 17:07
d_stranz

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

I don't understand why you are creating separate pointer variables in your App class for the AlbumsManager and other class instances you have as member variables. If you need to get the pointer to one of these member variables, just return "&albumManager".

I also don't understand why you have a separate QList of Albums as a member variable, and methods to add albums to it. This seems to completely bypass the role of the AlbumsManager class, because you are adding to this list without telling the AlbumsManager anything about it. You might be doing something similar in other parts of your code with Cards, but I haven't looked that deeply into it.

Also, understand that the Album instances contained in the QList<> are not the same as the Album instances that the AlbumsManager is managing. When you add the Album to either one of them you are adding by value and thus making an independent copy in both places. Modifying the Album in the list does nothing to modify the Album of the same name and id in the AlbumsManager. This is why anda_skoa's code used Album and Card ids instead Album and Card themselves in most places. The AlbumsManager and CardsManager should hold the only real instances of Album and Card, respectively.

Finally, I don't understand how you can even build this code, because copy constructors and assignment operators for QObject-based classes is forbidden by Qt. If your code tried to do a copy or assignment of one of these classes, it probably wouldn't compile, so maybe your compiler is optimizing out the code that isn't being used.
2nd January 2017, 17:22
Nizars

Re: Integration: Nested Tree Parent Child C++ Classes with Models/Delegates for QML

Yeah sorry about the code in the App class. It is just old functions that I haven't removed. I won't be using them and will remove them now. The App class contains code from from when it used to the class that managed the Albums. It does not any longer and just left the code in it's place knowing that it won't interfere with the purpose of the new changes I am doing to it.

When it comes to the copy constructors and assignment operators, I decided to just add them to all the classes because I have been constantly getting errors like: "Can't instanciate abstract class", "class doesn't have appropriate default constructor" "class references deleted constructor". I kept getting these in different variations when I tried to register or use any of the models. So it was more of a temporary duct tape fix rather than a planned class design.

A lot of the weird functions that you find are there because I try to find solutions and ways to implement the configurations on my my own before asking for help. I simply want to try to follow the instructions on my own and do whatever seems necessary to fix any potential conflicts from my implementations instead of having to ask you guys to show how to do everything step by step, so I apologize for any confusions. I read and re-read everything you guys write and will re-read it all again. If it doesn't look like it it's probably because something in the code is causing me problems and I am trying to temporarily bypass it until I fully understand what is happening.

I have also noticed that I haven't connected the signals. I am working on them now.

Edit: Thanks for the tip about passing pointers. I didn't know about that. I saved the pointer variables just to be sure that the pointers won't be deleted as soon the the function ends. A flawed method of thinking but as I said earlier, I am simply trying different things to see what will fix a problem and what won't. It's hard to produce code that isn't a beginner's code when I am still learning but I will try to take in everything you guys have offered to show me.

Show 50 post(s) from this thread on one page