string_utils.hpp

Go to the documentation of this file.

#pragma once
 
// SPDX-License-Identifier: BSD-3-Clause
// SPDX-FileCopyrightText: Czech Technical University in Prague
 
#include <array>
#include <cstdarg>
#include <cstring>
#include <functional>
#include <list>
#include <map>
#include <set>
#include <stdexcept>
#include <string>
#include <sstream>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include <cras_cpp_common/optional.hpp>
#include <cras_cpp_common/type_utils/string_traits.hpp>
 
namespace cras
{
 
void stripLeading(::std::string& s, const char& c = ' ');
 
void stripTrailing(::std::string& s, const char& c = ' ');
 
void strip(::std::string& s, const char& c = ' ');
 
void stripLeadingSlash(::std::string& s, bool warn = false);
 
::std::string stripLeading(const ::std::string& s, const char& c = ' ');
 
::std::string stripTrailing(const ::std::string& s, const char& c = ' ');
 
::std::string strip(const ::std::string& s, const char& c = ' ');
 
::std::string stripLeadingSlash(const ::std::string& s, bool warn = false);
 
::std::string removePrefix(const ::std::string& str, const ::std::string& prefix, bool* hadPrefix = nullptr);
 
::std::string removeSuffix(const ::std::string& str, const ::std::string& suffix, bool* hadSuffix = nullptr);
 
::std::string prependIfNonEmpty(const ::std::string& str, const ::std::string& prefix);
 
::std::string appendIfNonEmpty(const ::std::string& str, const ::std::string& suffix);
 
bool startsWith(const ::std::string& str, const ::std::string& prefix);
 
bool endsWith(const ::std::string& str, const ::std::string& suffix);
 
enum class ReplacePosition
{
  EVERYWHERE,
 
  START,
 
  END
};
 
::std::string replace(const ::std::string& str, const ::std::string& from, const ::std::string& to,
  const ::cras::ReplacePosition& where = ::cras::ReplacePosition::EVERYWHERE);
 
void replace(::std::string& str, const ::std::string& from, const ::std::string& to,
  const ::cras::ReplacePosition& where = ::cras::ReplacePosition::EVERYWHERE);
 
bool contains(const ::std::string& str, char c);
 
bool contains(const ::std::string& str, const ::std::string& needle);
 
::std::vector<::std::string> split(const ::std::string& str, const ::std::string& delimiter, int maxSplits = -1);
 
::std::string toUpper(const ::std::string& str);
 
::std::string toLower(const ::std::string& str);
 
__attribute__((format(printf, 1, 0)))
inline ::std::string format(const char* format, ::va_list args)
{
  constexpr size_t BUF_LEN = 1024u;
  char buf[BUF_LEN];
 
  ::va_list argsCopy;
  ::va_copy(argsCopy, args);
 
  const auto len = ::vsnprintf(buf, BUF_LEN, format, args);
 
  ::std::string result;
  if (len < 0)
  {
    throw ::std::runtime_error(::std::string("Error formatting string '") + format + "': " + ::strerror(errno));
  }
  else if (len < BUF_LEN)
  {
    result = buf;
  }
  else
  {
    char* buf2 = new char[len + 1];
    ::vsnprintf(buf2, len + 1, format, argsCopy);
    result = buf2;
    delete[] buf2;
  }
  ::va_end(argsCopy);
  return result;
}
 
__attribute__((format(printf, 1, 2)))
inline ::std::string format(const char* format, ...)
{
  ::va_list(args);
  ::va_start(args, format);
  const auto result = ::cras::format(format, args);
  ::va_end(args);
  return result;
}
 
inline ::std::string format(::std::string format, ...)
{
  ::va_list(args);
  ::va_start(args, format);
  const auto result = ::cras::format(format.c_str(), args);
  ::va_end(args);
  return result;
}
 
inline ::std::string format(::std::string format, ::va_list args)
{
  return ::cras::format(format.c_str(), args);
}
 
template<typename T, ::std::enable_if_t<!::cras::is_string<::std::decay_t<T>>::value, bool> = true>
inline ::std::string quoteIfStringType(const ::std::string& s, const T&)
{
  return s;
}
 
template<typename T, ::std::enable_if_t<::cras::is_string<::std::decay_t<T>>::value, bool> = true>
inline ::std::string quoteIfStringType(const ::std::string& s, const T&)
{
  return "\"" + s + "\"";
}
 
template<typename T>
inline decltype(::std::to_string(::std::declval<T>())) to_string(const T& value)
{
  return ::std::to_string(value);
}
 
template<typename T>
inline decltype(static_cast<::std::string>(::std::declval<T>())) to_string(const T& value)
{
  return static_cast<::std::string>(value);
}
 
template<typename T> using ToStringFn = ::std::function<::std::string(const T&)>;
 
inline ::std::string to_string(const double& value)
{
  return ::cras::format("%g", value);
}
 
inline ::std::string to_string(const float& value)
{
  return ::cras::format("%g", value);
}
 
inline ::std::string to_string(const long double& value)
{
  return ::cras::format("%Lg", value);
}
 
inline ::std::string to_string(const char* value)
{
  return {value};
}
 
inline ::std::string to_string(char* value)
{
  return {value};
}
 
template<int I>
inline ::std::string to_string(const char value[I])
{
  return {value};
}
 
template<int I>
inline ::std::string to_string(char value[I])
{
  return {value};
}
 
inline ::std::string to_string(const bool& value)
{
  return value ? "True" : "False";
}
 
inline ::std::string to_string(const ::std::string& value)
{
  return value;
}
 
}
 
#if __has_include(<Eigen/Core>)
#include "cras_cpp_common/string_utils/eigen.hpp"
#endif
 
#if __has_include(<tf2/LinearMath/Vector3.h>)
#include "cras_cpp_common/string_utils/tf2.hpp"
#endif
 
#if __has_include(<ros/ros.h>)
#include "cras_cpp_common/string_utils/ros.hpp"
#endif
 
#if __has_include(<xmlrpcpp/XmlRpcValue.h>)
#include "cras_cpp_common/string_utils/xmlrpc.hpp"
#endif
 
namespace cras
{
 
// forward declarations of to_string(map) so that to_string(vector) can make use of it
template<typename K, typename V>
inline ::std::string to_string(const ::std::map<K, V>& value);
 
template<typename K, typename V>
inline ::std::string to_string(const ::std::unordered_map<K, V>& value);
 
#define DECLARE_TO_STRING_VECTOR(vectorType, prefix, suffix) \
  template<typename T> \
  inline ::std::string to_string(const vectorType<T>& value) \
  { \
    ::std::stringstream ss; \
    ss << (prefix); \
    size_t i = 0; \
    for (const auto& v : value) \
    { \
      ss << ::cras::quoteIfStringType(::cras::to_string(v), v); \
      if (i + 1 < value.size()) \
        ss << ", "; \
      ++i; \
    } \
    ss << (suffix); \
    return ss.str(); \
  }
 
DECLARE_TO_STRING_VECTOR(::std::vector, "[", "]")
DECLARE_TO_STRING_VECTOR(::std::list, "[", "]")
DECLARE_TO_STRING_VECTOR(::std::set, "{", "}")
DECLARE_TO_STRING_VECTOR(::std::unordered_set, "{", "}")
 
template<typename T, size_t N>
inline ::std::string to_string(const ::std::array<T, N>& value)
{
  ::std::stringstream ss;
  ss << ("[");
  size_t i = 0;
  for (const auto& v : value)
  {
    ss << ::cras::quoteIfStringType(::cras::to_string(v), v);
    if (i + 1 < value.size())ss << ", ";
    ++i;
  }
  ss << ("]");
  return ss.str();
}
 
#define DECLARE_TO_STRING_MAP(mapType) \
  template<typename K, typename V> \
  inline ::std::string to_string(const mapType<K, V>& value) \
  { \
    ::std::stringstream ss; \
    ss << "{"; \
    size_t i = 0; \
    for (const auto& pair : value) \
    { \
      ss << ::cras::quoteIfStringType(::cras::to_string(pair.first), pair.first) \
         << ": " \
         << ::cras::quoteIfStringType(::cras::to_string(pair.second), pair.second); \
      if (i + 1 < value.size()) \
        ss << ", "; \
      ++i; \
    } \
    ss << "}"; \
    return ss.str(); \
  }
 
DECLARE_TO_STRING_MAP(::std::map)
DECLARE_TO_STRING_MAP(::std::unordered_map)
 
template<typename T>
::std::string join(const T& strings, const ::std::string& delimiter)
{
  const auto numStrings = strings.size();
  if (numStrings == 0)
    return "";
 
  ::std::stringstream ss;
  size_t i = 0;
  for (const auto& s : strings)
  {
    ss << ::cras::to_string(s);
    if (i < numStrings - 1)
      ss << delimiter;
    i++;
  }
  return ss.str();
}
 
int8_t parseInt8(const std::string& string);
 
int8_t parseInt8(const std::string& string, uint8_t base);
 
inline int8_t parseInt8(const char* string)
{
  return ::cras::parseInt8(::std::string(string));
}
 
inline int8_t parseInt8(const char* string, const uint8_t base)
{
  return ::cras::parseInt8(::std::string(string), base);
}
 
uint8_t parseUInt8(const std::string& string);
 
uint8_t parseUInt8(const std::string& string, uint8_t base);
 
inline uint8_t parseUInt8(const char* string)
{
  return ::cras::parseUInt8(::std::string(string));
}
 
inline uint8_t parseUInt8(const char* string, const uint8_t base)
{
  return ::cras::parseUInt8(::std::string(string), base);
}
 
int16_t parseInt16(const std::string& string);
 
int16_t parseInt16(const std::string& string, uint8_t base);
 
inline int16_t parseInt16(const char* string)
{
  return ::cras::parseInt16(::std::string(string));
}
 
inline int16_t parseInt16(const char* string, const uint8_t base)
{
  return ::cras::parseInt16(::std::string(string), base);
}
 
uint16_t parseUInt16(const std::string& string);
 
uint16_t parseUInt16(const std::string& string, uint8_t base);
 
inline uint16_t parseUInt16(const char* string)
{
  return ::cras::parseUInt16(::std::string(string));
}
 
inline uint16_t parseUInt16(const char* string, const uint8_t base)
{
  return ::cras::parseUInt16(::std::string(string), base);
}
 
int32_t parseInt32(const std::string& string);
 
int32_t parseInt32(const std::string& string, uint8_t base);
 
inline int32_t parseInt32(const char* string)
{
  return ::cras::parseInt32(::std::string(string));
}
 
inline int32_t parseInt32(const char* string, const uint8_t base)
{
  return ::cras::parseInt32(::std::string(string), base);
}
 
uint32_t parseUInt32(const std::string& string);
 
uint32_t parseUInt32(const std::string& string, uint8_t base);
 
inline uint32_t parseUInt32(const char* string)
{
  return ::cras::parseUInt32(::std::string(string));
}
 
inline uint32_t parseUInt32(const char* string, const uint8_t base)
{
  return ::cras::parseUInt32(::std::string(string), base);
}
 
int64_t parseInt64(const std::string& string);
 
int64_t parseInt64(const std::string& string, uint8_t base);
 
inline int64_t parseInt64(const char* string)
{
  return ::cras::parseInt64(::std::string(string));
}
 
inline int64_t parseInt64(const char* string, const uint8_t base)
{
  return ::cras::parseInt64(::std::string(string), base);
}
 
uint64_t parseUInt64(const std::string& string);
 
uint64_t parseUInt64(const std::string& string, uint8_t base);
 
inline uint64_t parseUInt64(const char* string)
{
  return ::cras::parseUInt64(::std::string(string));
}
 
inline uint64_t parseUInt64(const char* string, const uint8_t base)
{
  return ::cras::parseUInt64(::std::string(string), base);
}
 
float parseFloat(const ::std::string& string);
 
inline float parseFloat(const char* string)
{
  return ::cras::parseFloat(::std::string(string));
}
 
double parseDouble(const ::std::string& string);
 
inline double parseDouble(const char* string)
{
  return ::cras::parseDouble(::std::string(string));
}
 
bool isLegalName(const ::std::string& name);
 
bool isLegalBaseName(const ::std::string& name);
 
class TempLocale
{
public:
  TempLocale(int category, const char* newLocale);
  ~TempLocale();
 
private:
  int category;  //!< The category of the locale.
  const char* oldLocale;  //!< The previous locale.
};
 
::std::string iconvConvert(
  const ::std::string& toEncoding, const ::std::string& fromEncoding, const ::std::string& inText,
  bool translit = false, bool ignore = false, double initialOutbufSizeScale = 1.0, double outbufEnlargeCoef = 2.0,
  const ::cras::optional<::std::string>& localeName = ::cras::nullopt);
 
::std::string transliterateToAscii(const ::std::string& text);
 
::std::string toValidRosName(const ::std::string& text, bool baseName = true,
  const ::cras::optional<::std::string>& fallbackName = ::cras::nullopt);
 
}