StringTools.h

Go to the documentation of this file.

// StringTools.h: useful string manipulation methods.
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef LOFAR_COMMON_STRINGUTIL_H
#define LOFAR_COMMON_STRINGUTIL_H
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace dp3 {
namespace common {
 
namespace stringtools {
 
//
std::vector<std::string> tokenize(const std::string& str,
                                  const std::string& delims);
 
class Compare {
 public:
  enum Mode { NORMAL, NOCASE };
 
  Compare(Mode mode = NORMAL) : itsMode(mode) {}
 
  bool operator()(const std::string& s1, const std::string& s2) const {
    if (itsMode == NORMAL)
      return s1 < s2;
    else
      return lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),
                                     nocaseCompare);
  }
 
 private:
  static bool nocaseCompare(char c1, char c2) {
    return toupper(c1) < toupper(c2);
  }
 
  Mode itsMode;
};
 
}  // namespace stringtools
 
//
// formatString(format, ...) --> string up to 10Kb
//
// The function formatString accepts printf-like arguments and returns a
// formatted string. It can be used e.g. in stream constructions:
// stream << formatString("Opening connection with host %%s", hostName);
// In real life this must be %s ofcourse but doxygen need a double %%.
const std::string formatString(const char* format, ...);
 
// Skip leading whitespace (blanks and horizontal tabs) starting at st.
// It returns the position of the first non-whitespace character.
// It returns end if all whitespace.
// It can be used in combination with rskipws.
unsigned int lskipws(const std::string& value, unsigned int st,
                     unsigned int end);
 
// Skip trailing whitespace (blanks and horizontal tabs) starting at end.
// It returns the position after the last non-whitespace character, thus
// value.substr(st, end-st) extracts the significant value.
// It returns st if all whitespace.
unsigned int rskipws(const std::string& value, unsigned int st,
                     unsigned int end);
 
// Skip past a quoted string.
// The quote character is the first character (at position st).
// Usually the quote character is ' or ", but it could be any other character.
// An exception is thrown if no ending quote character is found.
unsigned int skipQuoted(const std::string& str, unsigned int st);
 
// Skip past the end of a balanced pair of delimiters where nested pairs
// are also skipped. Delimiters in quoted parts are ignored.
// The starting delimiter is the first character in the string (at position st).
// The ending delimiter is given as an argument.
// The function also works fine if starting and ending delimiter are the same.
// end delimiter is found before position end.
unsigned int skipBalanced(const std::string& str, unsigned int st,
                          unsigned int end, char endChar);
 
// Convert a string to the value of any of the fundamental arithmetic data
// types. It checks if the entire string is used for the conversion.
// An integer value can also be given in hexadecimal format (e.g. 0x123).
// Leading and trailing whitespace is allowed.
// It checks if an integer value does not exceed the data type range.
bool strToBool(const std::string& aString);
long strToLong(const std::string& aString);
int strToInt(const std::string& aString);
int32_t strToInt32(const std::string& aString);
int16_t strToInt16(const std::string& aString);
unsigned long strToUlong(const std::string& aString);
unsigned int strToUint(const std::string& aString);
uint32_t strToUint32(const std::string& aString);
uint16_t strToUint16(const std::string& aString);
int64_t strToInt64(const std::string& aString);
uint64_t strToUint64(const std::string& aString);
float strToFloat(const std::string& aString);
double strToDouble(const std::string& aString);
 
// Array specifications are often entered by the user with ranges
// like 3..32,55..58 For converting such a string to a real vector the spec must
// be expanded so that it contains all elements instead of the ranges. Likewise,
// when you present a array to the user you often want to show a spec with the
// ranges instead of all individual elements. See the ParameterSet document for
// a detailed description of the syntax.
 
// Given a string 'xx..xx, xx' this utility expands the string
// by replacing ranges with the fill series.
// Eg. "lii001..003xx, lii005" --> "lii001xx,lii002xx,lii003xx, lii005"
std::string expandRangeString(const std::string&);
 
// Given a string like '3*str' this utility expands the string
// by replacing the string 3 times.
// Eg. "3*0" --> "0,0,0"
std::string expandMultString(const std::string&);
 
// Apply expandMultString and expandRangeString (in that order) for an array
// string which must be enclosed in square brackets.
std::string expandArrayString(const std::string&);
 
std::string PatternToRegex(const std::string& pattern);
 
}  // namespace common
}  // namespace dp3
 
#endif