Add GFilename methods exists(), is_fits() and remove() and remove the equivalent…

… methods from GTools.

Add GFilename methods exists(), is_fits() and remove() and remove the equivalent…
… methods from GTools.
Jürgen Knödlseder
1 parent fae992c1
Showing 14 changed files with 207 additions and 190 deletions
ChangeLog
NEWS
include/GFilename.hpp
include/GTools.hpp
inst/com/src/GCOMResponse.cpp
inst/cta/src/GCTAEventList.cpp
inst/cta/src/GCTAResponseIrf.cpp
pyext/GFilename.i
pyext/GTools.i
src/fits/GFits.cpp
src/support/GCsv.cpp
src/support/GFilename.cpp
src/support/GTools.cpp
src/xml/GXml.cpp
-2016-02-13  Juergen Knoedlseder  <jurgen.knodlseder@irap.omp.eu>
+2016-02-16  Juergen Knoedlseder  <jurgen.knodlseder@irap.omp.eu>
  
         * Version 1.1.0 released
         =========================
  
+        Add GFilename methods and remove equivalents from GTools
         Use column names for CTA response table access (#1656)
         Add non-const GObservation::events() method (#1664)
         Remove event fetching from GCTAObservation class (#1648)
@@ -2,7 +2,7 @@ New Features and Important Changes in GammaLib 1.1.0
  
 Author(s) : Juergen Knoedlseder
  
-13 February 2016
+16 February 2016
  
  
 1. Introduction
@@ -15,7 +15,10 @@ made since the last release of GammaLib.
 ---------------------------------
 The following methods have been added to the public interface:
 - GObservation::events() (non-const variant)
-- GFilename::operator()
+- GFilename::operator std::string()
+- GFilename::exists()
+- GFilename::is_fits()
+- GFilename::remove()
 - GCTAResponseTable::axis(std::string)
 - GCTAResponseTable::table(std::string)
 - GCTAResponseTable::has_axis(std::string)
@@ -23,6 +26,9 @@ The following methods have been added to the public interface:
  
 The following methods have been removed:
 - GFilename::size()
+- gammalib::file_exists()
+- gammalib::file_exists_gzip()
+- gammalib::is_fits()
  
 The following methods have been renamed:
 - GCTAResponseTable::tables(), was GCTAResponseTable::size()
@@ -127,8 +133,12 @@ None
  
 13. Support module
 ------------------
-Add GFilename::fullname() method that returns the full filename including
-any FITS extension.
+The GFilename class has been extended and some methods have been renamed.
+The full filename including and FITS extension is now returned by an
+implicit type conversion operator std::string(). The filename() method has
+been renamed to url(), and the methods exists(), is_fits() and remove()
+have been added to replace functions of the GTools module that were used
+for this purpose in the past.
  
  
 14. XML module
@@ -89,9 +89,9 @@ public:
     //std::string        protocol(void) const;
     //std::string&       path(void) const;
     //std::string&       file(void) const;
-    //bool               exists(void) const;
-    //bool               is_fits(void) const;
-    //void               remove(void) const;
+    bool               exists(void) const;
+    bool               is_fits(void) const;
+    void               remove(void) const;
     std::string        extname(const std::string& defaultname = "") const;
     const std::string& expression(void) const;
     int                extno(const int& defaultno = -1) const;
@@ -110,10 +110,9 @@ protected:
     void set_filename(const std::string& filename);
  
     // Protected members
-    std::string m_fullname;   //!< Full file name
-    std::string m_filename;   //!< File name (with stripped extension info)
+    std::string m_filename;   //!< Full file name
     //std::string m_protocol;   //!< Access protocol
-    //std::string m_url;        //!< File name (with stripped extension info)
+    std::string m_url;        //!< File name (with stripped extension info)
     //std::string m_path;       //!< Path
     std::string m_extname;    //!< Extension name ("": not set)
     int         m_extno;      //!< Extension number  (-1: not set)
@@ -132,7 +131,7 @@ protected:
 inline
 GFilename::operator std::string(void) const
 {
-    return (gammalib::expand_env(m_fullname));
+    return (gammalib::expand_env(m_filename));
 }
  
  
@@ -156,7 +155,7 @@ std::string GFilename::classname(void) const
 inline
 bool GFilename::is_empty(void) const
 {
-    return (m_fullname.empty());
+    return (m_filename.empty());
 }
  
  
@@ -164,11 +163,13 @@ bool GFilename::is_empty(void) const
  * @brief Return length of filename
  *
  * @return Length of filename.
+ *
+ * Returns the length of the filename, excluding any FITS extension.
  ***************************************************************************/
 inline
 int GFilename::length(void) const
 {
-    return (m_filename.length());
+    return (m_url.length());
 }
  
  
@@ -183,7 +184,7 @@ int GFilename::length(void) const
 inline
 std::string GFilename::url(void) const
 {
-    return (gammalib::expand_env(m_filename));
+    return (gammalib::expand_env(m_url));
 }
  
  
@@ -95,12 +95,9 @@ namespace gammalib {
                                               const double& epivot,
                                               const double& gamma);
     GEnergy                  elogmean(const GEnergy& a, const GEnergy& b);
-    bool                     file_exists(const std::string& filename);
-    bool                     file_exists_gzip(const std::string& filename);
     bool                     dir_exists(const std::string& dirname);
     bool                     is_infinite(const double& x);
     bool                     is_notanumber(const double& x);
-    bool                     is_fits(const std::string& filename);
     bool                     contains(const std::string& str,
                                       const std::string& substring);
     void                     warning(const std::string& origin,
@@ -465,23 +465,17 @@ void GCOMResponse::load(const std::string&amp; rspname)
     m_rspname = rspname;
  
     // First attempt reading the response using the GCaldb interface
-    std::string filename = m_caldb.filename("","","IAQ","","",rspname);
+    GFilename filename = m_caldb.filename("","","IAQ","","",rspname);
  
     // If filename is empty then build filename from CALDB root path and
     // response name
-    if (filename.empty()) {
+    if (filename.is_empty()) {
         filename = gammalib::filepath(m_caldb.rootdir(), rspname);
-        if (!gammalib::file_exists(filename)) {
-            std::string testname = filename + ".fits";
-            if (gammalib::file_exists(testname)) {
+        if (!filename.exists()) {
+            GFilename testname = filename + ".fits";
+            if (testname.exists()) {
                 filename = testname;
             }
-            else {
-                std::string testname = filename + ".fits.gz";
-                if (gammalib::file_exists(testname)) {
-                    filename = testname;
-                }
-            }
         }
     }
  
@@ -642,10 +642,10 @@ void GCTAEventList::fetch(void) const
         if (!m_filename.is_empty()) {
  
             // Throw an exception if the file does not exist
-            if (!gammalib::file_exists_gzip(m_filename)) {
-                std::string msg = "File \""+m_filename+"\" not "
-                                  "found. Cannot fetch events. Maybe the "
-                                  "file has been deleted in the meantime.";
+            if (!m_filename.exists()) {
+                std::string msg = "File \""+m_filename+"\" not found. "
+                                  "Cannot fetch events. Maybe the file has "
+                                  "been deleted in the meantime.";
                 GException::file_error(G_FETCH, msg);
             }
  
@@ -1095,14 +1095,14 @@ void GCTAResponseIrf::load_aeff(const GFilename&amp; filename)
     m_aeff = NULL;
  
     // Check for existence of file
-    if (!gammalib::file_exists_gzip(filename)) {
+    if (!filename.exists()) {
         std::string msg = "File \""+filename+"\" not found. Please specify "
                           "a valid effective area response file.";
         throw GException::file_error(G_LOAD_AEFF, msg);
     }
  
     // If file is a FITS file ...
-    if (gammalib::is_fits(filename)) {
+    if (filename.is_fits()) {
  
         // Open FITS file
         GFits fits(filename);
@@ -1213,14 +1213,14 @@ void GCTAResponseIrf::load_psf(const GFilename&amp; filename)
     m_psf = NULL;
  
     // Check for existence of file
-    if (!gammalib::file_exists_gzip(filename)) {
+    if (!filename.exists()) {
         std::string msg = "File \""+filename+"\" not found. Please specify "
                           "a valid point spread function response file.";
         throw GException::file_error(G_LOAD_PSF, msg);
     }
  
     // If file is a FITS file ...
-    if (gammalib::is_fits(filename)) {
+    if (filename.is_fits()) {
  
         // Open FITS file
         GFits fits(filename);
@@ -1336,14 +1336,14 @@ void GCTAResponseIrf::load_edisp(const GFilename&amp; filename)
     m_edisp = NULL;
  
     // Check for existence of file
-    if (!gammalib::file_exists_gzip(filename)) {
+    if (!filename.exists()) {
         std::string msg = "File \""+filename+"\" not found. Please specify "
                           "a valid energy dispersion response file.";
         throw GException::file_error(G_LOAD_EDISP, msg);
     }
  
     // If file is a FITS file ...
-    if (gammalib::is_fits(filename)) {
+    if (filename.is_fits()) {
  
         // Open FITS file
         GFits fits(filename);
@@ -1441,14 +1441,14 @@ void GCTAResponseIrf::load_background(const GFilename&amp; filename)
     m_background = NULL;
  
     // Check for existence of file
-    if (!gammalib::file_exists_gzip(filename)) {
+    if (!filename.exists()) {
         std::string msg = "File \""+filename+"\" not found. Please specify "
                           "a valid background response file.";
         throw GException::file_error(G_LOAD_BACKGROUND, msg);
     }
  
     // If file is a FITS file than load background as 3D background
-    if (gammalib::is_fits(filename)) {
+    if (filename.is_fits()) {
         m_background = new GCTABackground3D(filename);
     }
  
@@ -2159,18 +2159,18 @@ void GCTAResponseIrf::free_members(void)
 std::string GCTAResponseIrf::irf_filename(const std::string& filename) const
 {
     // Set input filename as result filename
-    std::string result = filename;
+    GFilename result = filename;
  
     // If file does not exist then try a variant with extension .dat
-    if (!gammalib::file_exists(result)) {
-        std::string testname = result + ".dat";
-        if (gammalib::file_exists(testname)) {
+    if (!result.exists()) {
+        GFilename testname = filename + ".dat";
+        if (testname.exists()) {
             result = testname;
         }
     }
  
     // Return result
-    return result;
+    return (result.url());
 }
  
  
@@ -54,6 +54,9 @@ public:
     //std::string        protocol(void) const;
     //std::string        path(void) const;
     //std::string        file(void) const;
+    bool               exists(void) const;
+    bool               is_fits(void) const;
+    void               remove(void) const;
     std::string        extname(const std::string& defaultname = "") const;
     const std::string& expression(void) const;
     int                extno(const int& defaultno = -1) const;
@@ -62,12 +62,9 @@ namespace gammalib {
                                               const double& epivot,
                                               const double& gamma);
     GEnergy                  elogmean(const GEnergy& a, const GEnergy& b);
-    bool                     file_exists(const std::string& filename);
-    bool                     file_exists_gzip(const std::string& filename);
     bool                     dir_exists(const std::string& dirname);
     bool                     is_infinite(const double& x);
     bool                     is_notanumber(const double& x);
-    bool                     is_fits(const std::string& filename);
     bool                     contains(const std::string& str,
                                       const std::string& substring);
     void                     warning(const std::string& origin,
@@ -1213,7 +1213,7 @@ void GFits::save(const bool&amp; clobber)
  * @brief Saves to specified FITS file
  *
  * @param[in] filename Filename.
- * @param[in] clobber Overwrite existing FITS file (true/false).
+ * @param[in] clobber Overwrite existing FITS file? (default: false)
  *
  * @exception GException::fits_file_exist
  *            Specified file exists already. Overwriting requires
@@ -1233,23 +1233,12 @@ void GFits::saveto(const GFilename&amp; filename, const bool&amp; clobber)
               << " (size=" << size() << ") -->" << std::endl;
     #endif
  
-    // If overwriting has been specified then remove any existing file. We
-    // consider here also the possibility that the file is gzipped, but
-    // the file name does not contain the .gz extension.
+    // If overwriting has been specified then remove the file. Otherwise,
+    // throw an exception if the file exists.
     if (clobber) {
-        if (gammalib::file_exists(filename)) {
-            std::remove(filename.url().c_str());
-        }
-        else {
-            if (gammalib::file_exists(gzfname)) {
-                std::remove(gzfname.c_str());
-            }
-        }
+        filename.remove();
     }
-
-    // Otherwise, if file exists then throw an exception
-    else if (gammalib::file_exists(filename) ||
-             gammalib::file_exists(gzfname)) {
+    else if (filename.exists()) {
         throw GException::fits_file_exist(G_SAVETO, filename);
     }
  
@@ -454,29 +454,25 @@ void GCsv::load(const GFilename&amp; filename, const std::string&amp; sep)
  * @exception GException::file_error
  *            Unable to create file.
  *
- * Save CSV table into ASCII file. Any environment variable present in the
- * filename will be expanded.
+ * Save CSV table into ASCII file.
  **************************************************************************/
 void GCsv::save(const GFilename&   filename,
                 const std::string& sep,
                 const bool&        clobber) const
 {
     // Throw exception if file exists but clobber flag is false
-    if (!clobber && gammalib::file_exists(filename.url())) {
-        std::string msg = "File \""+filename.url()+"\" exists already but "
+    if (!clobber && filename.exists()) {
+        std::string msg = "File \""+filename+"\" exists already but "
                           "the clobber flag is set to \"false\". Set the "
                           "clobber flag to true to overwrite the existing "
                           "file or specify another file name.";
         throw GException::invalid_value(G_SAVE, msg);
     }
  
-    // Expand environment variables
-    std::string fname = gammalib::expand_env(filename.url());
-
     // Open CSV table (write-only)
-    FILE* fptr = std::fopen(fname.c_str(), "w");
+    FILE* fptr = std::fopen(filename.url().c_str(), "w");
     if (fptr == NULL) {
-        std::string msg = "Unable to create file \""+filename.url()+"\".";
+        std::string msg = "Unable to create file \""+filename+"\".";
         throw GException::file_error(G_SAVE, msg);
     }
  
@@ -28,6 +28,16 @@
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
+#if defined(HAVE_LIBCFITSIO)
+#if defined(HAVE_CFITSIO_FITSIO_H)
+#include <cfitsio/fitsio.h>
+#elif defined(HAVE_LIBCFITSIO0_FITSIO_H)
+#include <libcfitsio0/fitsio.h>
+#else
+#include <fitsio.h>
+#endif
+#endif
+#include <sys/stat.h>             // for stat structure and S_ISREG
 #include "GFilename.hpp"
 #include "GTools.hpp"
 #include "GException.hpp"
@@ -200,6 +210,108 @@ GFilename* GFilename::clone(void) const
  
  
 /***********************************************************************//**
+ * @brief Checks whether file exists
+ *
+ * @return True if file exists.
+ *
+ * Checks whether a file exists on disk. In case that the file is a FITS
+ * file, the method also checks whether a compressed version of the file
+ * (with a .gz, .Z, .z, or .zip extension) exists on disk (see is_fits()
+ * method).
+ ***************************************************************************/
+bool GFilename::exists(void) const
+{
+    // First check if file is a FITS file
+    bool exists = is_fits();
+
+    // If the file is not a FITS file, then check whether a file with the
+    // given name exists
+    if (!exists) {
+
+        // Allocate file information structure
+        struct stat info;
+
+        // Get file information structure
+        int ret = stat(url().c_str(), &info);
+
+        // If the file is a regular file then signal that it exists
+        if (ret == 0 && S_ISREG(info.st_mode)) {
+            exists = true;
+        }
+
+    } // endif: file was not a FITS file
+
+    // Return result
+    return (exists);
+}
+
+
+/***********************************************************************//**
+ * @brief Checks whether file is a FITS file
+ *
+ * @return True if file is a FITS file.
+ *
+ * Test if the file or a compressed version of the file (with a .gz, .Z, .z,
+ * or .zip extension) is a FITS file. 
+ ***************************************************************************/
+bool GFilename::is_fits(void) const
+{
+    // Initialise result
+    bool is_fits = false;
+
+    // Check now for a FITS file. This works only if cfitsio is available.
+    #if defined(HAVE_LIBCFITSIO)
+    int       status = 0;
+    fitsfile* fptr   = NULL;
+    status           = ffopen(&fptr, url().c_str(), 0, &status);
+    if (status == 0) {
+        is_fits = true;
+    }
+    ffclos(fptr, &status);
+    #endif
+
+    // Return result
+    return (is_fits);
+}
+
+
+/***********************************************************************//**
+ * @brief Remove file from disk
+ *
+ * Removes file or a compressed version of the file (with a .gz, .Z, .z,
+ * or .zip extension) if it exists on disk.
+ ***************************************************************************/
+void GFilename::remove(void) const
+{
+    // Set compressed file name variants
+    GFilename name_gz  = url()+".gz";
+    GFilename name_Z   = url()+".Z";
+    GFilename name_z   = url()+".z";
+    GFilename name_zip = url()+".zip";
+
+    // Remove file if one of the variants exists on disk
+    if (name_gz.exists()) {
+        std::remove(name_gz.url().c_str());
+    }
+    else if (name_Z.exists()) {
+        std::remove(name_Z.url().c_str());
+    }
+    else if (name_z.exists()) {
+        std::remove(name_z.url().c_str());
+    }
+    else if (name_zip.exists()) {
+        std::remove(name_zip.url().c_str());
+    }
+    else if (exists()) {
+        std::remove(url().c_str());
+    }
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
  * @brief Return extension name
  *
  * @param[in] defaultname Default extension name (default: "").
@@ -291,10 +403,14 @@ std::string GFilename::print(const GChatter&amp; chatter) const
         // Append header
         result.append("=== GFilename ===");
  
-        // Append file name
+        // Append filename
         result.append("\n"+gammalib::parformat("File name"));
         result.append(m_filename);
  
+        // Append URL
+        result.append("\n"+gammalib::parformat("URL"));
+        result.append(m_url);
+
         // Append extension name
         result.append("\n"+gammalib::parformat("Extension name"));
         if (has_extname()) {
@@ -350,8 +466,8 @@ std::string GFilename::print(const GChatter&amp; chatter) const
 void GFilename::init_members(void)
 {
     // Initialise members
-    m_fullname.clear();
     m_filename.clear();
+    m_url.clear();
     m_extname.clear();
     m_extno  = -1;
     m_extver = 0;
@@ -370,8 +486,8 @@ void GFilename::init_members(void)
 void GFilename::copy_members(const GFilename& filename)
 {
     // Copy members
-    m_fullname   = filename.m_fullname;
     m_filename   = filename.m_filename;
+    m_url        = filename.m_url;
     m_extname    = filename.m_extname;
     m_extno      = filename.m_extno;
     m_extver     = filename.m_extver;
@@ -414,47 +530,47 @@ void GFilename::set_filename(const std::string&amp; filename)
     clear();
  
     // Strip any whitespace and store the full name
-    m_fullname = gammalib::strip_whitespace(filename);
+    m_filename = gammalib::strip_whitespace(filename);
  
     // Continue only if filename is not empty
-    if (!m_fullname.empty()) {
+    if (!m_filename.empty()) {
  
         // Check for [ symbol in filename
-        size_t start = m_fullname.find_first_of("[");
+        size_t start = m_filename.find_first_of("[");
  
         // If we have an extension then separate filename into filename
         // part and extension part and fill the information of th object
         if (start != std::string::npos) {
  
             // Check for ] symbol in filename
-            size_t stop = m_fullname.find_first_of("]", start);
+            size_t stop = m_filename.find_first_of("]", start);
  
             // If there is no ] symbol then throw an exception
             if (stop == std::string::npos) {
                 std::string msg = "Missing ] symbol in file name \""+
-                                  m_fullname+"\" extension. Please correct "
+                                  m_filename+"\" extension. Please correct "
                                   "the file name.";
                 throw GException::invalid_argument(G_SET_FILENAME, msg);
             }
  
             // If ] is not the last character then check if an opening bracket is next
-            if (stop < m_fullname.length()-1) {
+            if (stop < m_filename.length()-1) {
  
                 // Get character
-                std::string character = gammalib::strip_whitespace(m_fullname.substr(stop+1,1));
+                std::string character = gammalib::strip_whitespace(m_filename.substr(stop+1,1));
  
                 // If no bracket is coming, throw an exception
                 if (character != "[") {
                     std::string msg = "Non-bracket character \""+character+
                                       "\" beyond ] symbol in file name \""+
-                                      m_fullname+"\" expression. Please "
+                                      m_filename+"\" expression. Please "
                                       "correct the file name.";
                     throw GException::invalid_argument(G_SET_FILENAME, msg);
                 }
              }
  
             // Extract extension name
-            std::string extname = gammalib::strip_whitespace(m_fullname.substr(start+1, stop-start-1));
+            std::string extname = gammalib::strip_whitespace(m_filename.substr(start+1, stop-start-1));
  
             // Check if there is a , symbol that separates extension name
             // and extension version
@@ -469,7 +585,7 @@ void GFilename::set_filename(const std::string&amp; filename)
                 // If string is empty then throw an exception
                 if (extver.empty()) {
                     std::string msg = "No extension version found after , "
-                                      "symbol in file name \""+m_fullname+
+                                      "symbol in file name \""+m_filename+
                                       "\". Please correct the file name.";
                     throw GException::invalid_argument(G_SET_FILENAME, msg);
                 }
@@ -482,7 +598,7 @@ void GFilename::set_filename(const std::string&amp; filename)
                 if (m_extver <= 0) {
                     std::string msg = "Non-positive extension version "
                                       "encountered in file name \""+
-                                      m_fullname+ "\". Please correct the "
+                                      m_filename+ "\". Please correct the "
                                       "file name.";
                     throw GException::invalid_argument(G_SET_FILENAME, msg);
                 }
@@ -495,7 +611,7 @@ void GFilename::set_filename(const std::string&amp; filename)
             // If we have an empty extension name then throw an exception
             if (extname.empty()) {
                 std::string msg = "An empty extension has been specified in "
-                                  "file name \""+m_fullname+"\". Please "
+                                  "file name \""+m_filename+"\". Please "
                                   "correct the file name.";
                 throw GException::invalid_argument(G_SET_FILENAME, msg);
             }
@@ -511,7 +627,7 @@ void GFilename::set_filename(const std::string&amp; filename)
                 // positive
                 if (m_extno < 0) {
                     std::string msg = "Negative extension number encountered "
-                                      "in file name \""+m_fullname+"\". "
+                                      "in file name \""+m_filename+"\". "
                                       "Please correct the file name.";
                     throw GException::invalid_argument(G_SET_FILENAME, msg);
                 }
@@ -527,7 +643,7 @@ void GFilename::set_filename(const std::string&amp; filename)
                 // Throw an exception if extension name is empty
                 if (m_extname.empty()) {
                     std::string msg = "Empty extension name encountered "
-                                      "in file name \""+m_fullname+"\". "
+                                      "in file name \""+m_filename+"\". "
                                       "Please correct the file name.";
                     throw GException::invalid_argument(G_SET_FILENAME, msg);
                 }
@@ -535,41 +651,41 @@ void GFilename::set_filename(const std::string&amp; filename)
             } // endelse: extension name provided
  
             // Store the file name
-            m_filename = gammalib::strip_whitespace(m_fullname.substr(0,start));
+            m_url = gammalib::strip_whitespace(m_filename.substr(0,start));
  
             // Check if there is an expression behind the extension name
-            size_t expr_start = m_fullname.find_first_of("[", stop+1);
+            size_t expr_start = m_filename.find_first_of("[", stop+1);
  
             if (expr_start != std::string::npos) {
  
                // Check for ] symbol in expression
-               size_t expr_stop = m_fullname.find_first_of("]", expr_start);
+               size_t expr_stop = m_filename.find_first_of("]", expr_start);
  
                // If there is no ] symbol then throw an exception
                if (expr_stop == std::string::npos) {
                    std::string msg = "Missing ] symbol in file name \""+
-                                     m_fullname+"\" expression. Please "
+                                     m_filename+"\" expression. Please "
                                      "correct the file name.";
                    throw GException::invalid_argument(G_SET_FILENAME, msg);
                }
  
                // If ] is not the last character then throw an exception
-               if (expr_stop < m_fullname.length()-1) {
+               if (expr_stop < m_filename.length()-1) {
                    std::string msg = "Characters beyond ] symbol in file "
-                                     "name \""+m_fullname+"\" expression. "
+                                     "name \""+m_filename+"\" expression. "
                                      "Please correct the file name.";
                    throw GException::invalid_argument(G_SET_FILENAME, msg);
                 }
  
                // Store expression
-               m_expression = gammalib::strip_whitespace(m_fullname.substr(expr_start+1, expr_stop - expr_start-1));
+               m_expression = gammalib::strip_whitespace(m_filename.substr(expr_start+1, expr_stop - expr_start-1));
             }
  
         } // endif: had extension
  
         // ... otherwise simply set the filename
         else {
-            m_filename = m_fullname;
+            m_url = m_filename;
         }
  
     } // endif: filename was not empty
@@ -1002,58 +1002,6 @@ GEnergy gammalib::elogmean(const GEnergy&amp; a, const GEnergy&amp; b)
  
  
 /***********************************************************************//**
- * @brief Checks if file exists
- *
- * @param[in] filename File name.
- * @return True if file exists, false otherwise.
- *
- * Checks if a file exists. If a directory with the same name is found, false
- * is returned. The function expands any environment variable prior to
- * checking.
- ***************************************************************************/
-bool gammalib::file_exists(const std::string& filename)
-{
-    // Initialise result
-    bool result = false;
-
-    // Allocate file information structure
-    struct stat info;
-
-    // Get file information structure
-    int ret = stat(gammalib::expand_env(filename).c_str(), &info);
-
-    // Check if file is a regular file
-    if (ret == 0 && S_ISREG(info.st_mode)) {
-        result = true;
-    }
-
-    // Return result
-    return result;
-}
-
-
-/***********************************************************************//**
- * @brief Checks if either uncompressed or compressed file exists
- *
- * @param[in] filename Uncompressed file name (withput ".gz" extension)
- * @return True if file exists, false otherwise.
- *
- * Checks if a file exists, either as an uncompressed file or with a ".gz"
- * extension. If a directory with the same name is found, false is returned.
- * The function expands any environment variable prior to checking.
- ***************************************************************************/
-bool gammalib::file_exists_gzip(const std::string& filename)
-{
-    // Get result
-    bool result = gammalib::file_exists(filename) ||
-                  gammalib::file_exists(filename+".gz");
-
-    // Return result
-    return result;
-}
-
-
-/***********************************************************************//**
  * @brief Checks if directory exists
  *
  * @param[in] dirname Directory name.
@@ -1084,41 +1032,6 @@ bool gammalib::dir_exists(const std::string&amp; dirname)
  
  
 /***********************************************************************//**
- * @brief Checks if file is a FITS file
- *
- * @param[in] filename File name.
- * @return True if file is a FITS file.
- *
- * Checks if the specified file is a FITS file.
- ***************************************************************************/
-bool gammalib::is_fits(const std::string& filename)
-{
-    // Initialise result
-    bool result = false;
-
-    // Try opening file
-    try {
-
-        // Open file
-        GFits fits(filename);
-
-        // If we're still alive then close file and set result to true
-        fits.close();
-        result = true;
-
-    }
-
-    // Catch any exceptions
-    catch (...) {
-        ;
-    }
-
-    // Return result
-    return result;
-}
-
-
-/***********************************************************************//**
  * @brief Checks if a substring is in a string
  *
  * @param[in] str string you want to search in.
 /***************************************************************************
  *                          GXml.cpp - XML class                           *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2015 by Juergen Knoedlseder                         *
+ *  copyright (C) 2010-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -518,9 +518,9 @@ const GXmlElement* GXml::element(const std::string&amp; name, const int&amp; index) cons
  ***************************************************************************/
 void GXml::load(const GFilename& filename)
 {
-    // Check if file exists
-    if (!gammalib::file_exists(filename.url())) {
-        throw GException::file_open_error(G_LOAD, filename.url());
+    // Throw an exception if file does not exist
+    if (!filename.exists()) {
+        throw GException::file_open_error(G_LOAD, filename);
     }
  
     // Open XML URL as file for reading