src/gromacs/utility/textwriter.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2015,2016,2017, 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 gmx::TextWriter.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_utility
  41  */
  42 #include "gmxpre.h"
  43
  44 #include "textwriter.h"
  45
  46 #include <cstring>
  47
  48 #include "gromacs/utility/filestream.h"
  49 #include "gromacs/utility/nodelete.h"
  50 #include "gromacs/utility/stringutil.h"
  51 #include "gromacs/utility/textstream.h"
  52
  53 namespace gmx
  54 {
  55
  56 class TextWriter::Impl
  57 {
  58     public:
  59         explicit Impl(const TextOutputStreamPointer &stream)
  60             : stream_(stream), newLineCount_(2), currentLineLength_(0),
  61               pendingNewLine_(false)
  62         {
  63             wrapper_.settings().setKeepFinalSpaces(true);
  64         }
  65
  66         void writeRawString(const char *str)
  67         {
  68             if (pendingNewLine_ && str[0] != '\n')
  69             {
  70                 stream_->write("\n");
  71             }
  72             pendingNewLine_ = false;
  73             const char *lastNewLine = std::strrchr(str, '\n');
  74             if (lastNewLine == nullptr)
  75             {
  76                 newLineCount_       = 0;
  77                 currentLineLength_ += std::strlen(str);
  78             }
  79             else if (lastNewLine[1] != '\0')
  80             {
  81                 newLineCount_       = 0;
  82                 currentLineLength_ += std::strlen(lastNewLine+1);
  83             }
  84             else
  85             {
  86                 currentLineLength_ = 0;
  87                 int newLineCount   = 0;
  88                 while (lastNewLine >= str && *lastNewLine == '\n')
  89                 {
  90                     ++newLineCount;
  91                     --lastNewLine;
  92                 }
  93                 if (lastNewLine >= str)
  94                 {
  95                     newLineCount_ = 0;
  96                 }
  97                 newLineCount_ += newLineCount;
  98             }
  99             stream_->write(str);
 100         }
 101         void writeRawString(const std::string &str)
 102         {
 103             writeRawString(str.c_str());
 104         }
 105
 106         void writeWrappedString(const std::string &str)
 107         {
 108             if (newLineCount_ > 0)
 109             {
 110                 writeRawString(wrapper_.wrapToString(str));
 111             }
 112             else
 113             {
 114                 writeRawString(str);
 115             }
 116         }
 117
 118         TextOutputStreamPointer stream_;
 119         TextLineWrapper         wrapper_;
 120         int                     newLineCount_;
 121         int                     currentLineLength_;
 122         bool                    pendingNewLine_;
 123 };
 124
 125 // static
 126 void TextWriter::writeFileFromString(const std::string &filename,
 127                                      const std::string &text)
 128 {
 129     TextWriter file(filename);
 130     file.writeString(text);
 131     file.close();
 132 }
 133
 134 TextWriter::TextWriter(const std::string &filename)
 135     : impl_(new Impl(TextOutputStreamPointer(new TextOutputFile(filename))))
 136 {
 137 }
 138
 139 TextWriter::TextWriter(FILE *fp)
 140     : impl_(new Impl(TextOutputStreamPointer(new TextOutputFile(fp))))
 141 {
 142 }
 143
 144 TextWriter::TextWriter(TextOutputStream *stream)
 145     : impl_(new Impl(TextOutputStreamPointer(stream, no_delete<TextOutputStream>())))
 146 {
 147 }
 148
 149 TextWriter::TextWriter(const TextOutputStreamPointer &stream)
 150     : impl_(new Impl(stream))
 151 {
 152 }
 153
 154 TextWriter::~TextWriter()
 155 {
 156 }
 157
 158 TextLineWrapperSettings &TextWriter::wrapperSettings()
 159 {
 160     return impl_->wrapper_.settings();
 161 }
 162
 163 void TextWriter::writeString(const char *str)
 164 {
 165     if (impl_->wrapper_.isTrivial())
 166     {
 167         impl_->writeRawString(str);
 168     }
 169     else
 170     {
 171         impl_->writeWrappedString(str);
 172     }
 173 }
 174
 175 void TextWriter::writeString(const std::string &str)
 176 {
 177     impl_->writeWrappedString(str);
 178 }
 179
 180 void TextWriter::writeLine(const char *line)
 181 {
 182     writeString(line);
 183     ensureLineBreak();
 184 }
 185
 186 void TextWriter::writeLine(const std::string &line)
 187 {
 188     writeString(line);
 189     ensureLineBreak();
 190 }
 191
 192 void TextWriter::writeLine()
 193 {
 194     impl_->writeRawString("\n");
 195 }
 196
 197 void TextWriter::ensureLineBreak()
 198 {
 199     if (impl_->newLineCount_ == 0)
 200     {
 201         impl_->writeRawString("\n");
 202     }
 203 }
 204
 205 void TextWriter::ensureEmptyLine()
 206 {
 207     ensureLineBreak();
 208     if (impl_->newLineCount_ < 2)
 209     {
 210         impl_->pendingNewLine_ = true;
 211     }
 212 }
 213
 214 void TextWriter::close()
 215 {
 216     impl_->stream_->close();
 217 }
 218
 219 } // namespace gmx