file.cc

Go to the documentation of this file.

 
//   File description
 
//   External declarations
 
#include "arts.h"
 
#include <algorithm>
#include <cstdlib>
#include <filesystem>
#include <stdexcept>
 
#include "array.h"
#include "file.h"
#include "parameters.h"
 
//   Default file names
 
void filename_ascii(String& filename, const String& varname) {
  if ("" == filename) {
    extern const String out_basename;
    filename = out_basename + "." + varname + ".aa";
  }
}
 
//   Functions to open and read ASCII files
 
void open_output_file(ofstream& file, const std::string_view name) {
  String ename = add_basedir(name);
 
  try {
    // Tell the stream that it should throw exceptions.
    // Badbit means that the entire stream is corrupted, failbit means
    // that the last operation has failed, but the stream is still
    // valid. We don't want either to happen!
    // FIXME: This does not yet work in  egcs-2.91.66, try again later.
    file.exceptions(ios::badbit | ios::failbit);
 
    file.open(ename.c_str());
 
    // See if the file is ok.
    // FIXME: This should not be necessary anymore in the future, when
    // g++ stream exceptions work properly. (In that case we would not
    // get here if there really was a problem, because of the exception
    // thrown by open().)
  } catch (const std::exception& e) {
    ARTS_USER_ERROR(
        "Cannot open output file: ",
        ename,
        "\nMaybe you don't have write access to the directory or the file?");
  }
}
 
void cleanup_output_file(ofstream& file, const std::string_view name) {
  if (file.is_open()) {
    streampos fpos = file.tellp();
    file.close();
    if (!fpos) std::filesystem::remove(expand_path(name).c_str());
  }
}
 
void open_input_file(ifstream& file, const std::string_view name) {
  String ename{expand_path(name)};
 
  // Command line parameters which give us the include search path.
  extern const Parameters parameters;
  ArrayOfString allpaths = parameters.includepath;
  allpaths.insert(
      allpaths.end(), parameters.datapath.begin(), parameters.datapath.end());
 
  ArrayOfString matching_files;
  find_file(matching_files, ename, allpaths);
 
  if (matching_files.nelem()) ename = matching_files[0];
 
  // Tell the stream that it should throw exceptions.
  // Badbit means that the entire stream is corrupted.
  // On the other hand, end of file will not lead to an exception, you
  // have to check this manually!
  file.exceptions(ios::badbit);
 
  // c_str explicitly converts to c String.
  file.open(ename.c_str());
 
  // See if the file is ok.
  // FIXME: This should not be necessary anymore in the future, when
  // g++ stream exceptions work properly.
  ARTS_USER_ERROR_IF(!file,
                     "Cannot open input file: ",
                     ename,
                     "\nMaybe the file does not exist?");
}
 
ArrayOfString read_text_from_stream(istream& is) {
  ArrayOfString text;
  String linebuffer;
 
  // Read as long as `is' is good.
  // Contary to what I understood from the book, the explicit check
  // for eof is necessary here, otherwise the last line is read twice
  // if it is not terminated by a newline character!
  while (is && is.good() && !is.eof()) {
    // Read line from file into linebuffer:
    getline(is, linebuffer);
 
    // Append to end of text:
    text.push_back(linebuffer);
  }
 
  // Check for error:
  // FIXME: This should not be necessary anymore when stream
  // exceptions work properly.
  ARTS_USER_ERROR_IF(!is.eof(), "Read Error. Last line read:\n", linebuffer);
 
  return text;
}
 
ArrayOfString read_text_from_file(const std::string_view name) {
  ArrayOfString text{};
  ifstream ifs;
 
  // Open input stream:
  open_input_file(ifs, name);
  // No need to check for error, because open_input_file throws a
  // runtime_error with an appropriate error message.
 
  // Read the text from the stream. Here we catch the exception,
  // because then we can issue a nicer error message that includes the
  // filename.
  try {
    text = read_text_from_stream(ifs);
  } catch (const std::runtime_error& x) {
    ARTS_USER_ERROR("Error reading file: ", name, "\n", x.what());
  }
 
  return text;
}
 
void replace_all(String& s, const std::string_view what, const std::string_view with) {
  Index j = s.find(what);
  while (j != s.npos) {
    s.replace(j, 1, with);
    j = s.find(what, j + with.size());
  }
}
 
int check_newline(const std::string_view s) {
  String d = s;
  int result = 0;
 
  // Remove all whitespaces except \n
  replace_all(d, " ", "");
  replace_all(d, "\t", "");
  replace_all(d, "\r", "");
 
  const char* cp = d.c_str();
  while (*cp == '\n') cp++;
 
  if (!(*cp)) result = 1;
 
  if (!result && d[d.length() - 1] != '\n')
    result = 2;
  else if (!result && d.length() > 2 && d[d.length() - 1] == '\n' &&
           d[d.length() - 2] == '\n')
    result = 3;
 
  return result;
}
 
bool file_exists(const std::string_view filename) {
  return std::filesystem::exists(filename) &&
         !std::filesystem::is_directory(filename);
}
 
bool find_file(ArrayOfString& matches,
               const std::string_view filename,
               const ArrayOfString& paths,
               const ArrayOfString& extensions) {
  bool exists = false;
  std::string efilename{expand_path(filename)};
 
  // filename contains full path
  if (!paths.nelem() || std::filesystem::path(efilename).is_absolute()) {
    for (const auto& ext : extensions) {
      const String fullpath{efilename + ext};
 
      if (file_exists(fullpath)) {
        if (std::find(matches.begin(), matches.end(), fullpath) ==
            matches.end())
          matches.push_back(fullpath);
        exists = true;
      }
    }
  }
  // filename contains no or relative path
  else {
    for (const auto& path : paths) {
      for (const auto& ext : extensions) {
        const String fullpath{expand_path(path) + "/" + efilename + ext};
 
        if (file_exists(fullpath)) {
          if (std::find(matches.begin(), matches.end(), fullpath) ==
              matches.end())
            matches.push_back(fullpath);
          exists = true;
        }
      }
    }
  }
 
  return exists;
}
 
void find_xml_file(String& filename, const Verbosity& verbosity) {
  // Command line parameters which give us the include search path.
  extern const Parameters parameters;
  ArrayOfString allpaths = parameters.includepath;
  allpaths.insert(
      allpaths.end(), parameters.datapath.begin(), parameters.datapath.end());
 
  ArrayOfString matching_files;
  find_file(matching_files, filename, allpaths, {"", ".xml", ".gz", ".xml.gz"});
 
  ARTS_USER_ERROR_IF(!matching_files.nelem(),
                     "Cannot find input file: ",
                     filename,
                     "\nSearch path: ",
                     allpaths);
 
  if (matching_files.nelem() > 1) {
    CREATE_OUT1;
    out1
        << "  WARNING: More than one file matching this name exists in the data path.\n"
        << "  Using the first file (1) found:\n";
    for (Index i = 0; i < matching_files.nelem(); i++)
      out1 << "  (" << i + 1 << ") " << matching_files[i] << "\n";
  }
 
  filename = matching_files[0];
}
 
bool find_xml_file_existence(String& filename) {
  // Command line parameters which give us the include search path.
  extern const Parameters parameters;
  ArrayOfString allpaths = parameters.includepath;
  allpaths.insert(
    allpaths.end(), parameters.datapath.begin(), parameters.datapath.end());
  
  ArrayOfString matching_files;
  find_file(matching_files, filename, allpaths, {"", ".xml", ".gz", ".xml.gz"});
  
  if (matching_files.nelem()) {
    filename = matching_files[0];
    return true;
  }
 
  return false;
}
 
String expand_path(String path) {
  if ((path.length() == 1 && path[0] == '~') ||
      (path.length() > 1 && path[0] == '~' && path[1] == '/')) {
    path = String(std::getenv("HOME")) + String(path, 1);
  }
 
  return path;
}
 
String add_basedir(const std::string_view path) {
  extern const Parameters parameters;
  String expanded_path{expand_path(path)};
 
  if (parameters.outdir.nelem() && path.length() && path[0] != '/') {
    expanded_path = parameters.outdir + '/' + expanded_path;
  }
 
  return expanded_path;
}
 
 
String get_dirname(const std::string_view path) {
  String dirname{};
  if (!path.length()) return dirname;
 
  ArrayOfString fileparts;
  String{path}.split(fileparts, "/");
  if (path[0] == '/') dirname = "/";
  if (fileparts.nelem() > 1) {
    for (Index i = 0; i < fileparts.nelem() - 1; i++) {
      dirname += fileparts[i];
      if (i < fileparts.nelem() - 2) dirname += "/";
    }
  }
 
  return dirname;
}
 
 
ArrayOfString list_directory(const std::string_view dirname) {
  ARTS_USER_ERROR_IF(!std::filesystem::is_directory(dirname),
                     "Error accessing directory: ",
                     dirname)
 
  ArrayOfString files{};
  for (const auto& filename :
       std::filesystem::directory_iterator{dirname}) {
    files.push_back(filename.path().string());
  }
 
  return files;
}
 
String make_filename_unique(const std::string_view filename, const String& extension) {
  String basename = filename;
  String extensionname;
 
  // Split filename into base and extension
  if (extension.length()) {
    size_t pos = filename.rfind(extension);
    if (pos == filename.length() - extension.length()) {
      basename = filename.substr(0, filename.length() - extension.length());
      extensionname = extension;
    }
  }
 
  Index filenumber = 0;
  ostringstream newfilename;
  newfilename << basename << extensionname;
 
  while (file_exists(newfilename.str()) ||
         file_exists(newfilename.str() + ".gz")) {
    filenumber++;
    newfilename.str("");
    newfilename << basename << "." << filenumber << extensionname;
  }
 
  return newfilename.str();
}