StringUtils.h

Go to the documentation of this file.

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * StringUtils.h
 * Random String functions.
 * Copyright (C) 2005 Simon Newton
 */

#ifndef INCLUDE_OLA_STRINGUTILS_H_
#define INCLUDE_OLA_STRINGUTILS_H_

#include <ola/strings/Format.h>
#include <stdint.h>
#include <iomanip>
#include <iostream>
#include <limits>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>

namespace ola {

void StringSplit(const std::string &input,
                 std::vector<std::string> *tokens,
                 const std::string &delimiters = " ");

inline void StringSplit(
    const std::string &input,
    std::vector<std::string> &tokens,  // NOLINT(runtime/references)
    const std::string &delimiters = " ") {
  StringSplit(input, &tokens, delimiters);
}

void StringTrim(std::string *input);

void ShortenString(std::string *input);

bool StringBeginsWith(const std::string &s, const std::string &prefix);

bool StringEndsWith(const std::string &s, const std::string &suffix);

bool StripPrefix(std::string *s, const std::string &prefix);

bool StripSuffix(std::string *s, const std::string &suffix);

inline std::string IntToString(int i) {
  return ola::strings::IntToString(i);
}

inline std::string IntToString(unsigned int i) {
  return ola::strings::IntToString(i);
}

std::string IntToHexString(unsigned int i, unsigned int width);

inline std::string IntToHexString(uint8_t i) {
  std::ostringstream str;
  str << ola::strings::ToHex(i);
  return str.str();
}

inline std::string IntToHexString(uint16_t i) {
  std::ostringstream str;
  str << ola::strings::ToHex(i);
  return str.str();
}

inline std::string IntToHexString(uint32_t i) {
  std::ostringstream str;
  str << ola::strings::ToHex(i);
  return str.str();
}

void Escape(std::string *original);

std::string EscapeString(const std::string &original);

void ReplaceAll(std::string *original,
                const std::string &find,
                const std::string &replace);

std::string EncodeString(const std::string &original);

bool StringToBool(const std::string &value, bool *output);

bool StringToBoolTolerant(const std::string &value, bool *output);

bool StringToInt(const std::string &value,
                 unsigned int *output,
                 bool strict = false);

bool StringToInt(const std::string &value,
                 uint16_t *output,
                 bool strict = false);

bool StringToInt(const std::string &value,
                 uint8_t *output,
                 bool strict = false);

bool StringToInt(const std::string &value, int *output, bool strict = false);

bool StringToInt(const std::string &value,
                 int16_t *output,
                 bool strict = false);

bool StringToInt(const std::string &value, int8_t *output, bool strict = false);

template <typename int_type>
int_type StringToIntOrDefault(const std::string &value,
                              int_type alternative,
                              bool strict = false) {
  int_type output;
  return (StringToInt(value, &output, strict)) ? output : alternative;
}

bool HexStringToInt(const std::string &value, uint8_t *output);

bool HexStringToInt(const std::string &value, uint16_t *output);

bool HexStringToInt(const std::string &value, uint32_t *output);

bool HexStringToInt(const std::string &value, int8_t *output);

bool HexStringToInt(const std::string &value, int16_t *output);

bool HexStringToInt(const std::string &value, int32_t *output);

void ToLower(std::string *s);

void ToUpper(std::string *s);

void CapitalizeLabel(std::string *s);

void CustomCapitalizeLabel(std::string *s);

inline void FormatData(std::ostream *out,
                       const uint8_t *data,
                       unsigned int length,
                       unsigned int indent = 0,
                       unsigned int byte_per_line = 8) {
  return ola::strings::FormatData(out, data, length, indent, byte_per_line);
}

template <typename int_type>
bool PrefixedHexStringToInt(const std::string &input, int_type *output) {
  if ((input.find("0x") != 0) && (input.find("0X") != 0))
    return false;
  std::string modified_input = input.substr(2);
  return HexStringToInt(modified_input, output);
}

template<typename T>
std::string StringJoin(const std::string &delim, const T &input) {
  std::ostringstream str;
  typename T::const_iterator iter = input.begin();
  while (iter != input.end()) {
    str << *iter++;
    if (iter != input.end())
      str << delim;
  }
  return str.str();
}
}  // namespace ola
#endif  // INCLUDE_OLA_STRINGUTILS_H_