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();

    static std::string findFile(std::string const&);

  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_();
    static std::string const& searchPath();
  };

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