FileInPath.h

Go to the documentation of this file.

#ifndef FWCore_Utilities_FileInPath_h
#define FWCore_Utilities_FileInPath_h
 
 
 
 
// Notes:
//
//  1. We do not deal well with paths that contain spaces; this is because
//     of the way the Utilities system's 'encode' and 'decode' functions
//     are implemented for FileInPath objects. This could be fixed, if it
//     is important to handle filenames or paths with embedded spaces.
//
//  2. All environment variables are read only once, when the FileInPath object is constructed.
//     Therefore, any changes made to these variables externally during the lifetime of
//     a FileInPath object will have no effect.
 
#include <iosfwd>
#include <string>
 
namespace edm {
  class FileInPath {
  public:
    enum LocationCode { Unknown = 0, Local = 1, Release = 2, Data = 3 };
 
    FileInPath();
 
    explicit FileInPath(const std::string& r);
    explicit FileInPath(const char* r);
 
    FileInPath(FileInPath const& other);
    FileInPath& operator=(FileInPath const& other);
    ~FileInPath();
    void swap(FileInPath& other);
 
    std::string relativePath() const;
 
    LocationCode location() const;
 
    std::string fullPath() const;
 
    void write(std::ostream& os) const;
 
    void read(std::istream& is);
 
    void readFromParameterSetBlob(std::istream& is);
 
    static void disableFileLookup();
 
  private:
    std::string relativePath_;
    std::string canonicalFilename_;
    LocationCode location_;
    std::string localTop_;
    std::string releaseTop_;
    std::string dataTop_;
    std::string searchPath_;
 
    // Helper function for construction.
    void getEnvironment();
    void initialize_();
  };
 
  // Free swap function
  inline void swap(FileInPath& a, FileInPath& b) { a.swap(b); }
 
  inline std::ostream& operator<<(std::ostream& os, const edm::FileInPath& fip) {
    fip.write(os);
    return os;
  }
 
  inline std::istream& operator>>(std::istream& is, FileInPath& fip) {
    fip.read(is);
    return is;
  }
 
  inline bool operator==(edm::FileInPath const& a, edm::FileInPath const& b) {
    return a.location() == b.location() && a.relativePath() == b.relativePath();
  }
 
}  // namespace edm
 
#endif