xref: /frameworks/compile/mclinker/include/mcld/Support/Directory.h

//===- 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_