3 * This source code is part of
7 * GROningen MAchine for Chemical Simulations
9 * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
10 * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
11 * Copyright (c) 2001-2009, The GROMACS development team,
12 * check out http://www.gromacs.org for more information.
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version 2
17 * of the License, or (at your option) any later version.
19 * If you want to redistribute modifications, please consider that
20 * scientific software is very special. Version control is crucial -
21 * bugs must be traceable. We will be happy to consider code for
22 * inclusion in the official distribution, but derived work must not
23 * be called official GROMACS. Details are found in the README & COPYING
24 * files - if they are missing, get the official version at www.gromacs.org.
26 * To help us fund GROMACS development, we humbly ask that you cite
27 * the papers on the package - you can find them in the top README file.
29 * For more info, check our website at http://www.gromacs.org
33 * Implements functions and classes in stringutil.h.
35 * \author Teemu Murtola <teemu.murtola@cbr.su.se>
36 * \ingroup module_utility
38 #include "stringutil.h"
49 #include "gromacs/utility/gmxassert.h"
54 bool endsWith(const std::string &str, const char *suffix)
56 if (suffix == NULL || suffix[0] == '\0')
60 size_t length = std::strlen(suffix);
61 return (str.length() >= length
62 && str.compare(str.length() - length, length, suffix) == 0);
65 std::string stripSuffixIfPresent(const std::string &str, const char *suffix)
69 size_t suffixLength = std::strlen(suffix);
70 if (suffixLength > 0 && endsWith(str, suffix))
72 return str.substr(0, str.length() - suffixLength);
78 std::string formatString(const char *fmt, ...)
83 std::vector<char> dynamicBuf;
84 char *buf = staticBuf;
86 // TODO: There may be a better way of doing this on Windows, Microsoft
87 // provides their own way of doing things...
91 int n = vsnprintf(buf, length, fmt, ap);
93 if (n > -1 && n < length)
95 std::string result(buf);
106 dynamicBuf.resize(length);
107 buf = &dynamicBuf[0];
111 std::string concatenateStrings(const char *const *sarray, size_t count)
115 for (size_t i = 0; i < count && sarray[i] != NULL; ++i)
117 if (sarray[i][0] != '\0')
119 result.append(sarray[i]);
120 char lastchar = sarray[i][std::strlen(sarray[i])-1];
121 if (!std::isspace(lastchar))
127 result.resize(result.find_last_not_of(" \n\r\t") + 1);
135 * Common implementation for string replacement functions.
137 * \param[in] input Input string.
138 * \param[in] from String to find.
139 * \param[in] to String to use to replace \p from.
140 * \param[in] bWholeWords Whether to only consider matches to whole words.
141 * \returns \p input with all occurrences of \p from replaced with \p to.
142 * \throws std::bad_alloc if out of memory.
145 replaceInternal(const std::string &input, const char *from, const char *to,
148 GMX_RELEASE_ASSERT(from != NULL && to != NULL,
149 "Replacement strings must not be NULL");
150 size_t matchLength = std::strlen(from);
153 size_t matchPos = input.find(from);
154 while (matchPos < input.length())
156 size_t matchEnd = matchPos + matchLength;
159 if (!((matchPos == 0 || !std::isalnum(input[matchPos-1]))
160 && (matchEnd == input.length() || !std::isalnum(input[matchEnd]))))
162 matchPos = input.find(from, matchPos + 1);
167 result.append(input, inputPos, matchPos - inputPos);
170 matchPos = input.find(from, inputPos);
172 result.append(input, inputPos, matchPos - inputPos);
179 replaceAll(const std::string &input, const char *from, const char *to)
181 return replaceInternal(input, from, to, false);
185 replaceAllWords(const std::string &input, const char *from, const char *to)
187 return replaceInternal(input, from, to, true);
191 /********************************************************************
192 * TextLineWrapperSettings
195 TextLineWrapperSettings::TextLineWrapperSettings()
196 : maxLength_(0), indent_(0), firstLineIndent_(-1),
197 bStripLeadingWhitespace_(true), continuationChar_('\0')
202 /********************************************************************
207 TextLineWrapper::findNextLine(const char *input, size_t lineStart) const
209 size_t inputLength = std::strlen(input);
210 bool bFirstLine = (lineStart == 0 || input[lineStart - 1] == '\n');
211 // Ignore leading whitespace if necessary.
212 if (!bFirstLine || settings_.bStripLeadingWhitespace_)
214 lineStart += std::strspn(input + lineStart, " ");
215 if (lineStart >= inputLength)
221 int indent = (bFirstLine ? settings_.firstLineIndent() : settings_.indent());
222 size_t lastAllowedBreakPoint
223 = (settings_.lineLength() > 0
224 ? std::min(lineStart + settings_.lineLength() - indent, inputLength)
226 // Ignore trailing whitespace.
227 lastAllowedBreakPoint += std::strspn(input + lastAllowedBreakPoint, " ");
228 size_t lineEnd = lineStart;
231 const char *nextBreakPtr = std::strpbrk(input + lineEnd, " \n");
233 = (nextBreakPtr != NULL ? nextBreakPtr - input : inputLength);
234 if (nextBreak > lastAllowedBreakPoint && lineEnd > lineStart)
238 lineEnd = nextBreak + 1;
240 while (lineEnd < lastAllowedBreakPoint && input[lineEnd - 1] != '\n');
241 return (lineEnd < inputLength ? lineEnd : inputLength);
245 TextLineWrapper::findNextLine(const std::string &input, size_t lineStart) const
247 return findNextLine(input.c_str(), lineStart);
251 TextLineWrapper::formatLine(const std::string &input,
252 size_t lineStart, size_t lineEnd) const
254 size_t inputLength = input.length();
255 bool bFirstLine = (lineStart == 0 || input[lineStart - 1] == '\n');
256 // Strip leading whitespace if necessary.
257 if (!bFirstLine || settings_.bStripLeadingWhitespace_)
259 lineStart = input.find_first_not_of(' ', lineStart);
260 if (lineStart >= inputLength)
262 return std::string();
265 int indent = (bFirstLine ? settings_.firstLineIndent() : settings_.indent());
266 bool bContinuation = (lineEnd < inputLength && input[lineEnd - 1] != '\n');
267 // Strip trailing whitespace.
268 while (lineEnd > lineStart && std::isspace(input[lineEnd - 1]))
273 size_t lineLength = lineEnd - lineStart;
274 std::string result(indent, ' ');
275 result.append(input, lineStart, lineLength);
276 if (bContinuation && settings_.continuationChar_ != '\0')
278 result.append(1, ' ');
279 result.append(1, settings_.continuationChar_);
285 TextLineWrapper::wrapToString(const std::string &input) const
288 size_t lineStart = 0;
289 size_t length = input.length();
290 while (lineStart < length)
292 size_t nextLineStart = findNextLine(input, lineStart);
293 result.append(formatLine(input, lineStart, nextLineStart));
294 if (nextLineStart < length
295 || (nextLineStart == length && input[length - 1] == '\n'))
299 lineStart = nextLineStart;
304 std::vector<std::string>
305 TextLineWrapper::wrapToVector(const std::string &input) const
307 std::vector<std::string> result;
308 size_t lineStart = 0;
309 size_t length = input.length();
310 while (lineStart < length)
312 size_t nextLineStart = findNextLine(input, lineStart);
313 result.push_back(formatLine(input, lineStart, nextLineStart));
314 lineStart = nextLineStart;