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

void CapitalizeFirst(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_