156 lines
4.2 KiB
C++
156 lines
4.2 KiB
C++
//===- Directory.h --------------------------------------------------------===//
|
|
//
|
|
// The MCLinker Project
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#ifndef MCLD_SUPPORT_DIRECTORY_H_
|
|
#define MCLD_SUPPORT_DIRECTORY_H_
|
|
|
|
#include "mcld/ADT/TypeTraits.h"
|
|
#include "mcld/Support/FileSystem.h"
|
|
#include "mcld/Support/Path.h"
|
|
#include "mcld/Support/PathCache.h"
|
|
|
|
#include <llvm/Support/Allocator.h>
|
|
#include <cstddef>
|
|
|
|
namespace mcld {
|
|
namespace sys {
|
|
namespace fs {
|
|
|
|
class DirIterator;
|
|
|
|
/** \class Directory
|
|
* \brief A Directory object stores a Path object, a FileStatus object for
|
|
* non-symbolic link status, and a FileStatus object for symbolic link
|
|
* status. The FileStatus objects act as value caches.
|
|
*/
|
|
class Directory {
|
|
friend mcld::sys::fs::PathCache::entry_type* detail::bring_one_into_cache(
|
|
DirIterator& pIter);
|
|
friend void detail::open_dir(Directory& pDir);
|
|
friend void detail::close_dir(Directory& pDir);
|
|
|
|
private:
|
|
friend class DirIterator;
|
|
|
|
public:
|
|
typedef DirIterator iterator;
|
|
|
|
public:
|
|
/// default constructor
|
|
Directory();
|
|
|
|
/// constructor - a directory whose path is pPath
|
|
explicit Directory(const Path& pPath,
|
|
FileStatus st = FileStatus(),
|
|
FileStatus symlink_st = FileStatus());
|
|
|
|
explicit Directory(const char* pPath,
|
|
FileStatus st = FileStatus(),
|
|
FileStatus symlink_st = FileStatus());
|
|
|
|
/// copy constructor
|
|
/// when a copying construction happens, the cache is not copied.
|
|
Directory(const Directory& pCopy);
|
|
|
|
/// assignment
|
|
/// When an assignment occurs, the cache is clear.
|
|
Directory& operator=(const Directory& pCopy);
|
|
|
|
/// destructor, inheritable.
|
|
virtual ~Directory();
|
|
|
|
/// Since we have default construtor, we must provide assign.
|
|
void assign(const Path& pPath,
|
|
FileStatus st = FileStatus(),
|
|
FileStatus symlink_st = FileStatus());
|
|
|
|
/// clear - clear the cache and close the directory handler
|
|
void clear();
|
|
|
|
bool isGood() const;
|
|
|
|
/// path - the path of the directory
|
|
const Path& path() const { return m_Path; }
|
|
|
|
FileStatus status() const;
|
|
FileStatus symlinkStatus() const;
|
|
|
|
// ----- iterators ----- //
|
|
// While the iterators move, the direcotry is modified.
|
|
// Thus, we only provide non-constant iterator.
|
|
iterator begin();
|
|
iterator end();
|
|
|
|
protected:
|
|
mcld::sys::fs::Path m_Path;
|
|
mutable FileStatus m_FileStatus;
|
|
mutable FileStatus m_SymLinkStatus;
|
|
intptr_t m_Handler;
|
|
// the cache of directory
|
|
mcld::sys::fs::PathCache m_Cache;
|
|
bool m_CacheFull;
|
|
};
|
|
|
|
/** \class DirIterator
|
|
* \brief A DirIterator object can traverse all entries in a Directory
|
|
*
|
|
* DirIterator will open the directory and add entry into Directory::m_Cache
|
|
* DirIterator() is the end of a directory.
|
|
* If the end of the directory elements is reached, the iterator becomes
|
|
* equal to the end iterator value - DirIterator().
|
|
*
|
|
* @see Directory
|
|
*/
|
|
class DirIterator {
|
|
friend mcld::sys::fs::PathCache::entry_type* detail::bring_one_into_cache(
|
|
DirIterator& pIter);
|
|
friend class Directory;
|
|
|
|
public:
|
|
typedef mcld::sys::fs::PathCache DirCache;
|
|
|
|
public:
|
|
typedef Directory value_type;
|
|
typedef ConstTraits<Directory> const_traits;
|
|
typedef NonConstTraits<Directory> non_const_traits;
|
|
typedef std::input_iterator_tag iterator_category;
|
|
typedef size_t size_type;
|
|
typedef ptrdiff_t difference_type;
|
|
|
|
private:
|
|
explicit DirIterator(Directory* pParent, const DirCache::iterator& pIter);
|
|
|
|
public:
|
|
// Since StringMapIterator has no default constructor, we also have none.
|
|
DirIterator(const DirIterator& X);
|
|
~DirIterator();
|
|
DirIterator& operator=(const DirIterator& pCopy);
|
|
|
|
DirIterator& operator++();
|
|
DirIterator operator++(int);
|
|
|
|
Path* generic_path();
|
|
|
|
Path* path();
|
|
const Path* path() const;
|
|
|
|
bool operator==(const DirIterator& y) const;
|
|
bool operator!=(const DirIterator& y) const;
|
|
|
|
private:
|
|
Directory* m_pParent; // get handler
|
|
DirCache::iterator m_Iter; // for full situation
|
|
DirCache::entry_type* m_pEntry;
|
|
};
|
|
|
|
} // namespace fs
|
|
} // namespace sys
|
|
} // namespace mcld
|
|
|
|
#endif // MCLD_SUPPORT_DIRECTORY_H_
|