stringutils.h

Go to the documentation of this file.

#ifndef ION_BASE_STRINGUTILS_H_
#define ION_BASE_STRINGUTILS_H_


#include <istream>  // NOLINT
#include <string>
#include <vector>

#include "base/integral_types.h"
#include "ion/base/stlalloc/allocvector.h"

namespace ion {
namespace base {

ION_API std::string EscapeString(const std::string& str);

ION_API std::string EscapeNewlines(const std::string& str);

ION_API std::string MimeBase64EncodeString(const std::string& str);

ION_API std::vector<std::string> SplitString(
    const std::string& str, const std::string& delimiters);

ION_API AllocVector<std::string> SplitString(
    const std::string& str, const std::string& delimiters,
    const AllocatorPtr& alloc);

ION_API std::vector<std::string> SplitStringWithoutSkipping(
    const std::string& str, const std::string& delimiters);

inline std::string QuoteString(const std::string& val) {
  std::ostringstream out;
  out << '"' << EscapeString(val) << '"';
  return out.str();
}

inline bool StartsWith(const std::string& target, const std::string& start) {
  return start.length() && start.compare(target.substr(0, start.size())) == 0;
}

inline bool EndsWith(const std::string& target, const std::string& end) {
  return end.length() && end.length() <= target.length() &&
       target.compare(target.length() - end.length(), end.length(), end) == 0;
}

inline std::string JoinStrings(const std::vector<std::string>& strings,
                                     const std::string& glue) {
  std::string joined;
  if (const size_t count = strings.size()) {
    joined = strings[0];
    for (size_t i = 1; i < count; ++i)
      joined += glue + strings[i];
  }
  return joined;
}

inline bool RemovePrefix(const std::string& prefix, std::string* target) {
  if (StartsWith(*target, prefix)) {
    *target = target->substr(prefix.length(),
                             target->length() - prefix.length());
    return true;
  }
  return false;
}

inline bool RemoveSuffix(const std::string& suffix, std::string* target) {
  if (EndsWith(*target, suffix)) {
    *target = target->substr(0, target->length() - suffix.length());
    return true;
  }
  return false;
}

inline std::string ReplaceString(const std::string& search,
                                 const std::string& from,
                                 const std::string& to) {
  if (search.empty() || from.empty())
    return search;

  std::string replaced = search;
  const size_t to_size = to.size();
  for (size_t start_pos = replaced.find(from); start_pos != std::string::npos;
       start_pos = replaced.find(from, start_pos + to_size))
    replaced.replace(start_pos, from.length(), to);
  return replaced;
}

inline std::string TrimStartWhitespace(const std::string& target) {
  const size_t pos = target.find_first_not_of(" \f\n\r\t\v");
  std::string trimmed;
  if (pos != std::string::npos)
    trimmed = target.substr(pos, std::string::npos);
  return trimmed;
}

inline std::string TrimEndWhitespace(const std::string& target) {
  const size_t pos = target.find_last_not_of(" \f\n\r\t\v");
  std::string trimmed;
  if (pos != std::string::npos)
    trimmed = target.substr(0, pos + 1U);
  return trimmed;
}

inline std::string TrimStartAndEndWhitespace(const std::string& target) {
  return TrimEndWhitespace(TrimStartWhitespace(target));
}

ION_API std::string UrlDecodeString(const std::string& str);

ION_API std::string UrlEncodeString(const std::string& str);

ION_API bool AreMultiLineStringsEqual(
    const std::string& s0, const std::string& s1,
    size_t* first_different_index, std::string* line0, std::string* line1,
    std::string* context0, std::string* context1);

ION_API int CompareCaseInsensitive(const std::string& str1,
                                   const std::string& str2);

ION_API bool StartsWithCaseInsensitive(const std::string& target,
                                       const std::string& start);

ION_API bool EndsWithCaseInsensitive(const std::string& target,
                                     const std::string& end);

ION_API int FindCaseInsensitive(const std::string& target,
                                const std::string& substr);

ION_API std::string WebSafeBase64Decode(const std::string& str);

ION_API std::string WebSafeBase64Encode(const std::string& input);

template <char expected>
inline std::istream& GetExpectedChar(std::istream& in) {  // NOLINT
  char c = expected + 1;
  if (in >> c && c != expected) {
    in.unget();
    in.setstate(std::ios_base::failbit);
  }
  return in;
}

inline std::istream& GetExpectedString(std::istream& in,  // NOLINT
                                       const std::string& expected) {
  if (!in.fail()) {
    const size_t length = expected.length();
    for (size_t i = 0; i < length; ++i) {
      char c;
      in >> c;
      if (!in.good() || c != expected[i]) {
        for (size_t j = 0; j <= i; ++j)
          in.unget();
        in.setstate(std::ios_base::failbit);
        break;
      }
    }
  }
  return in;
}

ION_API int32 StringToInt32(const std::string& str);

template<typename T>
void AppendBytes(std::string* s, const T& value) {
  const char* data = reinterpret_cast<const char*>(&value);
  s->insert(s->end(), data, data + sizeof(T));
}

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_STRINGUTILS_H_