DirList.h

Go to the documentation of this file.

// $Id: DirList.h,v 1.1.1.1 2009/07/06 23:57:25 eml Exp $

#ifndef GCP_UTIL_DIRLIST_H
#define GCP_UTIL_DIRLIST_H

#include <iostream>
#include <sstream>
#include <list>

namespace gcp {
  namespace util {

    class DirList {
    public:

      enum EntryType {
    TYPE_FILE  = 1,
    TYPE_DIR   = 2,
    TYPE_PIPE  = 4,
    TYPE_LINK  = 8,
    TYPE_ANY  = TYPE_FILE | TYPE_DIR | TYPE_PIPE,
      };

      // Enumerate an orthogonal set of file permissions that can be
      // tested for by testPathname()
      
      enum EntryRights {
    ENTRY_NONE  = 0,
    ENTRY_READ  = 1,  /* Test if the file is readable */
    ENTRY_WRITE = 2,  /* Test if the file is writable */
    ENTRY_EXE   = 4,  /* Test if the file is executable */
    ENTRY_OK    = 8   /* Test if the file exists, regardless of permissions */
      };

      struct DirEnt {
    EntryType   type_;   // Type of this entry
    EntryRights rights_; // Access of this entry
    std::string name_;   // Name of this entry
    std::string path_;   // Path to this entry, relative to the top directory

    // If this entry is a directory, this list will contain all
    // nodes below it

    std::list<DirEnt> entries_; 

    DirEnt(std::string name, std::string path, EntryType type, EntryRights rights) {
      name_     = name;
      path_     = path;
      type_     = type;
      rights_   = rights;
    }

    bool isDir() {
      return (unsigned)(type_) & TYPE_DIR;
    }

    bool isLink() {
      return (unsigned)(type_) & TYPE_LINK;
    }

    bool isFile() {
      return (unsigned)(type_) & TYPE_FILE;
    }

    bool isReadable() {
      return (unsigned)(rights_) & ENTRY_READ;
    }

    std::string pathName() {
      std::ostringstream os;
      os << path_ << "/";
      return os.str();
    }

    std::string fullName() {
      std::ostringstream os;
      os << path_ << "/" << name_;
      return os.str();
    }
      };

      friend std::ostream& operator<<(std::ostream& os, DirEnt& entry);

      DirList(std::string path, bool descend);

      DirList(const DirList& objToBeCopied);

      DirList(DirList& objToBeCopied);

      void operator=(const DirList& objToBeAssigned);

      void operator=(DirList& objToBeAssigned);

      friend std::ostream& operator<<(std::ostream& os, DirList& obj);

      virtual ~DirList();

      //  Get a listing of the specified directory, and optionally
      //  descend into subdirectories

      void listEntries();

      std::list<DirEnt> getFiles(bool includeSymlinks=false);
      std::list<DirEnt> getDirs(bool includeSymlinks=false);

      void listEntries(std::list<DirEnt>& entries);

    private:

      // The list of entries in this directory

      std::list<DirEnt> entries_; 

      void findEntries(std::list<DirEnt>& entries_, std::string path,
                bool descend);

      // Check whether a pathname refers to a file with selected
      // attributes.

      bool testPathname(std::string path, EntryType type, unsigned rights);

      // Check whether a pathname refers to a file with selected
      // attributes.

      EntryType getType(std::string path, bool link=false);

      // Get the access rights to this entry

      DirList::EntryRights getRights(std::string path);

      void getFiles(std::list<DirEnt>& files, 
            std::list<DirEnt>& entries, bool includeSymlinks);
      
      void getDirs(std::list<DirEnt>& dirs, 
           std::list<DirEnt>& entries, bool includeSymlinks);

    }; // End class DirList

  } // End namespace util
} // End namespace gcp



#endif // End #ifndef GCP_UTIL_DIRLIST_H