Warning, file /system/kpmcore/src/core/partition.h was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /*
     SPDX-FileCopyrightText: 2008-2010 Volker Lanz <vl@fidra.de>
     SPDX-FileCopyrightText: 2008 Laurent Montel <montel@kde.org>
     SPDX-FileCopyrightText: 2013-2020 Andrius Štikonas <andrius@stikonas.eu>
     SPDX-FileCopyrightText: 2015 Chris Campbell <c.j.campbell@ed.ac.uk>
     SPDX-FileCopyrightText: 2015 Teo Mrnjavac <teo@kde.org>
     SPDX-FileCopyrightText: 2020 Gaël PORTAY <gael.portay@collabora.com>
 
     SPDX-License-Identifier: GPL-3.0-or-later
 */
 
 #ifndef KPMCORE_PARTITION_H
 #define KPMCORE_PARTITION_H
 
 #include "core/partitionnode.h"
 #include "core/partitionrole.h"
 #include "core/partitiontable.h"
 
 #include "util/libpartitionmanagerexport.h"
 
 #include <QtGlobal>
 #include <QPointer>
 
 class Device;
 class OperationStack;
 class CoreBackendPartitionTable;
 class PartitionAlignment;
 
 class PartResizerWidget;
 class ResizeDialog;
 class InsertDialog;
 class NewDialog;
 class EditMountPointDialog;
 class PartPropsDialog;
 class SizeDialogBase;
 
 class CreateFileSystemOperation;
 class RestoreOperation;
 class SetPartFlagsOperation;
 class CopyOperation;
 class NewOperation;
 class ResizeOperation;
 
 class SetPartGeometryJob;
 class CreatePartitionJob;
 class SetPartFlagsJob;
 class RestoreFileSystemJob;
 
 class FileSystem;
 
 class Report;
 
 class QString;
 class QTextStream;
 
 /** A partition or some unallocated space on a Device.
 
     Represent partitions in a PartitionTable on a Device. Partitions can be unallocated, thus not all
     instances really are partitions in the way the user would see them.
 
     Extended partitions have child objects that represent the logicals inside them.
 
     @see PartitionTable, Device, FileSystem
     @author Volker Lanz <vl@fidra.de>
 */
 class LIBKPMCORE_EXPORT Partition : public PartitionNode
 {
 
 public:
     /** A Partition state -- where did it come from? */
     enum State {
         None,      /**< exists on disk */
         New,       /**< from a NewOperation */
         Copy,      /**< from a CopyOperation */
         Restore,   /**< from a RestoreOperation */
         StateNone [[deprecated("Use Partition::State::None")]] = None,
         StateNew [[deprecated("Use Partition::State::New")]] = New,
         StateCopy [[deprecated("Use Partition::State::Copy")]] = Copy,
         StateRestore [[deprecated("Use Partition::State::Restore")]] = Restore
     };
 
     Partition(PartitionNode* parent, const Device& device, const PartitionRole& role, FileSystem* fs, qint64 sectorStart, qint64 sectorEnd, QString partitionPath, PartitionTable::Flags availableFlags = PartitionTable::Flag::None, const QString& mountPoint = QString(), bool mounted = false, PartitionTable::Flags activeFlags = PartitionTable::Flag::None, State state = State::None);
     ~Partition() override;
 
     Partition(const Partition& other, PartitionNode* parent = nullptr);
     Partition& operator=(const Partition&);
 
     bool operator==(const Partition& other) const;
     bool operator!=(const Partition& other) const;
 
     qint32 number() const {
         return m_Number;    /**< @return the Partition's device number, e.g. 7 for /dev/sdd7 */
     }
 
     bool isRoot() const override {
         return false;    /**< @return always false for Partition */
     }
 
     const PartitionTable* partitionTable() const;
 
     PartitionNode* parent() override {
         return m_Parent;    /**< @return the Partition's parent PartitionNode */
     }
     const PartitionNode* parent() const override {
         return m_Parent;    /**< @return the Partition's parent PartitionNode */
     }
 
     Partitions& children() override {
         return m_Children;    /**< @return the Partition's children. empty for non-extended. */
     }
     const Partitions& children() const override {
         return m_Children;    /**< @return the Partition's children. empty for non-extended. */
     }
     const QString& devicePath() const {
         return m_DevicePath;    /**< @return the Partition's device path, e.g. /dev/sdd */
     }
     const QString& partitionPath() const {
         return m_PartitionPath;    /**< @return the Partition's path, e.g. /dev/sdd1 */
     }
     const QString& label() const {
         return m_Label;    /**< @return the GPT Partition label */
     }
     const QString& type() const {
         return m_Type;    /**< @return the GPT Partition type */
     }
     const QString& uuid() const {
         return m_UUID;    /**< @return the GPT Partition UUID */
     }
     quint64 attributes() const {
         return m_Attributes;    /**< @return the GPT Partition attributes */
     }
     qint64 firstSector() const {
         return m_FirstSector;    /**< @return the Partition's first sector on the Device */
     }
     qint64 lastSector() const {
         return m_LastSector;    /**< @return the Partition's last sector on the Device */
     }
     qint64 firstByte() const {
         return firstSector() * sectorSize();    /**< @return the Partition's first byte on the Device */
     }
     qint64 lastByte() const {
         return firstByte() + length() * sectorSize() - 1;    /**< @return the Partition's last byte on the Device */
     }
     qint64 sectorsUsed() const;
     qint64 sectorSize() const {
         return m_SectorSize;    /**< @return the sector size on the Partition's Device */
     }
     qint64 length() const {
         return lastSector() - firstSector() + 1;    /**< @return the length of the Partition */
     }
     qint64 capacity() const {
         return length() * sectorSize();    /**< @return the capacity of the Partition in bytes */
     }
     qint64 used() const {
         return sectorsUsed() < 0 ? -1 : sectorsUsed() * sectorSize();    /**< @return the number of used sectors in the Partition's FileSystem */
     }
     qint64 available() const {
         return sectorsUsed() < 0 ? -1 : capacity() - used();    /**< @return the number of free sectors in the Partition's FileSystem */
     }
     qint64 minimumSectors() const;
     qint64 maximumSectors() const;
     qint64 maxFirstSector() const;
     qint64 minLastSector() const;
 
     QString deviceNode() const;
 
     const PartitionRole& roles() const {
         return m_Roles;    /**< @return the Partition's role(s) */
     }
 
     const QString& mountPoint() const {
         return m_MountPoint;    /**< @return the Partition's mount point */
     }
 
     PartitionTable::Flags activeFlags() const {
         return m_ActiveFlags;    /**< @return the flags currently set for this Partition */
     }
     PartitionTable::Flags availableFlags() const {
         return m_AvailableFlags;    /**< @return the flags available for this Partition */
     }
     bool isMounted() const {
         return m_IsMounted;    /**< @return true if Partition is mounted */
     }
     FileSystem& fileSystem() {
         return *m_FileSystem;    /**< @return the Partition's FileSystem */
     }
     const FileSystem& fileSystem() const {
         return *m_FileSystem;    /**< @return the Partition's FileSystem */
     }
     State state() const {
         return m_State;    /**< @return the Partition's state */
     }
     bool hasChildren() const;
 
     bool mount(Report& report);
     bool unmount(Report& report);
 
     bool canMount() const;
     bool canUnmount() const;
 
     void adjustLogicalNumbers(qint32 deletedNumber, qint32 insertedNumber) const;
     void checkChildrenMounted();
 
     void setFirstSector(qint64 s) {
         m_FirstSector = s;
     }
     void setLastSector(qint64 s) {
         m_LastSector = s;
     }
 
     void setLabel(const QString& s) {
         m_Label = s;    /**< @param s the new label */
     }
     void setType(const QString& s) {
         m_Type = s;    /**< @param s the new type */
     }
     void setUUID(const QString& s) {
         m_UUID = s;    /**< @param s the new UUID */
     }
     void setAttributes(quint64 f) {
         m_Attributes = f;    /**< @param f the new attributes */
     }
 
     void append(Partition* p) override {
         m_Children.append(p);
         std::sort(m_Children.begin(), m_Children.end(), [] (const Partition *a, const Partition *b) -> bool {return a->firstSector() < b->firstSector();});
     }
     void setDevicePath(const QString& s) {
         m_DevicePath = s;
     }
     void setPartitionPath(const QString& s);
     void setRoles(const PartitionRole& r) {
         m_Roles = r;
     }
     void setMountPoint(const QString& s) {
         m_MountPoint = s;
     }
     void setFlags(PartitionTable::Flags f) {
         m_ActiveFlags = f;
     }
     void setSectorSize(qint32 s) {
         m_SectorSize = s;
     }
     void move(qint64 newStartSector);
     void setMounted(bool b);
 
     void setFlag(PartitionTable::Flag f) {
         m_ActiveFlags = m_ActiveFlags.setFlag(f);
     }
     void unsetFlag(PartitionTable::Flag f) {
         m_ActiveFlags = m_ActiveFlags.setFlag(f, false);
     }
     void setParent(PartitionNode* p) {
         m_Parent = p;
     }
     void setFileSystem(FileSystem* fs);
     void setState(State s) {
         m_State = s;
     }
     void deleteFileSystem();
 
 private:
     void setNumber(qint32 n) {
         m_Number = n;
     }
 
     qint32 m_Number = 0;
     Partitions m_Children;
     QPointer< PartitionNode > m_Parent = nullptr;
     FileSystem* m_FileSystem = nullptr;
     PartitionRole m_Roles;
     qint64 m_FirstSector = 0;
     qint64 m_LastSector = 0;
     QString m_DevicePath;
     QString m_Label;
     QString m_Type;
     QString m_UUID;
     quint64 m_Attributes = 0;
     QString m_PartitionPath;
     QString m_MountPoint;
     PartitionTable::Flags m_AvailableFlags;
     PartitionTable::Flags m_ActiveFlags;
     bool m_IsMounted = false;
     qint64 m_SectorSize = 0;
     State m_State = None;
 };
 
 QTextStream& operator<<(QTextStream& stream, const Partition& p);
 
 #endif