quazip-0.7.2/quazip/quazipdir.h

#ifndef QUAZIP_QUAZIPDIR_H
#define QUAZIP_QUAZIPDIR_H

/*
Copyright (C) 2005-2014 Sergey A. Tachenov

This file is part of QuaZIP.

QuaZIP is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.

QuaZIP 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with QuaZIP.  If not, see <http://www.gnu.org/licenses/>.

See COPYING file for the full LGPL text.

Original ZIP package is copyrighted by Gilles Vollant and contributors,
see quazip/(un)zip.h files for details. Basically it's the zlib license.
*/

class QuaZipDirPrivate;

#include "quazip.h"
#include "quazipfileinfo.h"
#include <QDir>
#include <QList>
#include <QSharedDataPointer>

/// Provides ZIP archive navigation.
/**
* This class is modelled after QDir, and is designed to provide similar
* features for ZIP archives.
*
* The only significant difference from QDir is that the root path is not
* '/', but an empty string since that's how the file paths are stored in
* the archive. However, QuaZipDir understands the paths starting with
* '/'. It is important in a few places:
*
* - In the cd() function.
* - In the constructor.
* - In the exists() function.
* - In the relativePath() function.
*
* Note that since ZIP uses '/' on all platforms, the '\' separator is
* not supported.
*/
class QUAZIP_EXPORT QuaZipDir {
private:
    QSharedDataPointer<QuaZipDirPrivate> d;
public:
    /// The copy constructor.
    QuaZipDir(const QuaZipDir &that);
    /// Constructs a QuaZipDir instance pointing to the specified directory.
    /**
       If \a dir is not specified, points to the root of the archive.
       The same happens if the \a dir is &quot;/&quot;.
     */
    QuaZipDir(QuaZip *zip, const QString &dir = QString());
    /// Destructor.
    ~QuaZipDir();
    /// The assignment operator.
    bool operator==(const QuaZipDir &that);
    /// operator!=
    /**
      \return \c true if either this and \a that use different QuaZip
      instances or if they point to different directories.
      */
    inline bool operator!=(const QuaZipDir &that) {return !operator==(that);}
    /// operator==
    /**
      \return \c true if both this and \a that use the same QuaZip
      instance and point to the same directory.
      */
    QuaZipDir& operator=(const QuaZipDir &that);
    /// Returns the name of the entry at the specified position.
    QString operator[](int pos) const;
    /// Returns the current case sensitivity mode.
    QuaZip::CaseSensitivity caseSensitivity() const;
    /// Changes the 'current' directory.
    /**
      * If the path starts with '/', it is interpreted as an absolute
      * path from the root of the archive. Otherwise, it is interpreted
      * as a path relative to the current directory as was set by the
      * previous cd() or the constructor.
      * 
      * Note that the subsequent path() call will not return a path
      * starting with '/' in all cases.
      */
    bool cd(const QString &dirName);
    /// Goes up.
    bool cdUp();
    /// Returns the number of entries in the directory.
    uint count() const;
    /// Returns the current directory name.
    /**
      The name doesn't include the path.
      */
    QString dirName() const;
    /// Returns the list of the entries in the directory.
    /**
      \param nameFilters The list of file patterns to list, uses the same
      syntax as QDir.
      \param filters The entry type filters, only Files and Dirs are
      accepted.
      \param sort Sorting mode.
      */
    QList<QuaZipFileInfo> entryInfoList(const QStringList &nameFilters,
        QDir::Filters filters = QDir::NoFilter,
        QDir::SortFlags sort = QDir::NoSort) const;
    /// Returns the list of the entries in the directory.
    /**
      \overload

      The same as entryInfoList(QStringList(), filters, sort).
      */
    QList<QuaZipFileInfo> entryInfoList(QDir::Filters filters = QDir::NoFilter,
        QDir::SortFlags sort = QDir::NoSort) const;
    /// Returns the list of the entries in the directory with zip64 support.
    /**
      \param nameFilters The list of file patterns to list, uses the same
      syntax as QDir.
      \param filters The entry type filters, only Files and Dirs are
      accepted.
      \param sort Sorting mode.
      */
    QList<QuaZipFileInfo64> entryInfoList64(const QStringList &nameFilters,
        QDir::Filters filters = QDir::NoFilter,
        QDir::SortFlags sort = QDir::NoSort) const;
    /// Returns the list of the entries in the directory with zip64 support.
    /**
      \overload

      The same as entryInfoList64(QStringList(), filters, sort).
      */
    QList<QuaZipFileInfo64> entryInfoList64(QDir::Filters filters = QDir::NoFilter,
        QDir::SortFlags sort = QDir::NoSort) const;
    /// Returns the list of the entry names in the directory.
    /**
      The same as entryInfoList(nameFilters, filters, sort), but only
      returns entry names.
      */
    QStringList entryList(const QStringList &nameFilters,
        QDir::Filters filters = QDir::NoFilter,
        QDir::SortFlags sort = QDir::NoSort) const;
    /// Returns the list of the entry names in the directory.
    /**
      \overload

      The same as entryList(QStringList(), filters, sort).
      */
    QStringList entryList(QDir::Filters filters = QDir::NoFilter,
        QDir::SortFlags sort = QDir::NoSort) const;
    /// Returns \c true if the entry with the specified name exists.
    /**
      The &quot;..&quot; is considered to exist if the current directory
      is not root. The &quot;.&quot; and &quot;/&quot; are considered to
      always exist. Paths starting with &quot;/&quot; are relative to
      the archive root, other paths are relative to the current dir.
      */
    bool exists(const QString &fileName) const;
    /// Return \c true if the directory pointed by this QuaZipDir exists.
    bool exists() const;
    /// Returns the full path to the specified file.
    /**
      Doesn't check if the file actually exists.
      */
    QString filePath(const QString &fileName) const;
    /// Returns the default filter.
    QDir::Filters filter();
    /// Returns if the QuaZipDir points to the root of the archive.
    /**
      Not that the root path is the empty string, not '/'.
     */
    bool isRoot() const;
    /// Return the default name filter.
    QStringList nameFilters() const;
    /// Returns the path to the current dir.
    /**
      The path never starts with '/', and the root path is an empty
      string.
      */
    QString path() const;
    /// Returns the path to the specified file relative to the current dir.
    /**
     * This function is mostly useless, provided only for the sake of
     *  completeness.
     *
     * @param fileName The path to the file, should start with &quot;/&quot;
     *  if relative to the archive root.
     * @return Path relative to the current dir.
     */
    QString relativeFilePath(const QString &fileName) const;
    /// Sets the default case sensitivity mode.
    void setCaseSensitivity(QuaZip::CaseSensitivity caseSensitivity);
    /// Sets the default filter.
    void setFilter(QDir::Filters filters);
    /// Sets the default name filter.
    void setNameFilters(const QStringList &nameFilters);
    /// Goes to the specified path.
    /**
      The difference from cd() is that this function never checks if the
      path actually exists and doesn't use relative paths, so it's
      possible to go to the root directory with setPath(&quot;&quot;).

      Note that this function still chops the trailing and/or leading
      '/' and treats a single '/' as the root path (path() will still
      return an empty string).
      */
    void setPath(const QString &path);
    /// Sets the default sorting mode.
    void setSorting(QDir::SortFlags sort);
    /// Returns the default sorting mode.
    QDir::SortFlags sorting() const;
};

#endif // QUAZIP_QUAZIPDIR_H
Revision:	1049
Committed:	Sat Sep 17 08:47:04 2016 UTC (9 years ago) by s10k
Content type:	text/x-chdr
File size:	8523 byte(s)
Log Message:
#	Content
1	#ifndef QUAZIP_QUAZIPDIR_H
2	#define QUAZIP_QUAZIPDIR_H
3
4	/*
5	Copyright (C) 2005-2014 Sergey A. Tachenov
6
7	This file is part of QuaZIP.
8
9	QuaZIP is free software: you can redistribute it and/or modify
10	it under the terms of the GNU Lesser General Public License as published by
11	the Free Software Foundation, either version 2.1 of the License, or
12	(at your option) any later version.
13
14	QuaZIP is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU Lesser General Public License for more details.
18
19	You should have received a copy of the GNU Lesser General Public License
20	along with QuaZIP. If not, see <http://www.gnu.org/licenses/>.
21
22	See COPYING file for the full LGPL text.
23
24	Original ZIP package is copyrighted by Gilles Vollant and contributors,
25	see quazip/(un)zip.h files for details. Basically it's the zlib license.
26	*/
27
28	class QuaZipDirPrivate;
29
30	#include "quazip.h"
31	#include "quazipfileinfo.h"
32	#include <QDir>
33	#include <QList>
34	#include <QSharedDataPointer>
35
36	/// Provides ZIP archive navigation.
37	/**
38	* This class is modelled after QDir, and is designed to provide similar
39	* features for ZIP archives.
40	*
41	* The only significant difference from QDir is that the root path is not
42	* '/', but an empty string since that's how the file paths are stored in
43	* the archive. However, QuaZipDir understands the paths starting with
44	* '/'. It is important in a few places:
45	*
46	* - In the cd() function.
47	* - In the constructor.
48	* - In the exists() function.
49	* - In the relativePath() function.
50	*
51	* Note that since ZIP uses '/' on all platforms, the '\' separator is
52	* not supported.
53	*/
54	class QUAZIP_EXPORT QuaZipDir {
55	private:
56	QSharedDataPointer<QuaZipDirPrivate> d;
57	public:
58	/// The copy constructor.
59	QuaZipDir(const QuaZipDir &that);
60	/// Constructs a QuaZipDir instance pointing to the specified directory.
61	/**
62	If \a dir is not specified, points to the root of the archive.
63	The same happens if the \a dir is "/".
64	*/
65	QuaZipDir(QuaZip *zip, const QString &dir = QString());
66	/// Destructor.
67	~QuaZipDir();
68	/// The assignment operator.
69	bool operator==(const QuaZipDir &that);
70	/// operator!=
71	/**
72	\return \c true if either this and \a that use different QuaZip
73	instances or if they point to different directories.
74	*/
75	inline bool operator!=(const QuaZipDir &that) {return !operator==(that);}
76	/// operator==
77	/**
78	\return \c true if both this and \a that use the same QuaZip
79	instance and point to the same directory.
80	*/
81	QuaZipDir& operator=(const QuaZipDir &that);
82	/// Returns the name of the entry at the specified position.
83	QString operator[](int pos) const;
84	/// Returns the current case sensitivity mode.
85	QuaZip::CaseSensitivity caseSensitivity() const;
86	/// Changes the 'current' directory.
87	/**
88	* If the path starts with '/', it is interpreted as an absolute
89	* path from the root of the archive. Otherwise, it is interpreted
90	* as a path relative to the current directory as was set by the
91	* previous cd() or the constructor.
92	*
93	* Note that the subsequent path() call will not return a path
94	* starting with '/' in all cases.
95	*/
96	bool cd(const QString &dirName);
97	/// Goes up.
98	bool cdUp();
99	/// Returns the number of entries in the directory.
100	uint count() const;
101	/// Returns the current directory name.
102	/**
103	The name doesn't include the path.
104	*/
105	QString dirName() const;
106	/// Returns the list of the entries in the directory.
107	/**
108	\param nameFilters The list of file patterns to list, uses the same
109	syntax as QDir.
110	\param filters The entry type filters, only Files and Dirs are
111	accepted.
112	\param sort Sorting mode.
113	*/
114	QList<QuaZipFileInfo> entryInfoList(const QStringList &nameFilters,
115	QDir::Filters filters = QDir::NoFilter,
116	QDir::SortFlags sort = QDir::NoSort) const;
117	/// Returns the list of the entries in the directory.
118	/**
119	\overload
120
121	The same as entryInfoList(QStringList(), filters, sort).
122	*/
123	QList<QuaZipFileInfo> entryInfoList(QDir::Filters filters = QDir::NoFilter,
124	QDir::SortFlags sort = QDir::NoSort) const;
125	/// Returns the list of the entries in the directory with zip64 support.
126	/**
127	\param nameFilters The list of file patterns to list, uses the same
128	syntax as QDir.
129	\param filters The entry type filters, only Files and Dirs are
130	accepted.
131	\param sort Sorting mode.
132	*/
133	QList<QuaZipFileInfo64> entryInfoList64(const QStringList &nameFilters,
134	QDir::Filters filters = QDir::NoFilter,
135	QDir::SortFlags sort = QDir::NoSort) const;
136	/// Returns the list of the entries in the directory with zip64 support.
137	/**
138	\overload
139
140	The same as entryInfoList64(QStringList(), filters, sort).
141	*/
142	QList<QuaZipFileInfo64> entryInfoList64(QDir::Filters filters = QDir::NoFilter,
143	QDir::SortFlags sort = QDir::NoSort) const;
144	/// Returns the list of the entry names in the directory.
145	/**
146	The same as entryInfoList(nameFilters, filters, sort), but only
147	returns entry names.
148	*/
149	QStringList entryList(const QStringList &nameFilters,
150	QDir::Filters filters = QDir::NoFilter,
151	QDir::SortFlags sort = QDir::NoSort) const;
152	/// Returns the list of the entry names in the directory.
153	/**
154	\overload
155
156	The same as entryList(QStringList(), filters, sort).
157	*/
158	QStringList entryList(QDir::Filters filters = QDir::NoFilter,
159	QDir::SortFlags sort = QDir::NoSort) const;
160	/// Returns \c true if the entry with the specified name exists.
161	/**
162	The ".." is considered to exist if the current directory
163	is not root. The "." and "/" are considered to
164	always exist. Paths starting with "/" are relative to
165	the archive root, other paths are relative to the current dir.
166	*/
167	bool exists(const QString &fileName) const;
168	/// Return \c true if the directory pointed by this QuaZipDir exists.
169	bool exists() const;
170	/// Returns the full path to the specified file.
171	/**
172	Doesn't check if the file actually exists.
173	*/
174	QString filePath(const QString &fileName) const;
175	/// Returns the default filter.
176	QDir::Filters filter();
177	/// Returns if the QuaZipDir points to the root of the archive.
178	/**
179	Not that the root path is the empty string, not '/'.
180	*/
181	bool isRoot() const;
182	/// Return the default name filter.
183	QStringList nameFilters() const;
184	/// Returns the path to the current dir.
185	/**
186	The path never starts with '/', and the root path is an empty
187	string.
188	*/
189	QString path() const;
190	/// Returns the path to the specified file relative to the current dir.
191	/**
192	* This function is mostly useless, provided only for the sake of
193	* completeness.
194	*
195	* @param fileName The path to the file, should start with "/"
196	* if relative to the archive root.
197	* @return Path relative to the current dir.
198	*/
199	QString relativeFilePath(const QString &fileName) const;
200	/// Sets the default case sensitivity mode.
201	void setCaseSensitivity(QuaZip::CaseSensitivity caseSensitivity);
202	/// Sets the default filter.
203	void setFilter(QDir::Filters filters);
204	/// Sets the default name filter.
205	void setNameFilters(const QStringList &nameFilters);
206	/// Goes to the specified path.
207	/**
208	The difference from cd() is that this function never checks if the
209	path actually exists and doesn't use relative paths, so it's
210	possible to go to the root directory with setPath("").
211
212	Note that this function still chops the trailing and/or leading
213	'/' and treats a single '/' as the root path (path() will still
214	return an empty string).
215	*/
216	void setPath(const QString &path);
217	/// Sets the default sorting mode.
218	void setSorting(QDir::SortFlags sort);
219	/// Returns the default sorting mode.
220	QDir::SortFlags sorting() const;
221	};
222
223	#endif // QUAZIP_QUAZIPDIR_H