src/gromacs/utility/filestream.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2015, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Implements classes from filestream.h.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_utility
  41  */
  42 #include "gmxpre.h"
  43
  44 #include "filestream.h"
  45
  46 #include "config.h"
  47
  48 #include <cerrno>
  49 #include <cstdio>
  50
  51 #ifdef HAVE_UNISTD_H
  52 #include <unistd.h>
  53 #endif
  54
  55 #include "gromacs/utility/exceptions.h"
  56 #include "gromacs/utility/gmxassert.h"
  57 #include "gromacs/utility/stringutil.h"
  58
  59 namespace gmx
  60 {
  61
  62 namespace
  63 {
  64
  65 //! Helper function for implementing readLine() for input streams.
  66 bool readLineImpl(FILE *fp, std::string *line)
  67 {
  68     line->clear();
  69     const size_t bufsize = 256;
  70     std::string  result;
  71     char         buf[bufsize];
  72     buf[0] = '\0';
  73     while (std::fgets(buf, bufsize, fp) != NULL)
  74     {
  75         const size_t length = std::strlen(buf);
  76         result.append(buf, length);
  77         if (length < bufsize - 1 || buf[length - 1] == '\n')
  78         {
  79             break;
  80         }
  81     }
  82     if (std::ferror(fp))
  83     {
  84         GMX_THROW_WITH_ERRNO(FileIOError("Error while reading file"),
  85                              "fgets", errno);
  86     }
  87     *line = result;
  88     return !result.empty() || !std::feof(fp);
  89 }
  90
  91 }   // namespace
  92
  93 namespace internal
  94 {
  95
  96 /********************************************************************
  97  * FileStreamImpl
  98  */
  99
 100 class FileStreamImpl
 101 {
 102     public:
 103         explicit FileStreamImpl(FILE *fp)
 104             : fp_(fp), bClose_(false)
 105         {
 106         }
 107         FileStreamImpl(const char *filename, const char *mode)
 108             : fp_(NULL), bClose_(true)
 109         {
 110             fp_ = std::fopen(filename, mode);
 111             if (fp_ == NULL)
 112             {
 113                 GMX_THROW_WITH_ERRNO(
 114                         FileIOError(formatString("Could not open file '%s'", filename)),
 115                         "fopen", errno);
 116             }
 117         }
 118         ~FileStreamImpl()
 119         {
 120             if (fp_ != NULL && bClose_)
 121             {
 122                 if (std::fclose(fp_) != 0)
 123                 {
 124                     // TODO: Log the error somewhere
 125                 }
 126             }
 127         }
 128
 129         FILE *handle()
 130         {
 131             GMX_RELEASE_ASSERT(fp_ != NULL,
 132                                "Attempted to access a file object that is not open");
 133             return fp_;
 134         }
 135
 136         void close()
 137         {
 138             GMX_RELEASE_ASSERT(fp_ != NULL,
 139                                "Attempted to close a file object that is not open");
 140             GMX_RELEASE_ASSERT(bClose_,
 141                                "Attempted to close a file object that should not be");
 142             const bool bOk = (std::fclose(fp_) == 0);
 143             fp_ = NULL;
 144             if (!bOk)
 145             {
 146                 GMX_THROW_WITH_ERRNO(
 147                         FileIOError("Error while closing file"), "fclose", errno);
 148             }
 149         }
 150
 151     private:
 152         //! File handle for this object (NULL if the stream has been closed).
 153         FILE  *fp_;
 154         //! Whether \p fp_ should be closed by this object.
 155         bool   bClose_;
 156 };
 157
 158 }   // namespace internal
 159
 160 using internal::FileStreamImpl;
 161
 162 /********************************************************************
 163  * StandardInputStream
 164  */
 165
 166 bool StandardInputStream::isInteractive() const
 167 {
 168 #ifdef HAVE_UNISTD_H
 169     return isatty(fileno(stdin));
 170 #else
 171     return true;
 172 #endif
 173 }
 174
 175 bool StandardInputStream::readLine(std::string *line)
 176 {
 177     return readLineImpl(stdin, line);
 178 }
 179
 180 // static
 181 StandardInputStream &StandardInputStream::instance()
 182 {
 183     static StandardInputStream stdinObject;
 184     return stdinObject;
 185 }
 186
 187 /********************************************************************
 188  * TextInputFile
 189  */
 190
 191 // static
 192 FILE *TextInputFile::openRawHandle(const char *filename)
 193 {
 194     FILE *fp = fopen(filename, "r");
 195     if (fp == NULL)
 196     {
 197         GMX_THROW_WITH_ERRNO(
 198                 FileIOError(formatString("Could not open file '%s'", filename)),
 199                 "fopen", errno);
 200     }
 201     return fp;
 202 }
 203
 204 // static
 205 FILE *TextInputFile::openRawHandle(const std::string &filename)
 206 {
 207     return openRawHandle(filename.c_str());
 208 }
 209
 210 TextInputFile::TextInputFile(const std::string &filename)
 211     : impl_(new FileStreamImpl(filename.c_str(), "r"))
 212 {
 213 }
 214
 215 TextInputFile::TextInputFile(FILE *fp)
 216     : impl_(new FileStreamImpl(fp))
 217 {
 218 }
 219
 220 TextInputFile::~TextInputFile()
 221 {
 222 }
 223
 224 FILE *TextInputFile::handle()
 225 {
 226     return impl_->handle();
 227 }
 228
 229 bool TextInputFile::readLine(std::string *line)
 230 {
 231     return readLineImpl(impl_->handle(), line);
 232 }
 233
 234 void TextInputFile::close()
 235 {
 236     impl_->close();
 237 }
 238
 239 /********************************************************************
 240  * TextOutputFile
 241  */
 242
 243 TextOutputFile::TextOutputFile(const std::string &filename)
 244     : impl_(new FileStreamImpl(filename.c_str(), "w"))
 245 {
 246 }
 247
 248 TextOutputFile::TextOutputFile(FILE *fp)
 249     : impl_(new FileStreamImpl(fp))
 250 {
 251 }
 252
 253 TextOutputFile::~TextOutputFile()
 254 {
 255 }
 256
 257 void TextOutputFile::write(const char *str)
 258 {
 259     if (std::fprintf(impl_->handle(), "%s", str) < 0)
 260     {
 261         GMX_THROW_WITH_ERRNO(FileIOError("Writing to file failed"),
 262                              "fprintf", errno);
 263     }
 264 }
 265
 266 void TextOutputFile::close()
 267 {
 268     impl_->close();
 269 }
 270
 271 // static
 272 TextOutputFile &TextOutputFile::standardOutput()
 273 {
 274     static TextOutputFile stdoutObject(stdout);
 275     return stdoutObject;
 276 }
 277
 278 // static
 279 TextOutputFile &TextOutputFile::standardError()
 280 {
 281     static TextOutputFile stderrObject(stderr);
 282     return stderrObject;
 283 }
 284
 285 } // namespace gmx