File indexing completed on 2024-05-12 04:01:52

 /*
     SPDX-FileCopyrightText: 2006-2007 Kevin Ottens <ervin@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #ifndef SOLID_STORAGEDRIVE_H
 #define SOLID_STORAGEDRIVE_H
 
 #include <solid/solid_export.h>
 
 #include <solid/deviceinterface.h>
 
 namespace Solid
 {
 class StorageDrivePrivate;
 class Device;
 
 /**
  * @class Solid::StorageDrive storagedrive.h <Solid/StorageDrive>
  *
  * This device interface is available on storage devices.
  *
  * A storage is anything that can contain a set of volumes (card reader,
  * hard disk, cdrom drive...). It's a particular kind of block device.
  */
 class SOLID_EXPORT StorageDrive : public DeviceInterface
 {
     Q_OBJECT
     Q_PROPERTY(Bus bus READ bus)
     Q_PROPERTY(DriveType driveType READ driveType)
     Q_PROPERTY(bool removable READ isRemovable)
     Q_PROPERTY(bool hotpluggable READ isHotpluggable)
     Q_PROPERTY(bool inUse READ isInUse)
     Q_PROPERTY(qulonglong size READ size)
     Q_PROPERTY(QDateTime timeDetected READ timeDetected CONSTANT)
     Q_PROPERTY(QDateTime timeMediaDetected READ timeDetected)
 
     Q_DECLARE_PRIVATE(StorageDrive)
     friend class Device;
 
 public:
     /**
      * This enum type defines the type of bus a storage device is attached to.
      *
      * - Ide : An Integrated Drive Electronics (IDE) bus, also known as ATA
      * - Usb : An Universal Serial Bus (USB)
      * - Ieee1394 : An Ieee1394 bus, also known as Firewire
      * - Scsi : A Small Computer System Interface bus
      * - Sata : A Serial Advanced Technology Attachment (SATA) bus
      * - Platform : A legacy bus that is part of the underlying platform
      */
     enum Bus { Ide, Usb, Ieee1394, Scsi, Sata, Platform };
     Q_ENUM(Bus)
 
     /**
      * This enum type defines the type of drive a storage device can be.
      *
      * - HardDisk : A hard disk
      * - CdromDrive : An optical drive
      * - Floppy : A floppy disk drive
      * - Tape : A tape drive
      * - CompactFlash : A Compact Flash card reader
      * - MemoryStick : A Memory Stick card reader
      * - SmartMedia : A Smart Media card reader
      * - SdMmc : A SecureDigital/MultiMediaCard card reader
      * - Xd : A xD card reader
      */
     enum DriveType { HardDisk, CdromDrive, Floppy, Tape, CompactFlash, MemoryStick, SmartMedia, SdMmc, Xd };
     Q_ENUM(DriveType)
 
 private:
     /**
      * Creates a new StorageDrive object.
      * You generally won't need this. It's created when necessary using
      * Device::as().
      *
      * @param backendObject the device interface object provided by the backend
      * @see Solid::Device::as()
      */
     SOLID_NO_EXPORT explicit StorageDrive(QObject *backendObject);
 
 public:
     /**
      * Destroys a StorageDrive object.
      */
     ~StorageDrive() override;
 
     /**
      * Get the Solid::DeviceInterface::Type of the StorageDrive device interface.
      *
      * @return the StorageDrive device interface type
      * @see Solid::DeviceInterface::Type
      */
     static Type deviceInterfaceType()
     {
         return DeviceInterface::StorageDrive;
     }
 
     /**
      * Retrieves the type of physical interface this storage device is
      * connected to.
      *
      * @return the bus type
      * @see Solid::StorageDrive::Bus
      */
     Bus bus() const;
 
     /**
      * Retrieves the type of this storage drive.
      *
      * @return the drive type
      * @see Solid::StorageDrive::DriveType
      */
     DriveType driveType() const;
 
     /**
      * Indicates if the media contained by this drive can be removed.
      *
      * For example memory card can be removed from the drive by the user,
      * while partitions can't be removed from hard disks.
      *
      * @return true if media can be removed, false otherwise.
      */
     bool isRemovable() const;
 
     /**
      * Indicates if this storage device can be plugged or unplugged while
      * the computer is running.
      *
      * @return true if this storage supports hotplug, false otherwise
      */
     bool isHotpluggable() const;
 
     /**
      * Retrieves this drives size in bytes.
      *
      * @return the size of this drive
      */
     qulonglong size() const;
 
     /**
      * Indicates if the storage device is currently in use
      * i.e. if at least one child storage access is
      * mounted
      *
      * @return true if at least one child storage access is mounted
      */
     bool isInUse() const;
 
     /**
      * Returns the time the drive was deteced.
      * Typically this means the time a drive was plugged in, or the computer rebooted
      *
      * An invalid datetime may be returned if the underlying information is not available
      * @since 6.0
      */
     QDateTime timeDetected() const;
 
     /**
      * Returns the time media in the drive was deteced.
      * Typically this means the time a card was inserted into a reader, or the computer rebooted
      *
      * An invalid datetime may be returned if the underlying information is not available
      * @since 6.0
      */
     QDateTime timeMediaDetected() const;
 
 protected:
     /**
      * @internal
      */
     SOLID_NO_EXPORT StorageDrive(StorageDrivePrivate &dd, QObject *backendObject);
 };
 }
 
 #endif // SOLID_STORAGEDRIVE_H