| OpenMS 2.5.0

String.h
Go to the documentation of this file.
1 // --------------------------------------------------------------------------
2 // OpenMS -- Open-Source Mass Spectrometry
3 // --------------------------------------------------------------------------
4 // Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
5 // ETH Zurich, and Freie Universitaet Berlin 2002-2020.
6 //
7 // This software is released under a three-clause BSD license:
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of any author or any participating institution
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
16 // For a full list of authors, refer to the file AUTHORS.
17 // --------------------------------------------------------------------------
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 // ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
22 // INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // --------------------------------------------------------------------------
31 // $Maintainer: Timo Sachsenberg$
32 // $Authors: Marc Sturm $
33 // --------------------------------------------------------------------------
34
35 #pragma once
36
37 #include <OpenMS/CONCEPT/Types.h>
38 #include <OpenMS/OpenMSConfig.h>
39
40 #include <algorithm> // for "min"
41 #include <string>
42 #include <vector>
43
44 class QString;
45
46 namespace OpenMS
47 {
48 class DataValue;
49 template <typename FloatingPointType>
50 struct PrecisionWrapper;
58 class String :
59 public std::string
60 {
61 public:
62
64 OPENMS_DLLAPI static const String EMPTY;
65
69 typedef iterator Iterator;
72 typedef const_iterator ConstIterator;
74 typedef reverse_iterator ReverseIterator;
76 typedef const_reverse_iterator ConstReverseIterator;
78 typedef size_type SizeType;
79
81 enum QuotingMethod {NONE, ESCAPE, DOUBLE};
82
84
88 OPENMS_DLLAPI String();
91 OPENMS_DLLAPI String(const String&) = default;
93 OPENMS_DLLAPI String(String&&) = default;
95 OPENMS_DLLAPI String(const std::string& s);
97 OPENMS_DLLAPI String(const QString& s);
99 OPENMS_DLLAPI String(const char* s);
101 OPENMS_DLLAPI String(const char c);
103 OPENMS_DLLAPI String(const char* s, SizeType length);
105 OPENMS_DLLAPI String(size_t len, char c);
107 template <class InputIterator>
108 String(InputIterator first, InputIterator last) :
109 std::string(first, last)
110 {
111 }
112
114 OPENMS_DLLAPI String(int i);
116 OPENMS_DLLAPI String(unsigned int i);
118 OPENMS_DLLAPI String(short int i);
120 OPENMS_DLLAPI String(short unsigned int i);
122 OPENMS_DLLAPI String(long int i);
124 OPENMS_DLLAPI String(long unsigned int i);
126 OPENMS_DLLAPI String(long long unsigned int i);
128 OPENMS_DLLAPI String(long long signed int i);
130 OPENMS_DLLAPI String(float f, bool full_precision = true);
132 OPENMS_DLLAPI String(double d, bool full_precision = true);
134 OPENMS_DLLAPI String(long double ld, bool full_precision = true);
136 OPENMS_DLLAPI String(const DataValue& d, bool full_precision = true);
137
139
143 OPENMS_DLLAPI bool hasPrefix(const String& string) const;
145
147 OPENMS_DLLAPI bool hasSuffix(const String& string) const;
148
150 OPENMS_DLLAPI bool hasSubstring(const String& string) const;
151
153 OPENMS_DLLAPI bool has(Byte byte) const;
155
157 OPENMS_DLLAPI String& operator=(const String&) = default;
159 OPENMS_DLLAPI String& operator=(String&&) & = default;
160
169 OPENMS_DLLAPI String prefix(SizeType length) const;
170
176 OPENMS_DLLAPI String suffix(SizeType length) const;
177
184 OPENMS_DLLAPI String prefix(Int length) const;
185
192 OPENMS_DLLAPI String suffix(Int length) const;
193
199 OPENMS_DLLAPI String prefix(char delim) const;
200
206 OPENMS_DLLAPI String suffix(char delim) const;
207
220 OPENMS_DLLAPI String substr(size_t pos = 0, size_t n = npos) const;
221
229 OPENMS_DLLAPI String chop(Size n) const;
230
232
233
240 OPENMS_DLLAPI String& reverse();
242
244 OPENMS_DLLAPI String& trim();
245
253 OPENMS_DLLAPI String& quote(char q = '"', QuotingMethod method = ESCAPE);
254
264 OPENMS_DLLAPI String& unquote(char q = '"', QuotingMethod method = ESCAPE);
265
267 OPENMS_DLLAPI String& simplify();
268
270 OPENMS_DLLAPI String& fillLeft(char c, UInt size);
271
273 OPENMS_DLLAPI String& fillRight(char c, UInt size);
274
276 OPENMS_DLLAPI String& toUpper();
277
279 OPENMS_DLLAPI String& toLower();
280
282 OPENMS_DLLAPI String& firstToUpper();
283
285 OPENMS_DLLAPI String& substitute(char from, char to);
286
288 OPENMS_DLLAPI String& substitute(const String& from, const String& to);
289
291 OPENMS_DLLAPI String& remove(char what);
292
294 OPENMS_DLLAPI String& ensureLastChar(char end);
295
297 OPENMS_DLLAPI String& removeWhitespaces();
299
303
312 OPENMS_DLLAPI Int toInt() const;
313
319 OPENMS_DLLAPI float toFloat() const;
320
326 OPENMS_DLLAPI double toDouble() const;
327
329 OPENMS_DLLAPI QString toQString() const;
330
332
336 OPENMS_DLLAPI String operator+(int i) const;
339 OPENMS_DLLAPI String operator+(unsigned int i) const;
341 OPENMS_DLLAPI String operator+(short int i) const;
343 OPENMS_DLLAPI String operator+(short unsigned int i) const;
345 OPENMS_DLLAPI String operator+(long int i) const;
347 OPENMS_DLLAPI String operator+(long unsigned int i) const;
349 OPENMS_DLLAPI String operator+(long long unsigned int i) const;
351 OPENMS_DLLAPI String operator+(float f) const;
353 OPENMS_DLLAPI String operator+(double d) const;
355 OPENMS_DLLAPI String operator+(long double ld) const;
357 OPENMS_DLLAPI String operator+(char c) const;
359 OPENMS_DLLAPI String operator+(const char* s) const;
361 OPENMS_DLLAPI String operator+(const String& s) const;
363 OPENMS_DLLAPI String operator+(const std::string& s) const;
365
369 OPENMS_DLLAPI String& operator+=(int i);
372 OPENMS_DLLAPI String& operator+=(unsigned int i);
374 OPENMS_DLLAPI String& operator+=(short int i);
376 OPENMS_DLLAPI String& operator+=(short unsigned int i);
378 OPENMS_DLLAPI String& operator+=(long int i);
380 OPENMS_DLLAPI String& operator+=(long unsigned int i);
382 OPENMS_DLLAPI String& operator+=(long long unsigned int i);
384 OPENMS_DLLAPI String& operator+=(float f);
386 OPENMS_DLLAPI String& operator+=(double d);
388 OPENMS_DLLAPI String& operator+=(long double d);
390 OPENMS_DLLAPI String& operator+=(char c);
392 OPENMS_DLLAPI String& operator+=(const char* s);
394 OPENMS_DLLAPI String& operator+=(const String& s);
396 OPENMS_DLLAPI String& operator+=(const std::string& s);
398
400 OPENMS_DLLAPI static String random(UInt length);
401
403 OPENMS_DLLAPI static String number(double d, UInt n);
409 OPENMS_DLLAPI static String numberLength(double d, UInt n);
410
411
428 OPENMS_DLLAPI bool split(const char splitter, std::vector<String>& substrings, bool quote_protect = false) const;
429
441 OPENMS_DLLAPI bool split(const String& splitter, std::vector<String>& substrings) const;
442
457 OPENMS_DLLAPI bool split_quoted(const String& splitter, std::vector<String>& substrings,
458 char q = '"', QuotingMethod method = ESCAPE) const;
459
465 template <class StringIterator>
466 void concatenate(StringIterator first, StringIterator last, const String& glue = "")
467 {
468 //empty container
469 if (first == last)
470 {
471 std::string::clear();
472 return;
473 }
474
475 std::string::operator=(* first);
476 for (StringIterator it = ++first; it != last; ++it)
477 {
478 std::string::operator+=(glue + (*it));
479 }
480 }
481
482 };
483
488 class OPENMS_DLLAPI StringView
489 {
490 public:
491
492 // create view on string
493 StringView() : begin_(), size_(0)
494 {
495 }
496
497 // create view on string
498 StringView(const std::string& s) : begin_(s.data()), size_(s.size())
499 {
500 }
501
502 // construct from other view
503 StringView(const StringView& s) : begin_(s.begin_), size_(s.size_)
504 {
505 }
506
508 bool operator<(const StringView other) const
509 {
510 if (size_ < other.size_) return true;
511
512 if (size_ > other.size_) return false;
513
514 // same size
515 const char * b = begin_;
516 const char * bo = other.begin_;
517
518 for (Size i = 0; i != size_; ++i, ++b, ++bo)
519 {
520 if (*b < *bo) return true;
521 if (*b > *bo) return false;
522 }
523
524 return false;
525 }
526
528 inline StringView substr(Size start, Size length) const
529 {
530 if (!size_) return *this;
531
532 StringView sv(*this);
533 sv.begin_ = begin_ + start;
534 sv.size_ = std::min(length, sv.size_ - start);
535 return sv;
536 }
537
539 inline Size size() const
540 {
541 return size_;
542 }
543
545 inline String getString() const
546 {
547 if (!size_) return String();
548 return String(begin_, begin_ + size_);
549 }
550
551 private:
552 const char* begin_;
553 Size size_;
554 };
555
556 OPENMS_DLLAPI ::size_t hash_value(OpenMS::String const& s);
557 } // namespace OpenMS
558
559 namespace std
560 {
561 template <> struct hash<OpenMS::String> //hash for String
562 {
563 std::size_t operator()( OpenMS::String const& s) const
564 {
565 return std::hash<string>()(static_cast<string>(s));
566 }
567 };
568 } // namespace std
OpenMS::String::ReverseIterator
reverse_iterator ReverseIterator
Reverse Iterator.
Definition: String.h:74
OpenMS::String::operator=
String & operator=(const String &)=default
Assignment operator.
OpenMS::String::Iterator
iterator Iterator
Iterator.
Definition: String.h:70
OpenMS::String
A more convenient string class.
Definition: String.h:58
OpenMS::DataValue
Class to hold strings, numeric values, lists of strings and lists of numeric values.
Definition: DataValue.h:56
OpenMS::StringView::substr
StringView substr(Size start, Size length) const
create view that references a substring of the original string
Definition: String.h:528
OpenMS::String::hasSuffix
bool hasSuffix(const String &string) const
true if String ends with string, false otherwise
OpenMS::String::toLower
String & toLower()
Converts the string to lowercase.
OpenMS::String< TSize >::QuotingMethod
QuotingMethod
How to handle embedded quotes when quoting strings.
Definition: String.h:81
OpenMS::String::fillLeft
String & fillLeft(char c, UInt size)
Adds c on the left side until the size of the string is size.
OpenMS::Byte
OPENMS_BYTE_TYPE Byte
Byte type.
Definition: Types.h:111
OpenMS::String::ensureLastChar
String & ensureLastChar(char end)
Makes sure the string ends with the character end.
OpenMS::String::substitute
String & substitute(char from, char to)
Replaces all occurrences of the character from by the character to.
OpenMS::String::ConstIterator
const_iterator ConstIterator
Const Iterator.
Definition: String.h:72
OpenMS::String::hasPrefix
bool hasPrefix(const String &string) const
true if String begins with string, false otherwise
OpenMS::String::operator+=
String & operator+=(int i)
Sum operator for an integer.
OpenMS::String::ESCAPE
Definition: String.h:81
OpenMS::StringView::StringView
StringView(const std::string &s)
Definition: String.h:498
OpenMS::String::operator+
String operator+(int i) const
Sum operator for an integer.
OpenMS::String::String
String()
Default constructor.
std
STL namespace.
OpenMS::StringView::size
Size size() const
size of view
Definition: String.h:539
OpenMS::StringView::size_
Size size_
Definition: String.h:553
Types.h
OpenMS::String::concatenate
void concatenate(StringIterator first, StringIterator last, const String &glue="")
Concatenates all elements from first to last-1 and inserts glue between the elements.
Definition: String.h:466
OpenMS::String::has
bool has(Byte byte) const
true if String contains the byte, false otherwise
OpenMS::String::toInt
Int toInt() const
Conversion to int.
OpenMS::StringView
StringView provides a non-owning view on an existing string.
Definition: String.h:488
OpenMS::String::split_quoted
bool split_quoted(const String &splitter, std::vector< String > &substrings, char q='"', QuotingMethod method = ESCAPE) const
Splits a string into substrings using splitter (the whole string) as delimiter, but does not split wi...
OpenMS::StringView::operator<
bool operator<(const StringView other) const
less operator
Definition: String.h:508
OpenMS::String::NONE
Definition: String.h:81
OpenMS::String::toDouble
double toDouble() const
Conversion to double.
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:46
OpenMS::String::removeWhitespaces
String & removeWhitespaces()
removes whitespaces (space, tab, line feed, carriage return)
OpenMS::String::toUpper
String & toUpper()
Converts the string to uppercase.
OpenMS::StringView::StringView
StringView(const StringView &s)
Definition: String.h:503
OpenMS::UInt
unsigned int UInt
Unsigned integer type.
Definition: Types.h:94
OpenMS::StringView::StringView
StringView()
Definition: String.h:493
OpenMS::String::unquote
String & unquote(char q='"', QuotingMethod method = ESCAPE)
Reverses changes made by the quote method.
OpenMS::String::substr
String substr(size_t pos=0, size_t n=npos) const
Wrapper for the STL substr() method. Returns a String object with its contents initialized to a subst...
OpenMS::String::prefix
String prefix(SizeType length) const
returns the prefix of length length
OpenMS::String::fillRight
String & fillRight(char c, UInt size)
Adds c on the right side until the size of the string is size.
OpenMS::String::random
static String random(UInt length)
returns a random string of the given length. It consists of [0-9a-zA-Z]
OpenMS::String::firstToUpper
String & firstToUpper()
Converts the first letter of the string to uppercase.
OpenMS::String::ConstReverseIterator
const_reverse_iterator ConstReverseIterator
Const reverse Iterator.
Definition: String.h:76
OpenMS::Constants::c
const double c
OpenMS::String::String
String(InputIterator first, InputIterator last)
Constructor from a char range.
Definition: String.h:108
OpenMS::String::suffix
String suffix(SizeType length) const
returns the suffix of length length
OpenMS::String::SizeType
size_type SizeType
UInt type.
Definition: String.h:78
OpenMS::String::quote
String & quote(char q='"', QuotingMethod method = ESCAPE)
Wraps the string in quotation marks.
int
OpenMS::String::reverse
String & reverse()
inverts the direction of the string
OpenMS::String::EMPTY
static const String EMPTY
Empty string for comparisons.
Definition: String.h:64
OpenMS::String::split
bool split(const char splitter, std::vector< String > &substrings, bool quote_protect=false) const
Splits a string into substrings using splitter as delimiter.
OpenMS::String::number
static String number(double d, UInt n)
returns a string for d with exactly n decimal places
OpenMS::String::toFloat
float toFloat() const
Conversion to float.
OpenMS::String::chop
String chop(Size n) const
Returns a substring where n characters were removed from the end of the string.
OpenMS::String::DOUBLE
Definition: String.h:81
OpenMS::String::hasSubstring
bool hasSubstring(const String &string) const
true if String contains the string, false otherwise
std::hash< OpenMS::String >::operator()
std::size_t operator()(OpenMS::String const &s) const
Definition: String.h:563
OpenMS::StringView::getString
String getString() const
create String object from view
Definition: String.h:545
OpenMS::hash_value
std::size_t hash_value(const DPosition< N, T > &b)
Definition: HashGrid.h:450
OpenMS::Size
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:127
OpenMS::String::simplify
String & simplify()
merges subsequent whitespaces to one blank character
OpenMS::String::numberLength
static String numberLength(double d, UInt n)
Returns a string with at maximum n characters for d.
OpenMS::StringView::begin_
const char * begin_
Definition: String.h:552
OpenMS::String::toQString
QString toQString() const
Conversion to Qt QString.
OpenMS::String::trim
String & trim()
removes whitespaces (space, tab, line feed, carriage return) at the beginning and the end of the stri...