| // Licensed to the Software Freedom Conservancy (SFC) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The SFC licenses this file | |
| // to you under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "StringUtilities.h" | |
| #define WHITESPACE " \n\r\t" | |
| #define WIDE_WHITESPACE L" \n\r\t" | |
| namespace webdriver { | |
| StringUtilities::StringUtilities(void) { | |
| } | |
| StringUtilities::~StringUtilities(void) { | |
| } | |
| std::wstring StringUtilities::ToWString(const std::string& input) { | |
| // Assumption: The wstring character count will be the same as the length of | |
| // the string character count. Allocate the buffer with that many wchar_t items | |
| // so that the first MultiByteToWideChar call will succeed most of the time as | |
| // an optimization. | |
| std::wstring output = L""; | |
| int input_string_byte_count = static_cast<int>(input.size()) + 1; | |
| int wide_string_length = input_string_byte_count; | |
| std::vector<wchar_t> output_buffer(wide_string_length); | |
| bool convert_failed = (0 == ::MultiByteToWideChar(CP_UTF8, | |
| 0, | |
| input.c_str(), | |
| input_string_byte_count, | |
| &output_buffer[0], | |
| wide_string_length)); | |
| if (convert_failed) { | |
| if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER) { | |
| // Buffer wasn't big enough. Call MultiByteToWideChar again with | |
| // NULL values to determine how big the buffer should be. | |
| wide_string_length = ::MultiByteToWideChar(CP_UTF8, | |
| 0, | |
| input.c_str(), | |
| input_string_byte_count, | |
| NULL, | |
| 0); | |
| output_buffer.resize(wide_string_length); | |
| convert_failed = (0 == ::MultiByteToWideChar(CP_UTF8, | |
| 0, | |
| input.c_str(), | |
| input_string_byte_count, | |
| &output_buffer[0], | |
| wide_string_length)); | |
| if (!convert_failed) { | |
| output = &output_buffer[0]; | |
| } | |
| } | |
| } else { | |
| output = &output_buffer[0]; | |
| } | |
| return output; | |
| } | |
| std::string StringUtilities::ToString(const std::wstring& input) { | |
| // Assumption: The byte count of the resulting narrow string will be at most | |
| // four times the character count of the input wstring. Allocate the buffer | |
| // with that many char items (bytes) so that the first WideCharToMultiByte | |
| // call will succeed most of the time as an optimization. | |
| std::string output = ""; | |
| int wide_string_length = static_cast<int>(input.size()) + 1; | |
| int output_string_byte_count = wide_string_length * 4; | |
| std::vector<char> string_buffer(output_string_byte_count); | |
| bool convert_failed = (0 == ::WideCharToMultiByte(CP_UTF8, | |
| 0, | |
| input.c_str(), | |
| wide_string_length, | |
| &string_buffer[0], | |
| output_string_byte_count, | |
| NULL, | |
| NULL)); | |
| if (convert_failed) { | |
| if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER) { | |
| // Buffer wasn't big enough. Call WideCharToMultiByte again with | |
| // NULL values to determine how big the buffer should be. | |
| output_string_byte_count = ::WideCharToMultiByte(CP_UTF8, | |
| 0, | |
| input.c_str(), | |
| wide_string_length, | |
| NULL, | |
| 0, | |
| NULL, | |
| NULL); | |
| string_buffer.resize(output_string_byte_count); | |
| convert_failed = (0 == ::WideCharToMultiByte(CP_UTF8, | |
| 0, | |
| input.c_str(), | |
| wide_string_length, | |
| &string_buffer[0], | |
| output_string_byte_count, | |
| NULL, | |
| NULL)); | |
| if (!convert_failed) { | |
| output = &string_buffer[0]; | |
| } | |
| } | |
| } else { | |
| output = &string_buffer[0]; | |
| } | |
| return output; | |
| } | |
| std::string StringUtilities::Format(const char* format, ...) { | |
| va_list args; | |
| va_start(args, format); | |
| size_t buffer_size = _vscprintf(format, args); | |
| std::vector<char> buffer(buffer_size + 1); | |
| _vsnprintf_s(&buffer[0], buffer.size(), buffer_size + 1, format, args); | |
| va_end(args); | |
| std::string formatted = &buffer[0]; | |
| return formatted; | |
| } | |
| std::wstring StringUtilities::Format(const wchar_t* format, ...) { | |
| va_list args; | |
| va_start(args, format); | |
| size_t buffer_size = _vscwprintf(format, args); | |
| std::vector<wchar_t> buffer(buffer_size + 1); | |
| _vsnwprintf_s(&buffer[0], buffer.size(), buffer_size + 1, format, args); | |
| va_end(args); | |
| std::wstring formatted = &buffer[0]; | |
| return formatted; | |
| } | |
| void StringUtilities::ToBuffer(const std::string& input, std::vector<char>* buffer) { | |
| buffer->resize(input.size() + 1); | |
| strcpy_s(&((*buffer)[0]), buffer->size(), input.c_str()); | |
| (*buffer)[buffer->size() - 1] = L'\0'; | |
| } | |
| void StringUtilities::ToBuffer(const std::wstring& input, std::vector<wchar_t>* buffer) { | |
| buffer->resize(input.size() + 1); | |
| wcscpy_s(&((*buffer)[0]), buffer->size(), input.c_str()); | |
| (*buffer)[buffer->size() - 1] = L'\0'; | |
| } | |
| std::string StringUtilities::Trim(const std::string& input) { | |
| return TrimRight(TrimLeft(input)); | |
| } | |
| std::string StringUtilities::TrimLeft(const std::string& input) { | |
| size_t startpos = input.find_first_not_of(WHITESPACE); | |
| return (startpos == std::string::npos) ? "" : input.substr(startpos); | |
| } | |
| std::string StringUtilities::TrimRight(const std::string& input) { | |
| size_t endpos = input.find_last_not_of(WHITESPACE); | |
| return (endpos == std::string::npos) ? "" : input.substr(0, endpos + 1); | |
| } | |
| std::wstring StringUtilities::Trim(const std::wstring& input) { | |
| return TrimRight(TrimLeft(input)); | |
| } | |
| std::wstring StringUtilities::TrimLeft(const std::wstring& input) { | |
| size_t startpos = input.find_first_not_of(WIDE_WHITESPACE); | |
| return (startpos == std::wstring::npos) ? L"" : input.substr(startpos); | |
| } | |
| std::wstring StringUtilities::TrimRight(const std::wstring& input) { | |
| size_t endpos = input.find_last_not_of(WIDE_WHITESPACE); | |
| return (endpos == std::wstring::npos) ? L"" : input.substr(0, endpos + 1); | |
| } | |
| void StringUtilities::Split(const std::string& input, | |
| const std::string& delimiter, | |
| std::vector<std::string>* tokens) { | |
| std::string input_copy = input; | |
| while (input_copy.size() > 0) { | |
| size_t delimiter_pos = input_copy.find(delimiter); | |
| std::string token = input_copy.substr(0, delimiter_pos); | |
| if (delimiter_pos == std::string::npos) { | |
| input_copy = ""; | |
| } else { | |
| input_copy = input_copy.substr(delimiter_pos + delimiter.size()); | |
| } | |
| tokens->push_back(token); | |
| } | |
| } | |
| void StringUtilities::Split(const std::wstring& input, | |
| const std::wstring& delimiter, | |
| std::vector<std::wstring>* tokens) { | |
| std::wstring input_copy = input; | |
| while (input_copy.size() > 0) { | |
| size_t delimiter_pos = input_copy.find(delimiter); | |
| std::wstring token = input_copy.substr(0, delimiter_pos); | |
| if (delimiter_pos == std::wstring::npos) { | |
| input_copy = L""; | |
| } else { | |
| input_copy = input_copy.substr(delimiter_pos + delimiter.size()); | |
| } | |
| tokens->push_back(token); | |
| } | |
| } | |
| std::wstring StringUtilities::CreateGuid() { | |
| UUID guid; | |
| RPC_WSTR guid_string = NULL; | |
| RPC_STATUS status = ::UuidCreate(&guid); | |
| if (status != RPC_S_OK) { | |
| // If we encounter an error, not bloody much we can do about it. | |
| // Just log it and continue. | |
| // LOG(WARN) << "UuidCreate returned a status other then RPC_S_OK: " << status; | |
| } | |
| status = ::UuidToString(&guid, &guid_string); | |
| if (status != RPC_S_OK) { | |
| // If we encounter an error, not bloody much we can do about it. | |
| // Just log it and continue. | |
| // LOG(WARN) << "UuidToString returned a status other then RPC_S_OK: " << status; | |
| } | |
| // RPC_WSTR is currently typedef'd in RpcDce.h (pulled in by rpc.h) | |
| // as unsigned short*. It needs to be typedef'd as wchar_t* | |
| wchar_t* cast_guid_string = reinterpret_cast<wchar_t*>(guid_string); | |
| std::wstring returned_guid(cast_guid_string); | |
| ::RpcStringFree(&guid_string); | |
| return returned_guid; | |
| } | |
| void StringUtilities::ComposeUnicodeString(std::wstring* input) { | |
| StringUtilities::NormalizeUnicodeString(NormalizationC, input); | |
| } | |
| void StringUtilities::DecomposeUnicodeString(std::wstring* input) { | |
| StringUtilities::NormalizeUnicodeString(NormalizationD, input); | |
| } | |
| void StringUtilities::NormalizeUnicodeString(NORM_FORM normalization_form, | |
| std::wstring* input) { | |
| if (FALSE == ::IsNormalizedString(normalization_form, input->c_str(), -1)) { | |
| int required = ::NormalizeString(normalization_form, | |
| input->c_str(), | |
| -1, | |
| NULL, | |
| 0); | |
| std::vector<wchar_t> buffer(required); | |
| ::NormalizeString(normalization_form, | |
| input->c_str(), | |
| -1, | |
| &buffer[0], | |
| static_cast<int>(buffer.size())); | |
| *input = &buffer[0]; | |
| } | |
| } | |
| } // namespace webdriver |