Warning, file /network/kio-extras/mtp/kiod_module/mtpstorage.h was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /*
     This file is part of the MTP KIOD module, part of the KDE project.
 
     SPDX-FileCopyrightText: 2018 Andreas Krutzler <andreas.krutzler@gmx.net>
     SPDX-FileCopyrightText: 2023 Harald Sitter <sitter@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef MTPSTORAGE_H
 #define MTPSTORAGE_H
 
 #include <optional>
 
 #include <QDBusContext>
 #include <QObject>
 
 #include <kmtpfile.h>
 #include <libmtp.h>
 
 class MTPDevice;
 
 /**
  * @brief This D-Bus interface is used to access a single MTP storage.
  *
  * This includes storage management like file-, folder- and object-access.
  *
  * As a performance optimization to reduce hardware interaction,
  * a time based cache for file ids, mapping their path to their ID is used.
  */
 class MTPStorage : public QObject, protected QDBusContext
 {
     Q_OBJECT
     Q_PROPERTY(QString description READ description)
     Q_PROPERTY(quint64 maxCapacity READ maxCapacity)
     Q_PROPERTY(quint64 freeSpaceInBytes READ freeSpaceInBytes)
 
 public:
     explicit MTPStorage(const QString &dbusObjectPath, const LIBMTP_devicestorage_t *mtpStorage, MTPDevice *parent);
 
     QString dbusObjectPath() const;
 
     // D-Bus properties
     QString description() const;
     quint64 maxCapacity() const;
     quint64 freeSpaceInBytes();
 
 private:
     void setStorageProperties(const LIBMTP_devicestorage_t *storage);
     void updateStorageInfo();
 
     LIBMTP_mtpdevice_t *getDevice() const;
 
     /**
      * @brief Get the correct file/folder from the device.
      *
      * @param path
      * @return
      */
     KMTPFile getFileFromPath(const QString &path);
 
     /**
      * @brief Get all children files/folders of @a parentId and cache them.
      *
      * @param path      parent path, used for caching
      * @param parentId
      * @return
      */
     KMTPFileList getFilesAndFoldersCached(const QString &path, quint32 parentId);
 
     /**
      * @brief Find a given filename in the parentId's children
      *
      * @param fileNeedle
      * @param parentPath
      * @param parentId
      * @return std::optional<KMTPFile>
      */
     std::optional<KMTPFile> findEntry(const QString &fileNeedle, const QString &parentPath, quint32 parentId);
 
     /**
      * @brief Returns the ID of the item at the given path, else 0.
      *
      * Automatically discards old items.
      *
      * @param path The Path to query the cache for
      * @return The ID of the Item if it exists, else 0
      */
     std::optional<quint32> queryPath(const QString &path, int timeToLive = 60);
 
     /**
      * @brief Adds a Path to the Cache with the given id and ttl.
      *
      * @param path The path of the file/folder
      * @param id The file ID on the storage
      * @param timeToLive The time in seconds the entry should be valid
      */
     void addPath(const QString &path, quint32 id, int timeToLive = 60);
 
     /**
      * @brief Remove the given path from the cache, i.e. if it got deleted
      *
      * @param path The path that should be removed
      */
     void removePath(const QString &path);
 
     const QString m_dbusObjectPath;
 
     // LIBMTP_devicestorage_t properties
     quint32 m_id = 0; /**< Unique ID for this storage */
     quint64 m_maxCapacity = 0; /**< Maximum capability */
     quint64 m_freeSpaceInBytes = 0; /**< Free space in bytes */
     QString m_description; /**< A brief description of this storage */
 
     QHash<QString, QPair<QDateTime, uint32_t>> m_cache;
 
 public Q_SLOTS:
     // D-Bus methods
 
     // file management
     KMTPFileList getFilesAndFolders(const QString &path, int &result);
     QDBusObjectPath getFilesAndFolders2(const QString &path);
     KMTPFile getFileMetadata(const QString &path);
 
     int getFileToHandler(const QString &path);
     int getFileToFileDescriptor(const QDBusUnixFileDescriptor &descriptor, const QString &sourcePath);
 
     int sendFileFromFileDescriptor(const QDBusUnixFileDescriptor &descriptor, const QString &destinationPath);
     int setFileName(const QString &path, const QString &newName);
 
     // folder management
     quint32 createFolder(const QString &path);
 
     // object management
     int deleteObject(const QString &path);
 
 Q_SIGNALS:
     // D-Bus signals
     void dataReady(const QByteArray &data);
     void copyProgress(qulonglong transferredBytes, qulonglong totalBytes);
     void copyFinished(int result);
 };
 
 #endif // MTPSTORAGE_H