p2p/lib/dt_p2p/stingray_sdk/plugin_foundation/string.inl

#include <ctype.h>

namespace stingray_plugin_foundation {

// ----------------------------------------------------------------------
// C string methods
// ----------------------------------------------------------------------

inline unsigned strlen32(const char *s)
{
	return (unsigned)strlen(s);
}

inline unsigned strlenw32(const wchar_t *s)
{
	const wchar_t *e = s;
	while (*e) ++e;
	return (unsigned)(e-s);
}

inline bool strequal(const char *s1, const char *s2)
{
	return strcmp(s1, s2) == 0;
}

inline bool strequali(const char *s1, const char *s2)
{
	while (*s1 && *s2) {
		if (*s1 != *s2) {
			if (tolower(*s1) != tolower(*s2))
				return false;
		}
		++s1; ++s2;
	}
	return *s1 == *s2;
}


inline bool strempty(const char *s)
{
	return *s == 0;
}

inline int to_int(const char *s)
{
	return (int)strtol(s, nullptr, 10);
}

inline float to_float(const char *s)
{
	return float(strtod(s, nullptr));
}

inline unsigned to_unsigned(const char *s)
{
	return (unsigned)strtoul(s, nullptr, 10);
}

inline int to_int(const char *s, bool &error)
{
	char *e;
	int i = (int)strtol(s, &e, 10);
	error = *s == 0 || *e != 0;
	return i;
}

inline float to_float(const char *s, bool &error)
{
	char *e;
	float f = float(strtod(s, &e));
	error = *s == 0 || *e != 0;
	return f;
}

inline unsigned to_unsigned(const char *s, bool &error)
{
	char *e;
	unsigned u = (unsigned)strtoul(s, &e, 10);
	error = *s == 0 || *e != 0;
	return u;
}

// ----------------------------------------------------------------------
// ConstString
// ----------------------------------------------------------------------


// ----------------------------------------------------------------------
// DynamicString
// ----------------------------------------------------------------------

inline void DynamicString::swap(DynamicString &other)
{
	_buffer.swap(other._buffer);
}

inline void append(DynamicString &str, const char *s)
{
	str.extend(strlen32(s));
	strcat(str.c_str(), s);
}

inline void append(DynamicString &str, const char *s, unsigned len)
{
	str.extend(len);
	strncat(str.c_str(), s, len);
}

inline void append(DynamicString &str, char c)
{
	str.extend(1);
	str.end()[-1] = c;
}

inline void prefix(DynamicString &str, const char *s)
{
	unsigned len = strlen32(s);
	str.extend(len);
	memmove(str.buffer().begin() + len, str.buffer().begin(), str.buffer().size() - len);
	memcpy(str.buffer().begin(), s, len);
}

// ----------------------------------------------------------------------
// string methods
// ----------------------------------------------------------------------

inline bool string::is_whitespace(char c)
{
	return c == '\t' || c == ' ' || c == '\n' || c == '\r';
}

inline const char *string::spaces(int n)
{
	const char *s =
		"          " "          " "          " "          " "          "
		"          " "          " "          " "          " "          "
		"          " "          " "          " "          " "          "
		"          " "          " "          " "          " "          ";
	if (n > 200)
		n = 200;
	return s + 200 - n;
}

inline bool string::contains(const char *s, const char *substring)
{
	return string::find(s, substring) != string::npos;
}

inline unsigned string::find_last(const char *s, char c)
{
	unsigned n = strlen32(s);
	for (int i=n - 1; i >= 0; --i) {
		if (s[i] == c)
			return i;
	}
	return npos;
}

inline unsigned string::find(const char *s, char c)
{
	unsigned n = strlen32(s);
	for (unsigned i=0; i<=n; ++i) {
		if (s[i] == c)
			return i;
	}
	return npos;
}

inline unsigned string::find(const char *s, const char *substring)
{
	unsigned n = strlen32(s) - strlen32(substring);
	if (n > 0x80000000)
		return npos;
	for (unsigned i=0; i<=n; ++i) {
		for (unsigned j=0;; ++j) {
			if (substring[j] == 0)
				return i;
			if (s[i+j] != substring[j])
				break;
		}
	}
	return npos;
}

inline void string::split(const char *s, const char *split_on, DynamicString &first, DynamicString &second)
{
	unsigned pos = find(s, split_on);
	if (pos == npos) {
		first = s;
		second.clear();
	} else {
		unsigned s_n = strlen32(s);
		unsigned split_on_n = strlen32(split_on);
		first.resize(pos);
		memmove(&first[0], &s[0], pos);
		second.resize(s_n - pos - split_on_n);
		memmove(&second[0], &s[pos + split_on_n], s_n - pos - split_on_n);
	}
}

// Cannot be defined in plugin_foundation at the moment. The Scaleform plugin
// includes string.h, and the plugin also removes the PS4 platform define,
// leading to __forceinline being undefined when compiling PS4. A fix is in the
// works. For now, defining this function in Wwise plugin (its only use)
// inline void string::split(const char *s, const char *split_by, Vector<DynamicString> &result)
// {
// 	Allocator & allocator = result.allocator();
// 	DynamicString a(allocator), b(allocator);
// 	string::split(s, split_by, a, b);
// 	while( !a.empty() ) {
// 		result.resize(result.size() + 1);
// 		result.back() = a;
// 		if( b.empty() )
// 			break;
// 		DynamicString temp = b;
// 		string::split(temp.c_str(), split_by, a, b);
// 	}
// }

// ----------------------------------------------------------------------

} // namespace stingray_plugin_foundation