File indexing completed on 2024-05-05 05:48:41

 /*
     SPDX-FileCopyrightText: 2008-2012 Volker Lanz <vl@fidra.de>
     SPDX-FileCopyrightText: 2008 Laurent Montel <montel@kde.org>
     SPDX-FileCopyrightText: 2015 Chris Campbell <c.j.campbell@ed.ac.uk>
     SPDX-FileCopyrightText: 2016-2019 Andrius Štikonas <andrius@stikonas.eu>
     SPDX-FileCopyrightText: 2015-2016 Teo Mrnjavac <teo@kde.org>
     SPDX-FileCopyrightText: 2016 Chantara Tith <tith.chantara@gmail.com>
 
     SPDX-License-Identifier: GPL-3.0-or-later
 */
 
 #ifndef KPMCORE_PARTITIONTABLE_H
 #define KPMCORE_PARTITIONTABLE_H
 
 #include "util/libpartitionmanagerexport.h"
 
 #include "core/partitionnode.h"
 #include "core/partitionrole.h"
 
 #include <QList>
 #include <QtGlobal>
 
 class Device;
 class Partition;
 class CoreBackend;
 
 class QTextStream;
 
 /** The partition table (a.k.a Disk Label)
 
     PartitionTable represents a partition table (or disk label).
 
     PartitionTable has child nodes that represent Partitions.
 
     @author Volker Lanz <vl@fidra.de>
 */
 class LIBKPMCORE_EXPORT PartitionTable : public PartitionNode
 {
     PartitionTable &operator=(const PartitionTable &) = delete;
 
     friend class CoreBackend;
     friend LIBKPMCORE_EXPORT QTextStream& operator<<(QTextStream& stream, const PartitionTable& ptable);
 
 public:
     enum TableType : int8_t {
         unknownTableType = -1,
 
         aix,
         bsd,
         dasd,
         msdos,
         msdos_sectorbased,
         dvh,
         gpt,
         loop,
         mac,
         pc98,
         amiga,
         sun,
         vmd,  /* Volume Manager Device */
         none, /* Single FileSystem devices */
     };
 
     /** Partition flags */
     enum Flag : uint32_t {
         None = 0x0,
         Boot = 0x1,
         Root = 0x2,
         Swap = 0x4,
         Hidden = 0x8,
         Raid = 0x10,
         Lvm = 0x20,
         Lba = 0x40,
         HpService = 0x80,
         Palo = 0x100,
         Prep = 0x200,
         MsftReserved = 0x400,
         BiosGrub = 0x800,
         AppleTvRecovery = 0x1000,
         Diag = 0x2000,
         LegacyBoot = 0x4000,
         MsftData = 0x8000,
         Irst = 0x100000,
         FlagNone [[deprecated("Use PartitionTable::Flag::None")]] = None,
         FlagBoot [[deprecated("Use PartitionTable::Flag::Boot")]] = Boot,
         FlagRoot [[deprecated("Use PartitionTable::Flag::Root")]] = Root,
         FlagSwap [[deprecated("Use PartitionTable::Flag::Swap")]] = Swap,
         FlagHidden [[deprecated("Use PartitionTable::Flag::Hidden")]] = Hidden,
         FlagRaid [[deprecated("Use PartitionTable::Flag::Raid")]] = Raid,
         FlagLvm [[deprecated("Use PartitionTable::Flag::Lvm")]] = Lvm,
         FlagLba [[deprecated("Use PartitionTable::Flag::Lba")]] = Lba,
         FlagHpService [[deprecated("Use PartitionTable::Flag::HpService")]] = HpService,
         FlagPalo [[deprecated("Use PartitionTable::Flag::Palo")]] = Palo,
         FlagPrep [[deprecated("Use PartitionTable::Flag::Prep")]] = Prep,
         FlagMsftReserved [[deprecated("Use PartitionTable::Flag::MsftReserved")]] = MsftReserved,
         FlagBiosGrub [[deprecated("Use PartitionTable::Flag::BiosGrub")]] = BiosGrub,
         FlagAppleTvRecovery [[deprecated("Use PartitionTable::Flag::AppleTvRecovery")]] = AppleTvRecovery,
         FlagDiag [[deprecated("Use PartitionTable::Flag::Diag")]] = Diag,
         FlagLegacyBoot [[deprecated("Use PartitionTable::Flag::LegacyBoot")]] = LegacyBoot,
         FlagMsftData [[deprecated("Use PartitionTable::Flag::MsftData")]] = MsftData,
         FlagIrst [[deprecated("Use PartitionTable::Flag::Irst")]] = Irst,
         FlagEsp [[deprecated("Use PartitionTable::Flag::Boot")]] = Boot
     };
 
     Q_DECLARE_FLAGS(Flags, Flag)
 
 public:
     PartitionTable(TableType type, qint64 firstUsable, qint64 lastUsable);
     PartitionTable(const PartitionTable& other);
     ~PartitionTable() override;
 
 public:
     PartitionNode* parent() override {
         return nullptr;    /**< @return always nullptr for PartitionTable */
     }
     const PartitionNode* parent() const override {
         return nullptr;    /**< @return always nullptr for PartitionTable */
     }
 
     bool isRoot() const override {
         return true;    /**< @return always true for PartitionTable */
     }
     bool isReadOnly() const {
         return tableTypeIsReadOnly(type());    /**< @return true if the PartitionTable is read only */
     }
 
     Partitions& children() override {
         return m_Children;    /**< @return the children in this PartitionTable */
     }
     const Partitions& children() const override {
         return m_Children;    /**< @return the children in this PartitionTable */
     }
 
     void setType(const Device& d, TableType t);
 
     void append(Partition* partition) override;
 
     qint64 freeSectorsBefore(const Partition& p) const;
     qint64 freeSectorsAfter(const Partition& p) const;
     qint64 freeSectors() const;
 
     bool hasExtended() const;
     Partition* extended() const;
 
     PartitionRole::Roles childRoles(const Partition& p) const;
 
     qint32 numPrimaries() const;
     qint32 maxPrimaries() const {
         return m_MaxPrimaries;    /**< @return max number of primary partitions this PartitionTable can handle */
     }
 
     PartitionTable::TableType type() const {
         return m_Type;    /**< @return the PartitionTable's type */
     }
     const QString typeName() const {
         return tableTypeToName(type());    /**< @return the name of this PartitionTable type */
     }
 
     qint64 firstUsable() const {
         return m_FirstUsable;
     }
     qint64 lastUsable() const {
         return m_LastUsable;
     }
 
     void setFirstUsableSector(qint64 s) {
         m_FirstUsable = s;
     }
     void setLastUsableSector(qint64 s) {
         m_LastUsable = s;
     }
 
     void updateUnallocated(const Device& d);
     void insertUnallocated(const Device& d, PartitionNode* p, qint64 start);
 
     bool isSectorBased(const Device& d) const;
 
     static const QList<Flag> flagList();
     static QString flagName(Flag f);
     static QStringList flagNames(Flags f);
     static PartitionTable::Flags flagsFromList(const QStringList list);
 
     static bool getUnallocatedRange(const Device& device, PartitionNode& parent, qint64& start, qint64& end);
 
     static void removeUnallocated(PartitionNode* p);
     void removeUnallocated();
 
     static qint64 defaultFirstUsable(const Device& d, TableType t);
     static qint64 defaultLastUsable(const Device& d, TableType t);
 
     static PartitionTable::TableType nameToTableType(const QString& n);
     static QString tableTypeToName(TableType l);
     static qint32 maxPrimariesForTableType(TableType l);
     static bool tableTypeSupportsExtended(TableType l);
     static bool tableTypeIsReadOnly(TableType l);
 
 protected:
     void setMaxPrimaries(qint32 n) {
         m_MaxPrimaries = n;
     }
 
 private:
     Partitions m_Children;
     qint32 m_MaxPrimaries;
     TableType m_Type;
     qint64 m_FirstUsable;
     qint64 m_LastUsable;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(PartitionTable::Flags)
 
 QTextStream& operator<<(QTextStream& stream, const PartitionTable& ptable);
 
 #endif