Directory.h revision f767be5432ccac097334be48698e48621d730190
1//===- Directory.h --------------------------------------------------------===// 2// 3// The MCLinker Project 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9#ifndef MCLD_DIRECTORY_H 10#define MCLD_DIRECTORY_H 11#ifdef ENABLE_UNITTEST 12#include <gtest.h> 13#endif 14 15#include <cstddef> 16 17#include "mcld/ADT/TypeTraits.h" 18#include "mcld/Support/FileSystem.h" 19#include "mcld/Support/Path.h" 20#include "mcld/Support/PathCache.h" 21#include <llvm/Support/Allocator.h> 22 23 24namespace mcld { 25namespace sys { 26namespace fs { 27 28class DirIterator; 29 30/** \class Directory 31 * \brief A Directory object stores a Path object, a FileStatus object for 32 * non-symbolic link status, and a FileStatus object for symbolic link 33 * status. The FileStatus objects act as value caches. 34 */ 35class Directory 36{ 37friend mcld::sys::fs::PathCache::entry_type* detail::bring_one_into_cache(DirIterator& pIter); 38friend void detail::open_dir(Directory& pDir); 39friend void detail::close_dir(Directory& pDir); 40private: 41 friend class DirIterator; 42 43public: 44 typedef DirIterator iterator; 45 46public: 47 /// default constructor 48 Directory(); 49 50 /// constructor - a directory whose path is pPath 51 explicit Directory(const Path& pPath, 52 FileStatus st = FileStatus(), 53 FileStatus symlink_st = FileStatus()); 54 55 /// copy constructor 56 /// when a copying construction happens, the cache is not copied. 57 Directory(const Directory& pCopy); 58 59 /// assignment 60 /// When an assignment occurs, the cache is clear. 61 Directory& operator=(const Directory& pCopy); 62 63 /// destructor, inheritable. 64 virtual ~Directory(); 65 66 /// Since we have default construtor, we must provide assign. 67 void assign(const Path& pPath, 68 FileStatus st = FileStatus(), 69 FileStatus symlink_st = FileStatus()); 70 71 /// clear - clear the cache and close the directory handler 72 void clear(); 73 74 bool isGood() const; 75 76 /// path - the path of the directory 77 const Path& path() const 78 { return m_Path; } 79 80 FileStatus status() const; 81 FileStatus symlinkStatus() const; 82 83 // ----- iterators ----- // 84 // While the iterators move, the direcotry is modified. 85 // Thus, we only provide non-constant iterator. 86 iterator begin(); 87 iterator end(); 88 89protected: 90 mcld::sys::fs::Path m_Path; 91 mutable FileStatus m_FileStatus; 92 mutable FileStatus m_SymLinkStatus; 93 intptr_t m_Handler; 94 // the cache of directory 95 mcld::sys::fs::PathCache m_Cache; 96 bool m_CacheFull; 97}; 98 99/** \class DirIterator 100 * \brief A DirIterator object can traverse all entries in a Directory 101 * 102 * DirIterator will open the directory and add entry into Directory::m_Cache 103 * DirIterator() is the end of a directory. 104 * If the end of the directory elements is reached, the iterator becomes 105 * equal to the end iterator value - DirIterator(). 106 * 107 * @see Directory 108 */ 109class DirIterator 110{ 111friend mcld::sys::fs::PathCache::entry_type* detail::bring_one_into_cache(DirIterator& pIter); 112friend class Directory; 113public: 114 typedef mcld::sys::fs::PathCache DirCache; 115 116public: 117 typedef Directory value_type; 118 typedef ConstTraits<Directory> const_traits; 119 typedef NonConstTraits<Directory> non_const_traits; 120 typedef std::input_iterator_tag iterator_category; 121 typedef size_t size_type; 122 typedef ptrdiff_t difference_type; 123 124private: 125 explicit DirIterator(Directory* pParent, 126 const DirCache::iterator& pIter); 127 128public: 129 // Since StringMapIterator has no default constructor, we also have none. 130 DirIterator(const DirIterator &X); 131 ~DirIterator(); 132 DirIterator& operator=(const DirIterator& pCopy); 133 134 DirIterator& operator++(); 135 DirIterator operator++(int); 136 137 Path* generic_path(); 138 139 Path* path(); 140 const Path* path() const; 141 142 bool operator==(const DirIterator& y) const; 143 bool operator!=(const DirIterator& y) const; 144 145private: 146 Directory* m_pParent; // get handler 147 DirCache::iterator m_Iter; // for full situation 148 DirCache::entry_type* m_pEntry; 149}; 150 151} // namespace of fs 152} // namespace of sys 153} // namespace of mcld 154 155#endif 156