Value lost after 2nd call of method-CodePudding

I have a problem with this situation (underneath) in the console.

The data is lost after passing twice in my method called in main.ccp after making the MyClass object.

main.ccp

#include <QCoreApplication>
#include <QDebug>
#include <iostream>
#include <myclass.h>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyClass* myClass = new MyClass();
    qDebug() << "Debug part 1";
    myClass->method();
    qDebug() << "Debug part 2";
    myClass->method();

    return a.exec();
}

The result in console:

Debug part 1
0
1 ".."   "0 Bytes"   "26.03.2022 08:21:13"
2 "stephane/"   "0 Bytes"   "26.04.2022 19:48:04"
3 ".localized"   "0 Bytes"   "26.03.2022 08:21:13"
4 "Shared/"   "0 Bytes"   "26.03.2022 08:21:13"
Debug part 2
0

The sources files:

myclass.h myclass.ccp entrys.h entrys.ccp entry.h entry.ccp

myclass.h

#ifndef MYCLASS_H
#define MYCLASS_H

#include <QObject>
#include <QString>
#include <QDateTime>
#include "entrys.h"

class MyClass : public QObject
{
Q_OBJECT
public:
    explicit MyClass(QObject *parent = nullptr);
    void method();
signals:
private:
    Entrys* entrys;
};


#endif // MYCLASS_H

myclass.ccp

#include "myclass.h"

#include <iostream>
#include "myclass.h"
#include "entry.h"
#include "entrys.h"

MyClass::MyClass(QObject *parent) : QObject(parent) {
    this->entrys = new Entrys();
    try {
        this->entrys->setDir("/Users/","L");
    } catch(ErrDirNotFound &e) {
        qDebug() << e.description << " " << e.what();
    }
}

void MyClass::method() {
    int i = 0;
    qDebug() << i;
    foreach(Entry *v, this->entrys->getEntrys("L")) {
        i  ;
        qDebug() << i << v->getName() << " " << v->getSizeString(2) << " " << v->getDateLastChangeString();
    }
}

entrys.h

#ifndef ENTRYS_H
#define ENTRYS_H

#include <QObject>
#include "entry.h"

struct ErrDirNotFound: public std::exception {
    QString description;
    const char *what() const throw() {
        return "Directory not found";
    }
};

class Entrys : public QObject
{
Q_OBJECT
public:
    explicit Entrys(QObject *parent = nullptr);
    void setDir(QString dir, QString side);
    QVector<Entry*> getEntrys(QString side);
    Entry* getEntry(QString side, QString key);
    QString getPath(QString side);
protected:

signals:
private:
    QHash<QString, QString> hash_path;
    QHash<QString, QVector<Entry*>> hash_side_entry;
    void setList(QString side);
};

#endif // ENTRYS_H

entrys.ccp

#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <QDebug>
#include <iostream>
#include <QDateTime>
#include <QProcess>
#include "entry.h"
#include "entrys.h"

Entrys::Entrys(QObject *parent)
        : QObject{parent}
{

}

void Entrys::setList(QString side) {
    QVector<Entry*> vec_entry;
    QString path = this->getPath(side);
    QByteArray path_ba = path.toLocal8Bit();
    const char* path_cstr = path_ba.constData();
    struct dirent *lecture;
    DIR *dir;
    struct stat buf;
    QString currentPath;
    int row = 0;

    dir = opendir(path_cstr);
    if (dir == NULL) {
        ErrDirNotFound e;
        QString description = "Path "   path   " don't exist !";
        e.description = description;
        throw e;
    }

    while ((lecture = readdir(dir)) != NULL) {
        if (strcmp(lecture->d_name, ".") != 0) {
            currentPath = path   lecture->d_name;
            QByteArray path_qb = currentPath.toLocal8Bit();
            const char *charCurrentPath = path_qb.constData();
            if ((stat(charCurrentPath, &buf)) == -1) {
                qCritical() << "stat" << currentPath;
            }
            int size = buf.st_size;
            QDateTime modif = QDateTime::fromSecsSinceEpoch(buf.st_mtime);
            Entry *entry = new Entry();
            if (!strcmp(lecture->d_name, "..")) {
                if (this->getPath(side) != "/") {
                    entry->setValue(lecture->d_name, 0, modif, 0);
                }
            } else {
                if (S_ISDIR(buf.st_mode)) {
                    QString qstringTemp = lecture->d_name;
                    qstringTemp  = "/";
                    entry->setValue(qstringTemp, 0, modif, buf.st_mode);
                } else {
                    entry->setValue(lecture->d_name, size, modif, buf.st_mode);
                }
            }
            vec_entry.append(entry);
            row  ;
        }
    }
    delete lecture;
    closedir(dir);
    this->hash_side_entry.insert(side, vec_entry);
}

void Entrys::setDir(QString dir, QString side) {
    this->hash_path.insert(side, dir);
    this->setList(side);
}


QVector<Entry*> Entrys::getEntrys(QString side) {
    return this->hash_side_entry.take(side);
}

QString Entrys::getPath(QString side) {
    return this->hash_path[side];
}

Entry* Entrys::getEntry(QString side, QString key) {
    QVector<Entry*> entry = this->getEntrys(side);
    for (int i = 0; i < entry.length(); i  ) {
        if (entry[i]->getName() == key) {
            return entry[i];
        }
    }
    return nullptr;
}

entry.h

#ifndef ENTRY_H
#define ENTRY_H

#include <QObject>
#include <QString>
#include <QDateTime>

class Entry : public QObject
{
Q_OBJECT
public:
    explicit Entry(QObject *parent = nullptr);
    Entry(QString name, int size_file, QDateTime date_last_change, mode_t mode);
    void setValue(QString name, int size_file, QDateTime date_last_change, mode_t mode);
    QString getName();
    QString getSizeString(int decimals);
    QString getDateLastChangeString();
signals:
private:
    QString name;
    int size_file;
    QDateTime date_last_change;
    mode_t mode;
};


#endif // ENTRY_H

entry.ccp

#include <QDateTime>
#include "entry.h"

Entry::Entry(QObject *parent)
        : QObject{parent}
{

}

Entry::Entry(QString name, int size_file, QDateTime date_last_change, mode_t mode)
{
    this->name = name;
    this->size_file = size_file;
    this->date_last_change = date_last_change;
    this->mode = mode;
}

void Entry::setValue(QString name, int size_file, QDateTime date_last_change, mode_t mode)
{
    this->name = name;
    this->size_file = size_file;
    this->date_last_change = date_last_change;
    this->mode = mode;
}

QString Entry::getName()
{
    return this->name;
}

QString Entry::getSizeString(int decimals) {
    int bytes = this->size_file;
    if (bytes == 0) return "0 Bytes";
    const int K = 1024;
    const QStringList SIZES = { "Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
    const int I =  std::floor((std::log(bytes) / std::log(K)));
    int dm = decimals < 0 ? 0 : decimals;
    if (I == 0) dm = 0;
    return QString::number((bytes / std::pow(K, I)),'f', dm)   " "   SIZES[I];
}

QString Entry::getDateLastChangeString() {
    return this->date_last_change.toString("dd.MM.yyyy hh:mm:ss");
}

CodePudding user response：

Tracking through your code by eye, I find this concerning:

QVector<Entry*> Entrys::getEntrys(QString side) {
    return this->hash_side_entry.take(side);
}

A bit of googling indicates that QHash's take "Removes the item with the key from the hash and returns the value associated with it." So your getEntrys is modifying your hash_side_entry - taking data out of it. Thus when your second call to method ends up calling getEntrys a second time, there's nothing in hash_side_entry anymore.