hasherezade-pe-sieve/utils/format_util.cpp

#include "format_util.h"

#include <algorithm>
#include <sstream>
#include <iomanip>
#include <cctype>

namespace pesieve {
	namespace util {

		bool is_hex(const char *buf, size_t len)
		{
			for (size_t i = 0; i < len; i++) {
				if (buf[i] >= '0' && buf[i] <= '9') continue;
				if (buf[i] >= 'A' && buf[i] <= 'F') continue;
				if (buf[i] >= 'a' && buf[i] <= 'f') continue;
				return false;
			}
			return true;
		}

		bool is_dec(const char *buf, size_t len)
		{
			for (size_t i = 0; i < len; i++) {
				if (buf[i] >= '0' && buf[i] <= '9') continue;
				return false;
			}
			return true;
		}

	};
};

long pesieve::util::get_number(const char *my_buf)
{
	const char hex_pattern[] = "0x";
	size_t hex_pattern_len = strlen(hex_pattern);

	const size_t len = strlen(my_buf);
	if (len == 0) return 0;

	long out = 0;
	const size_t min_length = 1; //tolerate number with at least 1 character
	if (len > hex_pattern_len) {
		if (is_cstr_equal(my_buf, hex_pattern, hex_pattern_len)) {
			if (!is_hex(my_buf + hex_pattern_len, min_length)) return 0;

			std::stringstream ss;
			ss << std::hex << my_buf;
			ss >> out;
			return out;
		}
	}
	if (!is_dec(my_buf, min_length)) return 0;

	std::stringstream ss;
	ss << std::dec << my_buf;
	ss >> out;
	return out;
}

bool pesieve::util::is_number(const char* my_buf)
{
	const char hex_pattern[] = "0x";
	size_t hex_pattern_len = strlen(hex_pattern);

	const size_t len = strlen(my_buf);
	if (len == 0) return false;

	if (len > hex_pattern_len) {
		if (is_cstr_equal(my_buf, hex_pattern, hex_pattern_len)) {
			if (!is_hex(my_buf + hex_pattern_len, len - hex_pattern_len)) return false;

			return true;
		}
	}
	if (!is_dec(my_buf, len)) return false;
	return true;
}

bool pesieve::util::is_in_list(std::string searched_str, std::set<std::string>& string_list, bool to_lower)
{
	bool result = false;
	if (to_lower) {
		std::transform(searched_str.begin(), searched_str.end(), searched_str.begin(), [](unsigned char c){ return std::tolower(c); });
	}
	std::set<std::string>::iterator found = string_list.find(searched_str);
	if (found != string_list.end()) {
		result = true;
	}
	return result;
}

namespace pesieve {
	namespace util {

		std::string& ltrim(std::string& str, const std::string& chars = "\t\n\v\f\r ")
		{
			str.erase(0, str.find_first_not_of(chars));
			return str;
		}

		std::string& rtrim(std::string& str, const std::string& chars = "\t\n\v\f\r ")
		{
			str.erase(str.find_last_not_of(chars) + 1);
			return str;
		}

		std::string& trim(std::string& str, const std::string& chars = "\t\n\v\f\r ")
		{
			return ltrim(rtrim(str, chars), chars);
		}
	}
};

size_t pesieve::util::string_to_list(IN::std::string s, IN char _delim, OUT::std::set<::std::string>& elements_list, bool to_lower)
{
	std::string delim(std::string(1, _delim));
	size_t start = 0;
	size_t end = s.find(delim);
	while (end != std::string::npos)
	{
		std::string next_str = s.substr(start, end - start);
		trim(next_str);
		if (next_str.length() > 0) {
			if (to_lower) {
				std::transform(next_str.begin(), next_str.end(), next_str.begin(), [](unsigned char c){ return std::tolower(c); });
			}
			elements_list.insert(next_str);
		}
		start = end + delim.length();
		end = s.find(delim, start);
	}
	std::string next_str = s.substr(start, end);
	trim(next_str);
	if (next_str.length() > 0) {
		if (to_lower) {
			std::transform(next_str.begin(), next_str.end(), next_str.begin(), [](unsigned char c){ return std::tolower(c); });
		}
		elements_list.insert(next_str);
	}
	return elements_list.size();
}