1 /*

     2  * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include <stdio.h>

    27 #include <stdarg.h>

    28 #include <stdexcept>

    29 #include <algorithm>

    30 

    31 #include "tstrings.h"

    32 #include "ErrorHandling.h"

    33 

    34 

    35 namespace tstrings {

    36 

    37 /* Create formatted string

    38  */

    39 tstring unsafe_format(tstring::const_pointer format, ...) {

    40     if (!format) {

    41         throw std::invalid_argument("Destination buffer can't be NULL");

    42     }

    43 

    44     tstring fmtout;

    45     int ret;

    46     const int inc = 256;

    47 

    48     va_list args;

    49     va_start(args, format);

    50     do {

    51         fmtout.resize(fmtout.size() + inc);

    52 #ifdef _MSC_VER

    53         ret = _vsntprintf_s(&*fmtout.begin(), fmtout.size(), _TRUNCATE, format, args);

    54 #else

    55         // With g++ this compiles only with '-std=gnu++0x' option

    56         ret = vsnprintf(&*fmtout.begin(), fmtout.size(), format, args);

    57 #endif

    58     } while(-1 == ret);

    59     va_end(args);

    60 

    61     //update string size by actual value

    62     fmtout.resize(ret);

    63 

    64     return fmtout;

    65 }

    66 

    67 /*

    68  * Tests if two strings are equal according to CompareType.

    69  *

    70  * a - string to compare

    71  * b - string to compare

    72  * ct - CASE_SENSITIVE: case sensitive comparing type

    73  *      IGNORE_CASE: case insensitive comparing type

    74  */

    75 bool equals(const tstring& a, const tstring& b, const CompareType ct) {

    76     if (IGNORE_CASE==ct) {

    77         return toLower(a) == toLower(b);

    78     }

    79     return a == b;

    80 }

    81 

    82 bool startsWith(const tstring &str, const tstring &substr, const CompareType ct)

    83 {

    84     if (str.size() < substr.size()) {

    85         return false;

    86     }

    87     const tstring startOfStr = str.substr(0, substr.size());

    88     return tstrings::equals(startOfStr, substr, ct);

    89 }

    90 

    91 bool endsWith(const tstring &str, const tstring &substr, const CompareType ct)

    92 {

    93     if (str.size() < substr.size()) {

    94         return false;

    95     }

    96     const tstring endOfStr = str.substr(str.size() - substr.size());

    97     return tstrings::equals(endOfStr, substr, ct);

    98 }

    99 

   100 /*

   101  * Split string into a vector with given delimiter string

   102  *

   103  * strVector - string vector to store split tstring

   104  * str - string to split

   105  * delimiter - delimiter to split the string around

   106  * st - ST_ALL: return value includes an empty string

   107  *      ST_EXCEPT_EMPTY_STRING: return value does not include an empty string

   108  *

   109  * Note: It does not support multiple delimiters

   110  */

   111 void split(tstring_array &strVector, const tstring &str,

   112           const tstring &delimiter, const SplitType st) {

   113     tstring::size_type start = 0, end = 0, length = str.length();

   114 

   115     if (length == 0 || delimiter.length() == 0) {

   116         return;

   117     }

   118 

   119     end = str.find(delimiter, start);

   120     while(end != tstring::npos) {

   121         if(st == ST_ALL || end - start > 1 ) {

   122             strVector.push_back(str.substr(start, end == tstring::npos ?

   123                                                   tstring::npos : end - start));

   124         }

   125         start = end > (tstring::npos - delimiter.size()) ?

   126                 tstring::npos : end + delimiter.size();

   127         end = str.find(delimiter, start);

   128     }

   129 

   130     if(st == ST_ALL || start < length) {

   131         strVector.push_back(str.substr(start, length - start));

   132     }

   133 }

   134 

   135 /*

   136  * Convert uppercase letters to lowercase

   137  */

   138 tstring toLower(const tstring& str) {

   139     tstring lower(str);

   140     tstring::iterator ok = std::transform(lower.begin(), lower.end(),

   141                                           lower.begin(), tolower);

   142     if (ok!=lower.end()) {

   143         lower.resize(0);

   144     }

   145     return lower;

   146 }

   147 

   148 

   149 /*

   150  * Replace all substring occurrences in a tstring.

   151  * If 'str' or 'search' is empty the function returns 'str'.

   152  * The given 'str' remains unchanged in any case.

   153  * The function returns changed copy of 'str'.

   154  */

   155 tstring replace(const tstring &str, const tstring &search, const tstring &replace)

   156 {

   157     if (search.empty()) {

   158         return str;

   159     }

   160 

   161     tstring s(str);

   162 

   163     for (size_t pos = 0; ; pos += replace.length()) {

   164         pos = s.find(search, pos);

   165         if (pos == tstring::npos) {

   166             break;

   167         }

   168         s.erase(pos, search.length());

   169         s.insert(pos, replace);

   170     }

   171     return s;

   172 }

   173 

   174 

   175 /*

   176  * Remove trailing spaces

   177  */

   178 

   179 tstring trim(const tstring& str, const tstring& whitespace) {

   180     const size_t strBegin = str.find_first_not_of(whitespace);

   181     if (strBegin == std::string::npos) {

   182         return tstring(); // no content

   183     }

   184 

   185     const size_t  strEnd = str.find_last_not_of(whitespace);

   186     const size_t strRange = strEnd - strBegin + 1;

   187 

   188     return str.substr(strBegin, strRange);

   189 }

   190 

   191 } // namespace tstrings

   192 

   193 

   194 #ifdef TSTRINGS_WITH_WCHAR

   195 namespace tstrings {

   196 

   197 namespace {

   198 /*

   199  * Converts UTF16-encoded string into multi-byte string of the given encoding.

   200  */

   201 std::string toMultiByte(const std::wstring& utf16str, int encoding) {

   202     std::string reply;

   203     do {

   204         int cm = WideCharToMultiByte(encoding,

   205                                     0,

   206                                     utf16str.c_str(),

   207                                     int(utf16str.size()),

   208                                     NULL,

   209                                     0,

   210                                     NULL,

   211                                     NULL);

   212         if (cm < 0) {

   213             JP_THROW("Unexpected reply from WideCharToMultiByte()");

   214         }

   215         if (0 == cm) {

   216             break;

   217         }

   218 

   219         reply.resize(cm);

   220         int cm2 = WideCharToMultiByte(encoding,

   221                                     0,

   222                                     utf16str.c_str(),

   223                                     int(utf16str.size()),

   224                                     &*reply.begin(),

   225                                     cm,

   226                                     NULL,

   227                                     NULL);

   228         if (cm != cm2) {

   229             JP_THROW("Unexpected reply from WideCharToMultiByte()");

   230         }

   231     } while(0);

   232 

   233     return reply;

   234 }

   235 

   236 /*

   237  * Converts multi-byte string of the given encoding into UTF16-encoded string.

   238  */

   239 std::wstring fromMultiByte(const std::string& str, int encoding) {

   240     std::wstring utf16;

   241     do {

   242         int cw = MultiByteToWideChar(encoding,

   243                                     MB_ERR_INVALID_CHARS,

   244                                     str.c_str(),

   245                                     int(str.size()),

   246                                     NULL,

   247                                     0);

   248         if (cw < 0) {

   249             JP_THROW("Unexpected reply from MultiByteToWideChar()");

   250         }

   251         if (0 == cw) {

   252             break;

   253         }

   254 

   255         utf16.resize(cw);

   256         int cw2 = MultiByteToWideChar(encoding,

   257                                     MB_ERR_INVALID_CHARS,

   258                                     str.c_str(),

   259                                     int(str.size()),

   260                                     &*utf16.begin(),

   261                                     cw);

   262         if (cw != cw2) {

   263             JP_THROW("Unexpected reply from MultiByteToWideChar()");

   264         }

   265     } while(0);

   266 

   267     return utf16;

   268 }

   269 } // namespace

   270 

   271 std::string toUtf8(const std::wstring& utf16str) {

   272     return toMultiByte(utf16str, CP_UTF8);

   273 }

   274 

   275 std::wstring toUtf16(const std::string& utf8str) {

   276     return fromMultiByte(utf8str, CP_UTF8);

   277 }

   278 

   279 } // namespace tstrings

   280 #endif // ifdef TSTRINGS_WITH_WCHAR