C++ string_view::substr方法代码示例

std::string environment_expand(std::string_view s) {
	std::string r;
	size_t start_pos = 0;
	size_t dollar_pos;
	while ((dollar_pos = s.find('$', start_pos)) != s.npos) {
		r += s.substr(start_pos, dollar_pos - start_pos);
		std::string varname;
		if (dollar_pos + 1 < s.length() && s[dollar_pos + 1] == '{') {
			size_t dollar_end = s.find('}', dollar_pos + 2);
			if (dollar_end == s.npos) {
				break;
			}
			varname = s.substr(dollar_pos + 2, dollar_end - (dollar_pos + 2));
			start_pos = dollar_end + 1;
		} else {
			size_t dollar_end = s.find_first_not_of("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_"sv, dollar_pos + 1);
			varname = s.substr(dollar_pos + 1, dollar_end - (dollar_pos + 1));
			start_pos = dollar_end;
		}
		if (const char *varval = getenv (varname.c_str ())) {
			r += varval;
		}
	}
	if (start_pos < s.length()) {
		r += s.substr(start_pos);
	}
	return r;
}

inline std::pair<std::string_view, std::string_view> splitAt( std::string_view str, char splitter ){
	auto pos = str.find( splitter );
	if( pos == std::string_view::npos )
		return { str, {} };
	else
		return { str.substr( 0, pos ), str.substr( pos+1 ) };
}

	std::pair<std::string_view, std::string_view> splitStringIn2(
		const std::string_view str, char delimiter)
	{
		auto pos = str.find(delimiter, 0);
		if (pos != std::string::npos)
		{
			return std::make_pair(str.substr(0, pos), str.substr(pos + 1, str.size() - pos));
		}
		return std::make_pair(str, "");
	}

inline std::vector<std::string_view> splitAllOn( std::string_view str, char splitter ){
	std::vector<std::string_view> splits;
	
	size_t last=0, pos = 0;
	while( (pos = str.find(splitter, last)) != std::string_view::npos ){
		splits.push_back( str.substr( last, pos-last ) );
		last = pos+1;
	}
	splits.push_back( str.substr( last ) );
	
	return splits;
}

	std::vector<std::string> splitString(const std::string_view str, char delimiter)
	{
		std::vector<std::string> strings;

		std::string_view::size_type pos = 0;
		std::string_view::size_type prev = 0;
		while ((pos = str.find(delimiter, prev)) != std::string::npos)
		{
			strings.push_back(std::string(str.substr(prev, pos - prev)));
			prev = pos + 1;
		}

		strings.push_back(std::string(str.substr(prev)));

		return strings;
	}

static std::string_view hash_from_url( std::string_view url ){
	size_t start = url.find_last_of( '/' ) + 1;
	size_t end = url.find_last_of( '.' );
	
	//Validate results
	if( start == string::npos || end == string::npos || start >= url.size() )
		return "";
	else
		return url.substr( start, end-start );
}

inline std::string StringFromHex(const std::string_view& input)
{
    assert((input.size() & 1) == 0);

    std::string result;
    result.reserve(input.size() / 2);
    for (size_t i = 0; i < input.size(); i += 2)
    {
        auto val = std::stoi(std::string(input.substr(i, 2)), 0, 16);
        result.push_back(val);
    }
    return result;
}

double Calculator::parseFunction(std::string_view &ref)
{
	try
	{
		std::string_view partStr = ref.substr(0, 3);

		if (partStr == std::string_view("sin"))
		{
			ref.remove_prefix(3);
			m_printStrategy->printFunctionName("sin");
			return sin(ParseArguments(ref) * M_PI / 180);
		}
		else if (partStr == std::string_view("cos"))
		{
			ref.remove_prefix(3);
			m_printStrategy->printFunctionName("cos");
			return cos(ParseArguments(ref) * M_PI / 180);
		}
		else
		{
			std::string_view partStr = ref.substr(0, 4);

			if (partStr == std::string_view("sqrt"))
			{
				ref.remove_prefix(4);
				m_printStrategy->printFunctionName("sqrt");
				return sqrt(ParseArguments(ref));
			}
		}
	}
	catch(const std::out_of_range&)
	{
		return std::numeric_limits<double>::quiet_NaN();
	}
	
	return std::numeric_limits<double>::quiet_NaN();
}

inline std::string_view trim( std::string_view str ){
	auto first = str.find_first_not_of( ' ' );
	auto last  = str.find_last_not_of(  ' ' );
	auto chars_removed = first + (str.size()-last-1);
	return str.substr( first, str.size() - chars_removed );
}

inline std::string_view removePostfix( std::string_view str, std::string_view postfix ){
	if( !ends_with( str, postfix ) )
		throw std::logic_error( std::string(str) + " does not end with " + std::string(postfix) );
	return str.substr( str.size() - postfix.size() );
}

inline bool ends_with( std::string_view input, std::string_view match ){
	if( input.length() >= match.length() )
		return input.substr( input.size() - match.length() ) == match;
	return false;
}

inline bool starts_with( std::string_view input, std::string_view match ){
	if( input.length() >= match.length() )
		return input.substr( 0, match.length() ) == match;
	return false;
}

std::string_view removeSuffix(std::string_view a, std::string_view b)
{
    ASSERT(endsWith(a, b));
    return a.substr(0, a.size() - b.size());
}

bool endsWith(std::string_view a, std::string_view b)
{
    return a.size() >= b.size() && a.substr(a.size() - b.size()) == b;
}

bool startsWith(std::string_view a, std::string_view b)
{
    return a.size() >= b.size() && a.substr(0, b.size()) == b;
}