Logo Search packages:      
Sourcecode: partitionmanager version File versions  Download package

partition.h

/***************************************************************************
 *   Copyright (C) 2008 by Volker Lanz <vl@fidra.de>                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
 ***************************************************************************/

#if !defined(PARTITION__H)

#define PARTITION__H

#include "core/partitionnode.h"
#include "core/partitionrole.h"
#include "core/partitiontable.h"

#include <QStringList>
#include <qglobal.h>

class Device;
class OperationStack;

class PartResizerWidget;
class InsertDialog;
class NewDialog;

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;

/** @brief A partition or some unallocated space on a Device.

      Repesent 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 vl@fidra.de
*/
00066 class Partition : public PartitionNode
{
      friend class PartitionTable;
      friend class OperationStack;
      friend class Device;
      friend class PartitionNode;

      friend class PartResizerWidget;
      friend class InsertDialog;
      friend class NewDialog;

      friend class CreateFileSystemOperation;
      friend class RestoreOperation;
      friend class SetPartFlagsOperation;
      friend class CopyOperation;
      friend class NewOperation;
      friend class ResizeOperation;

      friend class SetPartGeometryJob;
      friend class CreatePartitionJob;
      friend class SetPartFlagsJob;
      friend class RestoreFileSystemJob;

      public:
            /** A Partition state -- where did it come from? */
00091             enum State
            {
00093                   StateNone = 0,          /**< exists on disk */
00094                   StateNew = 1,           /**< from a NewOperation */
00095                   StateCopy = 2,          /**< from a CopyOperation */
00096                   StateRestore = 3  /**< from a RestoreOperation */
            };

      public:
            Partition(PartitionNode* parent, const Device& device, const PartitionRole& role, FileSystem* fs, qint64 sectorStart, qint64 sectorEnd, qint32 number, PartitionTable::Flags availableFlags = PartitionTable::FlagNone, const QStringList& mountPoints = QStringList(), bool mounted = false, PartitionTable::Flags activeFlags = PartitionTable::FlagNone, State state = StateNone);
            ~Partition();

      public:
            Partition(const Partition&);
            Partition& operator=(const Partition&);

      public:
00108             qint32 number() const { return m_Number; } /**< @return the Partition's device number, e.g. 7 for /dev/sdd7 */

00110             bool isRoot() const { return false; } /**< @return always false for Partition */

00112             PartitionNode* parent() { return m_Parent; } /**< @return the Partition's parent PartitionNode */
00113             const PartitionNode* parent() const { return m_Parent; } /**< @return the Partition's parent PartitionNode */

00115             Partitions& children() { return m_Children; } /**< @return the Partition's children. empty for non-extended. */
00116             const Partitions& children() const { return m_Children; } /**< @return the Partition's children. empty for non-extended. */

00118             const QString& devicePath() const { return m_DevicePath; } /**< @return the Partition's device path, e.g. /dev/sdd7 */

00120             qint64 firstSector() const { return m_FirstSector; } /**< @return the Partition's first sector on the Device */
00121             qint64 lastSector() const { return m_LastSector; } /**< @return the Partition's last sector on the Device */
            qint64 sectorsUsed() const;
00123             qint32 sectorSize() const { return m_SectorSize; } /**< @return the sector size on the Partition's Device */
00124             qint64 length() const { return lastSector() - firstSector() + 1; } /**< @return the length of the Partition */
00125             qint64 capacity() const { return length() * sectorSize(); } /**< @return the capacity of the Partition in bytes */
00126             qint64 used() const { return sectorsUsed() < 0 ? -1 : sectorsUsed() * sectorSize(); } /**< @return the number of used sectors in the Partition's FileSystem */
00127             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;

00135             const PartitionRole& roles() const { return m_Roles; } /**< @return the Partition's role(s) */

00137             const QStringList& mountPoints() const { return m_MountPoints; } /**< @return the Partition's mount points */

00139             PartitionTable::Flags activeFlags() const { return m_ActiveFlags; } /**< @return the flags currently set for this Partition */
00140             PartitionTable::Flags availableFlags() const { return m_AvailableFlags; } /**< @return the flags available for this Partition */

00142             bool isMounted() const { return m_IsMounted; } /**< @return true if Partition is mounted */

00144             FileSystem& fileSystem() { return *m_FileSystem; } /**< @return the Partition's FileSystem */
00145             const FileSystem& fileSystem() const { return *m_FileSystem; } /**< @return the Partition's FileSystem */

00147             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);
            void checkChildrenMounted();

      protected:
            void append(Partition* p) { m_Children.append(p); }
            void setDevicePath(const QString& s) { m_DevicePath = s; }
            void setRoles(const PartitionRole& r) { m_Roles = r; }
            void setMountPoints(const QStringList& sl) { m_MountPoints = sl; }
            void setFlags(PartitionTable::Flags f) { m_ActiveFlags = f; }
            void setSectorSize(qint32 s) { m_SectorSize = s; }
            void setFirstSector(qint64 s) { m_FirstSector = s; }
            void setLastSector(qint64 s) { m_LastSector = s; }
            void move(qint64 newStartSector);
            void setMounted(bool b) { m_IsMounted = b; }
            void setFlag(PartitionTable::Flag f) { m_ActiveFlags |= f; }
            void unsetFlag(PartitionTable::Flag f) { m_ActiveFlags &= ~f; }
            void setParent(PartitionNode* p) { m_Parent = p; }
            void setFileSystem(FileSystem* fs);
            void setNumber(qint32 n) { m_Number = n; }
            void setState(State s) { m_State = s; }
            void deleteFileSystem();

      private:
            qint32 m_Number;
            Partitions m_Children;
            PartitionNode* m_Parent;
            FileSystem* m_FileSystem;
            PartitionRole m_Roles;
            qint64 m_FirstSector;
            qint64 m_LastSector;
            QString m_DevicePath;
            QStringList m_MountPoints;
            PartitionTable::Flags m_AvailableFlags;
            PartitionTable::Flags m_ActiveFlags;
            bool m_IsMounted;
            qint32 m_SectorSize;
            State m_State;
};

#endif


Generated by  Doxygen 1.6.0   Back to index