file.cc

Go to the documentation of this file.

/* Copyright (C) 2000-2008 Stefan Buehler <sbuehler@ltu.se>

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. */


//   File description


//   External declarations

#include <stdexcept>
#include <cmath>
#include <cfloat>
#include "arts.h"
#include "matpackI.h"
#include "array.h"
#include "messages.h"
#include "parameters.h"
#include "file.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 String& name)
{
  // 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);
  
  // c_str explicitly converts to c String.
  file.open(name.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().)
  if (!file)
    {
      ostringstream os;
      os << "Cannot open output file: " << name << '\n'
         << "Maybe you don't have write access "
         << "to the directory or the file?";
      throw runtime_error(os.str());
    }
}




void open_input_file(ifstream& file, const String& name)
{
  // 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(name.c_str() );

  // See if the file is ok.
  // FIXME: This should not be necessary anymore in the future, when
  // g++ stream exceptions work properly.
  if (!file)
    {
      ostringstream os;
      os << "Cannot open input file: " << name << '\n'
         << "Maybe the file does not exist?";
      throw runtime_error(os.str());
    }
}




void read_text_from_stream(ArrayOfString& text, istream& is)
{
  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.
  if ( !is.eof() ) {
    ostringstream os;
    os << "Read Error. Last line read:\n" << linebuffer;
    throw runtime_error(os.str());
  }

}




void read_text_from_file(ArrayOfString& text, const String& name)
{
  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
    {
      read_text_from_stream(text,ifs);
    }
  catch (runtime_error x)
    {
      ostringstream os;
      os << "Error reading file: " << name << '\n'
         << x.what();
      throw runtime_error(os.str());
    }
}



void replace_all(String& s, const String& what, const String& 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 String& 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) 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 String& filename)
{
    bool exists = false;
    fstream fin;
    fin.open(filename.c_str(), ios::in);
    if (fin.is_open())
    {
      exists=true;
    }
    fin.close();
    return exists;
}



bool find_file(String& filename, const char* extension)
{
  bool exists = true;
  extern const Parameters parameters;

  if (!file_exists (filename))
    {
      if (file_exists (filename + extension))
        {
          filename += extension;
        }
      else
        {
          Index i;
          for (i=0; i < parameters.includepath.nelem(); i++)
            {
              String fullpath;
              fullpath = parameters.includepath[i] + "/" + filename;
              if (file_exists (fullpath))
                {
                  filename = fullpath;
                  break;
                }
              else if (file_exists (fullpath + extension))
                {
                  filename = fullpath + extension;
                  break;
                }
            }
          if (i == parameters.includepath.nelem())
            {
              exists = false;
            }
        }
    }

  return exists;
}

---