C++ wstring::rend方法代码示例

    //theSingleNode is only valid if numNodes is 1.
    void
    ConvertNodesString(const std::wstring & includedNodes, boost::uint64_t & converted, int & numNodes, int & theSingleNode)
    {
        if (includedNodes.size() != static_cast<size_t>(NUM_NODES))
        {
            throw Dob::Typesystem::ConfigurationErrorException
                               (L"Length of IncludedNodes string must be 64",__WFILE__,__LINE__);
        }

        converted = 0;
        numNodes = 0;

        for (std::wstring::const_reverse_iterator it = includedNodes.rbegin(); it!= includedNodes.rend();++it)
        {
            if (*it == '-')
            {
                converted = converted << 1; //add a 0 to the end
            }
            else if (*it == '+')
            {
                converted = converted << 1 | 0x1; //add a 1 to the end
                theSingleNode = static_cast<int>(std::distance(it,includedNodes.rend()) - 1);
                ++numNodes;
            }
            else
            {
                throw Dob::Typesystem::ConfigurationErrorException(L"Illegal character in IncludedNodes string (can only be + or -)",__WFILE__,__LINE__);
            }
        }
    }

vFindRegex::vFindRegex(std::wstring patternInput, bool recursive)
{
    if (recursive)
        state = new RvFindRegex();
    else
        state = new NRvFindRegex();
    if (globalOptions::expandRegex && std::find(patternInput.begin(), patternInput.end(), L'\\') != patternInput.end())
    {
        DWORD len = GetLongPathName(patternInput.c_str(), NULL, NULL);
        wchar_t *tempExpandedPath = new wchar_t[len];
        GetLongPathName(patternInput.c_str(), tempExpandedPath, len);
        patternInput = tempExpandedPath;
        delete [] tempExpandedPath;
    }
    std::wstring::const_iterator middle(std::find(patternInput.rbegin(), patternInput.rend(), L'\\').base());
    if (middle == patternInput.begin())
    {
        regex = patternInput;
    } else
    {
        regex = std::wstring(middle, patternInput.end());
        pathRoot = std::wstring(patternInput.begin(), middle);
    }
    if (!fpattern_isvalid(regex.c_str()))
        throw L"There is an error in the syntax of your VFIND regular expression.";
    stripEscapes(pathRoot);
}

std::wstring wideShorten(const std::wstring &ws, size_t max_length)
{
	std::wstring result;
	if (wideLength(ws) > max_length)
	{
		const size_t half_max = max_length/2 - 1;
		size_t len = 0;
		// get beginning of string
		for (auto it = ws.begin(); it != ws.end(); ++it)
		{
			len += wcwidth(*it);
			if (len > half_max)
				break;
			result += *it;
		}
		len = 0;
		std::wstring end;
		// get end of string in reverse order
		for (auto it = ws.rbegin(); it != ws.rend(); ++it)
		{
			len += wcwidth(*it);
			if (len > half_max)
				break;
			end += *it;
		}
		// apply end of string to its beginning
		result += L"..";
		result.append(end.rbegin(), end.rend());
	}
	else
		result = ws;
	return result;
}

	/**
	* Trims the front/back of the string of whitespace
	*/
	static void trim_string(std::wstring& str)
	{
		str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](int ch) {
			return !std::isspace(ch);
		}));
		str.erase(std::find_if(str.rbegin(), str.rend(), [](int ch) {
			return !std::isspace(ch);
		}).base(), str.end());
	}

inline std::wstring trim(const std::wstring& str)
{
	std::wstring::const_iterator begin = std::find_if(str.begin(), str.end(), std::not1(std::ptr_fun(_istspace)));

	if (begin == str.end())
		begin = str.begin();

	std::wstring::const_reverse_iterator end = std::find_if(str.rbegin(), str.rend(), std::not1(std::ptr_fun(_istspace)));

	return std::wstring(begin, end.base());
}

const std::wstring tolower_and_del_delims(const std::wstring& str, const bool reverse)
{
	std::wstring ret_str;
	if(reverse) {
		remove_copy_if(str.rbegin(), str.rend(), std::back_inserter(ret_str), is_delim);	
	} else {
		remove_copy_if(str.begin(), str.end(), std::back_inserter(ret_str), is_delim);	
	}	
	std::transform(ret_str.begin(), ret_str.end(), ret_str.begin(), std::towlower);
	return ret_str;
}

void SyntaxHighlighter::Highlight(const std::wstring& s, SyntaxHighlighter::CallbackType highlight)
{
    if (s.empty())
        return;

    const int length = int(s.length());

    for (auto i = s.begin(); i != s.end(); ++i)
    {
        if (!u_isblank(*i))
        {
            int wlen = int(i - s.begin());
            if (wlen)
                highlight(0, wlen, LeadingWhitespace);
            break;
        }
    }

    for (auto i = s.rbegin(); i != s.rend(); ++i)
    {
        if (!u_isblank(*i))
        {
            int wlen = int(i - s.rbegin());
            if (wlen)
                highlight(length - wlen, length, LeadingWhitespace);
            break;
        }
    }

    for (auto i = s.begin(); i != s.end(); ++i)
    {
        if (*i == '\\')
        {
            int pos = int(i - s.begin());
            if (++i == s.end())
                break;
            // TODO: highlight full syntax, incl. octals: http://en.cppreference.com/w/cpp/language/escape
            switch (*i)
            {
                case '0':
                case 'n':
                case 'r':
                case 't':
                case '"':
                case '\\':
                    highlight(pos, pos + 2, Escape);
                    break;
                default:
                    break;
            }
        }
    }
}

	/**
	* Trims the specified character from the back of the string
	*/
	static void right_trim_string(std::wstring& str, wchar_t c)
	{
		str.erase(std::find_if(str.rbegin(), str.rend(), [c](const wchar_t& ch) {
			return ch != c;
		}).base(), str.end());
	}

std::wstring TrimEnd(std::wstring s)
{
	s.erase(std::find_if(s.rbegin(), s.rend(),
		std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
	return s;
}