string_utils.hpp

Go to the documentation of this file.

#pragma once

#include <array>
#include <cstdarg>
#include <functional>
#include <list>
#include <map>
#include <set>
#include <string>
#include <sstream>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#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);

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 < 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;
}

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("%gL", 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);

inline int8_t parseInt8(const char* string)
{
  return ::cras::parseInt8(::std::string(string));
}

uint8_t parseUInt8(const std::string& string);

inline uint8_t parseUInt8(const char* string)
{
  return ::cras::parseUInt8(::std::string(string));
}

int16_t parseInt16(const std::string& string);

inline int16_t parseInt16(const char* string)
{
  return ::cras::parseInt16(::std::string(string));
}

uint16_t parseUInt16(const std::string& string);

inline uint16_t parseUInt16(const char* string)
{
  return ::cras::parseUInt16(::std::string(string));
}

int32_t parseInt32(const std::string& string);

inline int32_t parseInt32(const char* string)
{
  return ::cras::parseInt32(::std::string(string));
}

uint32_t parseUInt32(const std::string& string);

inline uint32_t parseUInt32(const char* string)
{
  return ::cras::parseUInt32(::std::string(string));
}

int64_t parseInt64(const std::string& string);

inline int64_t parseInt64(const char* string)
{
  return ::cras::parseInt64(::std::string(string));
}

uint64_t parseUInt64(const std::string& string);

inline uint64_t parseUInt64(const char* string)
{
  return ::cras::parseUInt64(::std::string(string));
}

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));
}

}