0
|
1 |
/****************************************************************************
|
|
2 |
**
|
|
3 |
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
4 |
** All rights reserved.
|
|
5 |
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
6 |
**
|
|
7 |
** This file is part of the test suite of the Qt Toolkit.
|
|
8 |
**
|
|
9 |
** $QT_BEGIN_LICENSE:LGPL$
|
|
10 |
** No Commercial Usage
|
|
11 |
** This file contains pre-release code and may not be distributed.
|
|
12 |
** You may use this file in accordance with the terms and conditions
|
|
13 |
** contained in the Technology Preview License Agreement accompanying
|
|
14 |
** this package.
|
|
15 |
**
|
|
16 |
** GNU Lesser General Public License Usage
|
|
17 |
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
18 |
** General Public License version 2.1 as published by the Free Software
|
|
19 |
** Foundation and appearing in the file LICENSE.LGPL included in the
|
|
20 |
** packaging of this file. Please review the following information to
|
|
21 |
** ensure the GNU Lesser General Public License version 2.1 requirements
|
|
22 |
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
23 |
**
|
|
24 |
** In addition, as a special exception, Nokia gives you certain additional
|
|
25 |
** rights. These rights are described in the Nokia Qt LGPL Exception
|
|
26 |
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
27 |
**
|
|
28 |
** If you have questions regarding the use of this file, please contact
|
|
29 |
** Nokia at qt-info@nokia.com.
|
|
30 |
**
|
|
31 |
**
|
|
32 |
**
|
|
33 |
**
|
|
34 |
**
|
|
35 |
**
|
|
36 |
**
|
|
37 |
**
|
|
38 |
** $QT_END_LICENSE$
|
|
39 |
**
|
|
40 |
****************************************************************************/
|
|
41 |
|
|
42 |
/*!
|
|
43 |
\since 4.5
|
|
44 |
\class QFileSystemIterator
|
|
45 |
\brief The QFileSystemIterator class provides an iterator for directory entrylists.
|
|
46 |
|
|
47 |
You can use QFileSystemIterator to navigate entries of a directory one at a time.
|
|
48 |
It is similar to QDir::entryList() and QDir::entryInfoList(), but because
|
|
49 |
it lists entries one at a time instead of all at once, it scales better
|
|
50 |
and is more suitable for large directories. It also supports listing
|
|
51 |
directory contents recursively, and following symbolic links. Unlike
|
|
52 |
QDir::entryList(), QFileSystemIterator does not support sorting.
|
|
53 |
|
|
54 |
The QFileSystemIterator constructor takes a QDir or a directory as
|
|
55 |
argument. After construction, the iterator is located before the first
|
|
56 |
directory entry. Here's how to iterate over all the entries sequentially:
|
|
57 |
|
|
58 |
\snippet doc/src/snippets/code/src.corelib.io.qdiriterator.cpp 0
|
|
59 |
|
|
60 |
The next() function returns the path to the next directory entry and
|
|
61 |
advances the iterator. You can also call filePath() to get the current
|
|
62 |
file path without advancing the iterator. The fileName() function returns
|
|
63 |
only the name of the file, similar to how QDir::entryList() works. You can
|
|
64 |
also call fileInfo() to get a QFileInfo for the current entry.
|
|
65 |
|
|
66 |
Unlike Qt's container iterators, QFileSystemIterator is uni-directional (i.e.,
|
|
67 |
you cannot iterate directories in reverse order) and does not allow random
|
|
68 |
access.
|
|
69 |
|
|
70 |
QFileSystemIterator works with all supported file engines, and is implemented
|
|
71 |
using QAbstractFileEngineIterator.
|
|
72 |
|
|
73 |
\sa QDir, QDir::entryList(), QAbstractFileEngineIterator
|
|
74 |
*/
|
|
75 |
|
|
76 |
/*! \enum QFileSystemIterator::IteratorFlag
|
|
77 |
|
|
78 |
This enum describes flags that you can combine to configure the behavior
|
|
79 |
of QFileSystemIterator.
|
|
80 |
|
|
81 |
\value NoIteratorFlags The default value, representing no flags. The
|
|
82 |
iterator will return entries for the assigned path.
|
|
83 |
|
|
84 |
\value Subdirectories List entries inside all subdirectories as well.
|
|
85 |
|
|
86 |
\value FollowSymlinks When combined with Subdirectories, this flag
|
|
87 |
enables iterating through all subdirectories of the assigned path,
|
|
88 |
following all symbolic links. Symbolic link loops (e.g., "link" => "." or
|
|
89 |
"link" => "..") are automatically detected and ignored.
|
|
90 |
*/
|
|
91 |
|
|
92 |
#include "qfilesystemiterator.h"
|
|
93 |
|
|
94 |
#include <QDebug>
|
|
95 |
#include <QtCore/qset.h>
|
|
96 |
#include <QtCore/qstack.h>
|
|
97 |
#include <QtCore/qvariant.h>
|
|
98 |
|
|
99 |
#ifdef Q_OS_WIN
|
|
100 |
# include <windows.h>
|
|
101 |
# include <atlbase.h>
|
|
102 |
#else
|
|
103 |
# include <sys/stat.h>
|
|
104 |
# include <sys/types.h>
|
|
105 |
# include <dirent.h>
|
|
106 |
# include <errno.h>
|
|
107 |
#endif
|
|
108 |
|
|
109 |
QT_BEGIN_NAMESPACE
|
|
110 |
|
|
111 |
class QFileSystemIteratorPrivate
|
|
112 |
{
|
|
113 |
public:
|
|
114 |
QFileSystemIteratorPrivate(const QString &path, const QStringList &nameFilters,
|
|
115 |
QDir::Filters filters, QFileSystemIterator::IteratorFlags flags);
|
|
116 |
~QFileSystemIteratorPrivate();
|
|
117 |
|
|
118 |
void pushSubDirectory(const QByteArray &path);
|
|
119 |
void advance();
|
|
120 |
bool isAcceptable() const;
|
|
121 |
bool shouldFollowDirectory(const QFileInfo &);
|
|
122 |
//bool matchesFilters(const QAbstractFileEngineIterator *it) const;
|
|
123 |
inline bool atEnd() const { return m_dirPaths.isEmpty(); }
|
|
124 |
|
|
125 |
#ifdef Q_OS_WIN
|
|
126 |
QStack<HANDLE> m_dirStructs;
|
|
127 |
WIN32_FIND_DATA* m_entry;
|
|
128 |
WIN32_FIND_DATA m_fileSearchResult;
|
|
129 |
bool m_bFirstSearchResult;
|
|
130 |
#else
|
|
131 |
QStack<DIR *> m_dirStructs;
|
|
132 |
dirent *m_entry;
|
|
133 |
#endif
|
|
134 |
|
|
135 |
QSet<QString> visitedLinks;
|
|
136 |
QStack<QByteArray> m_dirPaths;
|
|
137 |
QFileInfo fileInfo;
|
|
138 |
QString currentFilePath;
|
|
139 |
QFileSystemIterator::IteratorFlags iteratorFlags;
|
|
140 |
QDir::Filters filters;
|
|
141 |
QStringList nameFilters;
|
|
142 |
|
|
143 |
enum { DontShowDir, ShowDotDotDir, ShowDotDir, ShowDir }
|
|
144 |
m_currentDirShown, m_nextDirShown;
|
|
145 |
|
|
146 |
QFileSystemIterator *q;
|
|
147 |
|
|
148 |
private:
|
|
149 |
bool advanceHelper(); // returns true if we know we have something suitable
|
|
150 |
};
|
|
151 |
|
|
152 |
/*!
|
|
153 |
\internal
|
|
154 |
*/
|
|
155 |
QFileSystemIteratorPrivate::QFileSystemIteratorPrivate(const QString &path,
|
|
156 |
const QStringList &nameFilters, QDir::Filters filters,
|
|
157 |
QFileSystemIterator::IteratorFlags flags)
|
|
158 |
: iteratorFlags(flags)
|
|
159 |
{
|
|
160 |
if (filters == QDir::NoFilter)
|
|
161 |
filters = QDir::AllEntries;
|
|
162 |
this->filters = filters;
|
|
163 |
this->nameFilters = nameFilters;
|
|
164 |
|
|
165 |
fileInfo.setFile(path);
|
|
166 |
QString dir = fileInfo.isSymLink() ? fileInfo.canonicalFilePath() : path;
|
|
167 |
pushSubDirectory(dir.toLocal8Bit());
|
|
168 |
// skip to acceptable entry
|
|
169 |
while (true) {
|
|
170 |
if (atEnd())
|
|
171 |
return;
|
|
172 |
if (isAcceptable())
|
|
173 |
return;
|
|
174 |
if (advanceHelper())
|
|
175 |
return;
|
|
176 |
}
|
|
177 |
}
|
|
178 |
|
|
179 |
/*!
|
|
180 |
\internal
|
|
181 |
*/
|
|
182 |
QFileSystemIteratorPrivate::~QFileSystemIteratorPrivate()
|
|
183 |
{
|
|
184 |
#ifdef Q_OS_WIN
|
|
185 |
while (!m_dirStructs.isEmpty())
|
|
186 |
::FindClose(m_dirStructs.pop());
|
|
187 |
#else
|
|
188 |
while (!m_dirStructs.isEmpty())
|
|
189 |
::closedir(m_dirStructs.pop());
|
|
190 |
#endif
|
|
191 |
}
|
|
192 |
|
|
193 |
#ifdef Q_OS_WIN
|
|
194 |
static bool isDotOrDotDot(const wchar_t* name)
|
|
195 |
{
|
|
196 |
if (name[0] == L'.' && name[1] == 0)
|
|
197 |
return true;
|
|
198 |
if (name[0] == L'.' && name[1] == L'.' && name[2] == 0)
|
|
199 |
return true;
|
|
200 |
return false;
|
|
201 |
}
|
|
202 |
#else
|
|
203 |
static bool isDotOrDotDot(const char *name)
|
|
204 |
{
|
|
205 |
if (name[0] == '.' && name[1] == 0)
|
|
206 |
return true;
|
|
207 |
if (name[0] == '.' && name[1] == '.' && name[2] == 0)
|
|
208 |
return true;
|
|
209 |
return false;
|
|
210 |
}
|
|
211 |
#endif
|
|
212 |
|
|
213 |
/*!
|
|
214 |
\internal
|
|
215 |
*/
|
|
216 |
void QFileSystemIteratorPrivate::pushSubDirectory(const QByteArray &path)
|
|
217 |
{
|
|
218 |
/*
|
|
219 |
if (iteratorFlags & QFileSystemIterator::FollowSymlinks) {
|
|
220 |
if (fileInfo.filePath() != path)
|
|
221 |
fileInfo.setFile(path);
|
|
222 |
if (fileInfo.isSymLink()) {
|
|
223 |
visitedLinks << fileInfo.canonicalFilePath();
|
|
224 |
} else {
|
|
225 |
visitedLinks << fileInfo.absoluteFilePath();
|
|
226 |
}
|
|
227 |
}
|
|
228 |
*/
|
|
229 |
|
|
230 |
#ifdef Q_OS_WIN
|
|
231 |
wchar_t szSearchPath[MAX_PATH];
|
|
232 |
wcscpy(szSearchPath, QString(path).utf16());
|
|
233 |
wcscat(szSearchPath, L"\\*");
|
|
234 |
HANDLE dir = FindFirstFile(szSearchPath, &m_fileSearchResult);
|
|
235 |
m_bFirstSearchResult = true;
|
|
236 |
#else
|
|
237 |
DIR *dir = ::opendir(path.constData());
|
|
238 |
//m_entry = ::readdir(dir);
|
|
239 |
//while (m_entry && isDotOrDotDot(m_entry->d_name))
|
|
240 |
// m_entry = ::readdir(m_dirStructs.top());
|
|
241 |
#endif
|
|
242 |
m_dirStructs.append(dir);
|
|
243 |
m_dirPaths.append(path);
|
|
244 |
m_entry = 0;
|
|
245 |
if (filters & QDir::Dirs)
|
|
246 |
m_nextDirShown = ShowDir;
|
|
247 |
else
|
|
248 |
m_nextDirShown = DontShowDir;
|
|
249 |
m_currentDirShown = DontShowDir;
|
|
250 |
}
|
|
251 |
|
|
252 |
/*!
|
|
253 |
\internal
|
|
254 |
*/
|
|
255 |
bool QFileSystemIteratorPrivate::isAcceptable() const
|
|
256 |
{
|
|
257 |
if (!m_entry)
|
|
258 |
return false;
|
|
259 |
return true;
|
|
260 |
}
|
|
261 |
|
|
262 |
/*!
|
|
263 |
\internal
|
|
264 |
*/
|
|
265 |
|
|
266 |
|
|
267 |
void QFileSystemIteratorPrivate::advance()
|
|
268 |
{
|
|
269 |
while (true) {
|
|
270 |
if (advanceHelper())
|
|
271 |
return;
|
|
272 |
if (atEnd())
|
|
273 |
return;
|
|
274 |
if (isAcceptable())
|
|
275 |
return;
|
|
276 |
}
|
|
277 |
}
|
|
278 |
|
|
279 |
bool QFileSystemIteratorPrivate::advanceHelper()
|
|
280 |
{
|
|
281 |
if (m_dirStructs.isEmpty())
|
|
282 |
return true;
|
|
283 |
|
|
284 |
//printf("ADV %d %d\n", int(m_currentDirShown), int(m_nextDirShown));
|
|
285 |
|
|
286 |
if ((filters & QDir::Dirs)) {
|
|
287 |
m_currentDirShown = m_nextDirShown;
|
|
288 |
if (m_nextDirShown == ShowDir) {
|
|
289 |
//printf("RESTING ON DIR %s %x\n", m_dirPaths.top().constData(), int(filters));
|
|
290 |
m_nextDirShown = (filters & QDir::NoDotAndDotDot) ? DontShowDir : ShowDotDir;
|
|
291 |
// skip start directory itself
|
|
292 |
if (m_dirStructs.size() == 1 && m_currentDirShown == ShowDir)
|
|
293 |
return advanceHelper();
|
|
294 |
return true;
|
|
295 |
}
|
|
296 |
if (m_nextDirShown == ShowDotDir) {
|
|
297 |
//printf("RESTING ON DOT %s %x\n", m_dirPaths.top().constData(), int(filters));
|
|
298 |
m_nextDirShown = ShowDotDotDir;
|
|
299 |
return true;
|
|
300 |
}
|
|
301 |
if (m_nextDirShown == ShowDotDotDir) {
|
|
302 |
//printf("RESTING ON DOTDOT %s %x\n", m_dirPaths.top().constData(), int(filters));
|
|
303 |
m_nextDirShown = DontShowDir;
|
|
304 |
return true;
|
|
305 |
}
|
|
306 |
m_currentDirShown = DontShowDir;
|
|
307 |
}
|
|
308 |
|
|
309 |
#ifdef Q_OS_WIN
|
|
310 |
m_entry = &m_fileSearchResult;
|
|
311 |
if (m_bFirstSearchResult) {
|
|
312 |
m_bFirstSearchResult = false;
|
|
313 |
} else {
|
|
314 |
if (!FindNextFile(m_dirStructs.top(), m_entry))
|
|
315 |
m_entry = 0;
|
|
316 |
}
|
|
317 |
|
|
318 |
while (m_entry && isDotOrDotDot(m_entry->cFileName))
|
|
319 |
if (!FindNextFile(m_dirStructs.top(), m_entry))
|
|
320 |
m_entry = 0;
|
|
321 |
|
|
322 |
if (!m_entry) {
|
|
323 |
m_dirPaths.pop();
|
|
324 |
FindClose(m_dirStructs.pop());
|
|
325 |
return false;
|
|
326 |
}
|
|
327 |
|
|
328 |
if (m_entry->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
329 |
QByteArray ba = m_dirPaths.top();
|
|
330 |
ba += '\\';
|
|
331 |
ba += QString::fromWCharArray(m_entry->cFileName);
|
|
332 |
pushSubDirectory(ba);
|
|
333 |
}
|
|
334 |
#else
|
|
335 |
m_entry = ::readdir(m_dirStructs.top());
|
|
336 |
while (m_entry && isDotOrDotDot(m_entry->d_name))
|
|
337 |
m_entry = ::readdir(m_dirStructs.top());
|
|
338 |
//return false; // further iteration possibly needed
|
|
339 |
//printf("READ %p %s\n", m_entry, m_entry ? m_entry->d_name : "");
|
|
340 |
|
|
341 |
if (!m_entry) {
|
|
342 |
m_dirPaths.pop();
|
|
343 |
DIR *dir = m_dirStructs.pop();
|
|
344 |
::closedir(dir);
|
|
345 |
return false; // further iteration possibly needed
|
|
346 |
}
|
|
347 |
|
|
348 |
const char *name = m_entry->d_name;
|
|
349 |
|
|
350 |
QByteArray ba = m_dirPaths.top();
|
|
351 |
ba += '/';
|
|
352 |
ba += name;
|
|
353 |
struct stat st;
|
|
354 |
lstat(ba.constData(), &st);
|
|
355 |
|
|
356 |
if (S_ISDIR(st.st_mode)) {
|
|
357 |
pushSubDirectory(ba);
|
|
358 |
return false; // further iteration possibly needed
|
|
359 |
}
|
|
360 |
#endif
|
|
361 |
return false; // further iteration possiblye needed
|
|
362 |
}
|
|
363 |
|
|
364 |
/*!
|
|
365 |
\internal
|
|
366 |
*/
|
|
367 |
bool QFileSystemIteratorPrivate::shouldFollowDirectory(const QFileInfo &fileInfo)
|
|
368 |
{
|
|
369 |
// If we're doing flat iteration, we're done.
|
|
370 |
if (!(iteratorFlags & QFileSystemIterator::Subdirectories))
|
|
371 |
return false;
|
|
372 |
|
|
373 |
// Never follow non-directory entries
|
|
374 |
if (!fileInfo.isDir())
|
|
375 |
return false;
|
|
376 |
|
|
377 |
|
|
378 |
// Never follow . and ..
|
|
379 |
if (fileInfo.fileName() == QLatin1String(".") || fileInfo.fileName() == QLatin1String(".."))
|
|
380 |
return false;
|
|
381 |
|
|
382 |
|
|
383 |
// Check symlinks
|
|
384 |
if (fileInfo.isSymLink() && !(iteratorFlags & QFileSystemIterator::FollowSymlinks)) {
|
|
385 |
// Follow symlinks only if FollowSymlinks was passed
|
|
386 |
return false;
|
|
387 |
}
|
|
388 |
|
|
389 |
// Stop link loops
|
|
390 |
if (visitedLinks.contains(fileInfo.canonicalFilePath()))
|
|
391 |
return false;
|
|
392 |
|
|
393 |
return true;
|
|
394 |
}
|
|
395 |
|
|
396 |
|
|
397 |
/*!
|
|
398 |
\internal
|
|
399 |
|
|
400 |
This convenience function implements the iterator's filtering logics and
|
|
401 |
applies then to the current directory entry.
|
|
402 |
|
|
403 |
It returns true if the current entry matches the filters (i.e., the
|
|
404 |
current entry will be returned as part of the directory iteration);
|
|
405 |
otherwise, false is returned.
|
|
406 |
*/
|
|
407 |
#if 0
|
|
408 |
bool QFileSystemIteratorPrivate::matchesFilters(const QAbstractFileEngineIterator *it) const
|
|
409 |
{
|
|
410 |
const bool filterPermissions = ((filters & QDir::PermissionMask)
|
|
411 |
&& (filters & QDir::PermissionMask) != QDir::PermissionMask);
|
|
412 |
const bool skipDirs = !(filters & (QDir::Dirs | QDir::AllDirs));
|
|
413 |
const bool skipFiles = !(filters & QDir::Files);
|
|
414 |
const bool skipSymlinks = (filters & QDir::NoSymLinks);
|
|
415 |
const bool doReadable = !filterPermissions || (filters & QDir::Readable);
|
|
416 |
const bool doWritable = !filterPermissions || (filters & QDir::Writable);
|
|
417 |
const bool doExecutable = !filterPermissions || (filters & QDir::Executable);
|
|
418 |
const bool includeHidden = (filters & QDir::Hidden);
|
|
419 |
const bool includeSystem = (filters & QDir::System);
|
|
420 |
|
|
421 |
#ifndef QT_NO_REGEXP
|
|
422 |
// Prepare name filters
|
|
423 |
QList<QRegExp> regexps;
|
|
424 |
bool hasNameFilters = !nameFilters.isEmpty() && !(nameFilters.contains(QLatin1String("*")));
|
|
425 |
if (hasNameFilters) {
|
|
426 |
for (int i = 0; i < nameFilters.size(); ++i) {
|
|
427 |
regexps << QRegExp(nameFilters.at(i),
|
|
428 |
(filters & QDir::CaseSensitive) ? Qt::CaseSensitive : Qt::CaseInsensitive,
|
|
429 |
QRegExp::Wildcard);
|
|
430 |
}
|
|
431 |
}
|
|
432 |
#endif
|
|
433 |
|
|
434 |
QString fileName = it->currentFileName();
|
|
435 |
if (fileName.isEmpty()) {
|
|
436 |
// invalid entry
|
|
437 |
return false;
|
|
438 |
}
|
|
439 |
|
|
440 |
QFileInfo fi = it->currentFileInfo();
|
|
441 |
QString filePath = it->currentFilePath();
|
|
442 |
|
|
443 |
#ifndef QT_NO_REGEXP
|
|
444 |
// Pass all entries through name filters, except dirs if the AllDirs
|
|
445 |
// filter is passed.
|
|
446 |
if (hasNameFilters && !((filters & QDir::AllDirs) && fi.isDir())) {
|
|
447 |
bool matched = false;
|
|
448 |
for (int i = 0; i < regexps.size(); ++i) {
|
|
449 |
if (regexps.at(i).exactMatch(fileName)) {
|
|
450 |
matched = true;
|
|
451 |
break;
|
|
452 |
}
|
|
453 |
}
|
|
454 |
if (!matched)
|
|
455 |
return false;
|
|
456 |
}
|
|
457 |
#endif
|
|
458 |
|
|
459 |
bool dotOrDotDot = (fileName == QLatin1String(".") || fileName == QLatin1String(".."));
|
|
460 |
if ((filters & QDir::NoDotAndDotDot) && dotOrDotDot)
|
|
461 |
return false;
|
|
462 |
|
|
463 |
bool isHidden = !dotOrDotDot && fi.isHidden();
|
|
464 |
if (!includeHidden && isHidden)
|
|
465 |
return false;
|
|
466 |
|
|
467 |
bool isSystem = (!fi.isFile() && !fi.isDir() && !fi.isSymLink())
|
|
468 |
|| (!fi.exists() && fi.isSymLink());
|
|
469 |
if (!includeSystem && isSystem)
|
|
470 |
return false;
|
|
471 |
|
|
472 |
bool alwaysShow = (filters & QDir::TypeMask) == 0
|
|
473 |
&& ((isHidden && includeHidden)
|
|
474 |
|| (includeSystem && isSystem));
|
|
475 |
|
|
476 |
// Skip files and directories
|
|
477 |
if ((filters & QDir::AllDirs) == 0 && skipDirs && fi.isDir()) {
|
|
478 |
if (!alwaysShow)
|
|
479 |
return false;
|
|
480 |
}
|
|
481 |
|
|
482 |
if ((skipFiles && (fi.isFile() || !fi.exists()))
|
|
483 |
|| (skipSymlinks && fi.isSymLink())) {
|
|
484 |
if (!alwaysShow)
|
|
485 |
return false;
|
|
486 |
}
|
|
487 |
|
|
488 |
if (filterPermissions
|
|
489 |
&& ((doReadable && !fi.isReadable())
|
|
490 |
|| (doWritable && !fi.isWritable())
|
|
491 |
|| (doExecutable && !fi.isExecutable()))) {
|
|
492 |
return false;
|
|
493 |
}
|
|
494 |
|
|
495 |
if (!includeSystem && !dotOrDotDot && ((fi.exists() && !fi.isFile() && !fi.isDir() && !fi.isSymLink())
|
|
496 |
|| (!fi.exists() && fi.isSymLink()))) {
|
|
497 |
return false;
|
|
498 |
}
|
|
499 |
|
|
500 |
return true;
|
|
501 |
}
|
|
502 |
#endif
|
|
503 |
|
|
504 |
/*!
|
|
505 |
Constructs a QFileSystemIterator that can iterate over \a dir's entrylist, using
|
|
506 |
\a dir's name filters and regular filters. You can pass options via \a
|
|
507 |
flags to decide how the directory should be iterated.
|
|
508 |
|
|
509 |
By default, \a flags is NoIteratorFlags, which provides the same behavior
|
|
510 |
as in QDir::entryList().
|
|
511 |
|
|
512 |
The sorting in \a dir is ignored.
|
|
513 |
|
|
514 |
\sa atEnd(), next(), IteratorFlags
|
|
515 |
*/
|
|
516 |
QFileSystemIterator::QFileSystemIterator(const QDir &dir, IteratorFlags flags)
|
|
517 |
: d(new QFileSystemIteratorPrivate(dir.path(), dir.nameFilters(), dir.filter(), flags))
|
|
518 |
{
|
|
519 |
d->q = this;
|
|
520 |
}
|
|
521 |
|
|
522 |
/*!
|
|
523 |
Constructs a QFileSystemIterator that can iterate over \a path, with no name
|
|
524 |
filtering and \a filters for entry filtering. You can pass options via \a
|
|
525 |
flags to decide how the directory should be iterated.
|
|
526 |
|
|
527 |
By default, \a filters is QDir::NoFilter, and \a flags is NoIteratorFlags,
|
|
528 |
which provides the same behavior as in QDir::entryList().
|
|
529 |
|
|
530 |
\sa atEnd(), next(), IteratorFlags
|
|
531 |
*/
|
|
532 |
QFileSystemIterator::QFileSystemIterator(const QString &path, QDir::Filters filters, IteratorFlags flags)
|
|
533 |
: d(new QFileSystemIteratorPrivate(path, QStringList(QLatin1String("*")), filters, flags))
|
|
534 |
{
|
|
535 |
d->q = this;
|
|
536 |
}
|
|
537 |
|
|
538 |
/*!
|
|
539 |
Constructs a QFileSystemIterator that can iterate over \a path. You can pass
|
|
540 |
options via \a flags to decide how the directory should be iterated.
|
|
541 |
|
|
542 |
By default, \a flags is NoIteratorFlags, which provides the same behavior
|
|
543 |
as in QDir::entryList().
|
|
544 |
|
|
545 |
\sa atEnd(), next(), IteratorFlags
|
|
546 |
*/
|
|
547 |
QFileSystemIterator::QFileSystemIterator(const QString &path, IteratorFlags flags)
|
|
548 |
: d(new QFileSystemIteratorPrivate(path, QStringList(QLatin1String("*")), QDir::NoFilter, flags))
|
|
549 |
{
|
|
550 |
d->q = this;
|
|
551 |
}
|
|
552 |
|
|
553 |
/*!
|
|
554 |
Constructs a QFileSystemIterator that can iterate over \a path, using \a
|
|
555 |
nameFilters and \a filters. You can pass options via \a flags to decide
|
|
556 |
how the directory should be iterated.
|
|
557 |
|
|
558 |
By default, \a flags is NoIteratorFlags, which provides the same behavior
|
|
559 |
as QDir::entryList().
|
|
560 |
|
|
561 |
\sa atEnd(), next(), IteratorFlags
|
|
562 |
*/
|
|
563 |
QFileSystemIterator::QFileSystemIterator(const QString &path, const QStringList &nameFilters,
|
|
564 |
QDir::Filters filters, IteratorFlags flags)
|
|
565 |
: d(new QFileSystemIteratorPrivate(path, nameFilters, filters, flags))
|
|
566 |
{
|
|
567 |
d->q = this;
|
|
568 |
}
|
|
569 |
|
|
570 |
/*!
|
|
571 |
Destroys the QFileSystemIterator.
|
|
572 |
*/
|
|
573 |
QFileSystemIterator::~QFileSystemIterator()
|
|
574 |
{
|
|
575 |
delete d;
|
|
576 |
}
|
|
577 |
|
|
578 |
/*!
|
|
579 |
Advances the iterator to the next entry, and returns the file path of this
|
|
580 |
new entry. If atEnd() returns true, this function does nothing, and
|
|
581 |
returns a null QString.
|
|
582 |
|
|
583 |
You can call fileName() or filePath() to get the current entry file name
|
|
584 |
or path, or fileInfo() to get a QFileInfo for the current entry.
|
|
585 |
|
|
586 |
\sa hasNext(), fileName(), filePath(), fileInfo()
|
|
587 |
*/
|
|
588 |
void QFileSystemIterator::next()
|
|
589 |
{
|
|
590 |
d->advance();
|
|
591 |
}
|
|
592 |
|
|
593 |
/*!
|
|
594 |
Returns true if there is at least one more entry in the directory;
|
|
595 |
otherwise, false is returned.
|
|
596 |
|
|
597 |
\sa next(), fileName(), filePath(), fileInfo()
|
|
598 |
*/
|
|
599 |
bool QFileSystemIterator::atEnd() const
|
|
600 |
{
|
|
601 |
return d->atEnd();
|
|
602 |
}
|
|
603 |
|
|
604 |
/*!
|
|
605 |
Returns the file name for the current directory entry, without the path
|
|
606 |
prepended. If the current entry is invalid (i.e., isValid() returns
|
|
607 |
false), a null QString is returned.
|
|
608 |
|
|
609 |
This function is provided for the convenience when iterating single
|
|
610 |
directories. For recursive iteration, you should call filePath() or
|
|
611 |
fileInfo() instead.
|
|
612 |
|
|
613 |
\sa filePath(), fileInfo()
|
|
614 |
*/
|
|
615 |
QString QFileSystemIterator::fileName() const
|
|
616 |
{
|
|
617 |
if (d->atEnd() || !d->m_entry)
|
|
618 |
return QString();
|
|
619 |
if (d->m_currentDirShown == QFileSystemIteratorPrivate::ShowDir)
|
|
620 |
return QString();
|
|
621 |
if (d->m_currentDirShown == QFileSystemIteratorPrivate::ShowDotDir)
|
|
622 |
return QLatin1String("@");
|
|
623 |
if (d->m_currentDirShown == QFileSystemIteratorPrivate::ShowDotDotDir)
|
|
624 |
return QLatin1String("@@");
|
|
625 |
#ifdef Q_OS_WIN
|
|
626 |
return QString::fromWCharArray(d->m_entry->cFileName);
|
|
627 |
#else
|
|
628 |
return QString::fromLocal8Bit(d->m_entry->d_name);
|
|
629 |
#endif
|
|
630 |
}
|
|
631 |
|
|
632 |
/*!
|
|
633 |
Returns the full file path for the current directory entry. If the current
|
|
634 |
entry is invalid (i.e., isValid() returns false), a null QString is
|
|
635 |
returned.
|
|
636 |
|
|
637 |
\sa fileInfo(), fileName()
|
|
638 |
*/
|
|
639 |
QString QFileSystemIterator::filePath() const
|
|
640 |
{
|
|
641 |
if (d->atEnd())
|
|
642 |
return QString();
|
|
643 |
QByteArray ba = d->m_dirPaths.top();
|
|
644 |
if (d->m_currentDirShown == QFileSystemIteratorPrivate::ShowDotDir)
|
|
645 |
ba += "/.";
|
|
646 |
else if (d->m_currentDirShown == QFileSystemIteratorPrivate::ShowDotDotDir)
|
|
647 |
ba += "/..";
|
|
648 |
else if (d->m_entry) {
|
|
649 |
ba += '/';
|
|
650 |
#ifdef Q_OS_WIN
|
|
651 |
ba += QString::fromWCharArray(d->m_entry->cFileName);
|
|
652 |
#else
|
|
653 |
ba += d->m_entry->d_name;
|
|
654 |
#endif
|
|
655 |
}
|
|
656 |
return QString::fromLocal8Bit(ba);
|
|
657 |
}
|
|
658 |
|
|
659 |
/*!
|
|
660 |
Returns a QFileInfo for the current directory entry. If the current entry
|
|
661 |
is invalid (i.e., isValid() returns false), a null QFileInfo is returned.
|
|
662 |
|
|
663 |
\sa filePath(), fileName()
|
|
664 |
*/
|
|
665 |
QFileInfo QFileSystemIterator::fileInfo() const
|
|
666 |
{
|
|
667 |
return QFileInfo(filePath());
|
|
668 |
}
|
|
669 |
|
|
670 |
/*!
|
|
671 |
Returns the base directory of the iterator.
|
|
672 |
*/
|
|
673 |
QString QFileSystemIterator::path() const
|
|
674 |
{
|
|
675 |
return QString::fromLocal8Bit(d->m_dirPaths.top());
|
|
676 |
}
|
|
677 |
|
|
678 |
QT_END_NAMESPACE
|