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 <stdint.h>
#include <limits>
#include <sstream>
#include <string>
#include <vector>

namespace ola {

enum { HEX_BIT_WIDTH = 4 };

void StringSplit(const std::string &input,
                 std::vector<std::string> &tokens,  // NOLINT
                 const std::string &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);

std::string IntToString(int i);

std::string IntToString(unsigned int i);

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

inline std::string IntToHexString(uint8_t i) {
  return IntToHexString(i, (std::numeric_limits<uint8_t>::digits /
                            HEX_BIT_WIDTH));
}

inline std::string IntToHexString(uint16_t i) {
  return IntToHexString(i, (std::numeric_limits<uint16_t>::digits /
                            HEX_BIT_WIDTH));
}

inline std::string IntToHexString(uint32_t i) {
  return IntToHexString(i, (std::numeric_limits<uint32_t>::digits /
                            HEX_BIT_WIDTH));
}

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

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

void FormatData(std::ostream *out,
                const uint8_t *data,
                unsigned int length,
                unsigned int indent = 0,
                unsigned int byte_per_line = 8);

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_