src/gromacs/utility/textwriter.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2015,2016,2017,2018,2019, 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),
  61         newLineCount_(2),
  62         currentLineLength_(0),
  63         pendingNewLine_(false)
  64     {
  65         wrapper_.settings().setKeepFinalSpaces(true);
  66     }
  67
  68     void writeRawString(const char* str)
  69     {
  70         if (pendingNewLine_ && str[0] != '\n')
  71         {
  72             stream_->write("\n");
  73         }
  74         pendingNewLine_         = false;
  75         const char* lastNewLine = std::strrchr(str, '\n');
  76         if (lastNewLine == nullptr)
  77         {
  78             newLineCount_ = 0;
  79             currentLineLength_ += std::strlen(str);
  80         }
  81         else if (lastNewLine[1] != '\0')
  82         {
  83             newLineCount_ = 0;
  84             currentLineLength_ += std::strlen(lastNewLine + 1);
  85         }
  86         else
  87         {
  88             currentLineLength_ = 0;
  89             int newLineCount   = 0;
  90             while (lastNewLine >= str && *lastNewLine == '\n')
  91             {
  92                 ++newLineCount;
  93                 --lastNewLine;
  94             }
  95             if (lastNewLine >= str)
  96             {
  97                 newLineCount_ = 0;
  98             }
  99             newLineCount_ += newLineCount;
 100         }
 101         stream_->write(str);
 102     }
 103     void writeRawString(const std::string& str) { writeRawString(str.c_str()); }
 104
 105     void writeWrappedString(const std::string& str)
 106     {
 107         if (newLineCount_ > 0)
 108         {
 109             writeRawString(wrapper_.wrapToString(str));
 110         }
 111         else
 112         {
 113             writeRawString(str);
 114         }
 115     }
 116
 117     TextOutputStreamPointer stream_;
 118     TextLineWrapper         wrapper_;
 119     int                     newLineCount_;
 120     int                     currentLineLength_;
 121     bool                    pendingNewLine_;
 122 };
 123
 124 // static
 125 void TextWriter::writeFileFromString(const std::string& filename, const std::string& text)
 126 {
 127     TextWriter file(filename);
 128     file.writeString(text);
 129     file.close();
 130 }
 131
 132 TextWriter::TextWriter(const std::string& filename) :
 133     impl_(new Impl(TextOutputStreamPointer(new TextOutputFile(filename))))
 134 {
 135 }
 136
 137 TextWriter::TextWriter(FILE* fp) : impl_(new Impl(TextOutputStreamPointer(new TextOutputFile(fp))))
 138 {
 139 }
 140
 141 TextWriter::TextWriter(TextOutputStream* stream) :
 142     impl_(new Impl(TextOutputStreamPointer(stream, no_delete<TextOutputStream>())))
 143 {
 144 }
 145
 146 TextWriter::TextWriter(const TextOutputStreamPointer& stream) : impl_(new Impl(stream)) {}
 147
 148 TextWriter::~TextWriter() {}
 149
 150 TextLineWrapperSettings& TextWriter::wrapperSettings()
 151 {
 152     return impl_->wrapper_.settings();
 153 }
 154
 155 void TextWriter::writeString(const char* str)
 156 {
 157     if (impl_->wrapper_.isTrivial())
 158     {
 159         impl_->writeRawString(str);
 160     }
 161     else
 162     {
 163         impl_->writeWrappedString(str);
 164     }
 165 }
 166
 167 void TextWriter::writeString(const std::string& str)
 168 {
 169     impl_->writeWrappedString(str);
 170 }
 171
 172 void TextWriter::writeStringFormatted(const char* fmt, ...)
 173 {
 174     va_list ap;
 175
 176     va_start(ap, fmt);
 177     writeString(formatStringV(fmt, ap));
 178     va_end(ap);
 179 }
 180
 181 void TextWriter::writeLine(const char* line)
 182 {
 183     writeString(line);
 184     ensureLineBreak();
 185 }
 186
 187 void TextWriter::writeLine(const std::string& line)
 188 {
 189     writeString(line);
 190     ensureLineBreak();
 191 }
 192
 193 void TextWriter::writeLineFormatted(const char* fmt, ...)
 194 {
 195     va_list ap;
 196
 197     va_start(ap, fmt);
 198     writeString(formatStringV(fmt, ap));
 199     va_end(ap);
 200     ensureLineBreak();
 201 }
 202
 203 void TextWriter::writeLine()
 204 {
 205     impl_->writeRawString("\n");
 206 }
 207
 208 void TextWriter::ensureLineBreak()
 209 {
 210     if (impl_->newLineCount_ == 0)
 211     {
 212         impl_->writeRawString("\n");
 213     }
 214 }
 215
 216 void TextWriter::ensureEmptyLine()
 217 {
 218     ensureLineBreak();
 219     if (impl_->newLineCount_ < 2)
 220     {
 221         impl_->pendingNewLine_ = true;
 222     }
 223 }
 224
 225 void TextWriter::close()
 226 {
 227     impl_->stream_->close();
 228 }
 229
 230 } // namespace gmx