FileInPath.h

Go to the documentation of this file.

#ifndef FWCore_ParameterSet_FileInPath_h
#define FWCore_ParameterSet_FileInPath_h




// Notes:
//
//  1. We do not deal well with paths that contain spaces; this is because
//     of the way the ParameterSet 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.


// TODO: Find the correct package for this class to reside. It
// doesn't seem well-suited for ParameterSet.


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

}

#endif