source/string.cpp

   1 #include <ail/string.hpp>
   2 #include <ail/array.hpp>
   3
   4 namespace ail
   5 {
   6         bool is_alpha(char input)
   7         {
   8                 return (input >= 'A' && input <= 'Z') || (input >= 'a' && input <= 'z');
   9         }
  10
  11         bool is_digit(char input)
  12         {
  13                 return input >= '0' && input <= '9';
  14         }
  15
  16         bool is_oct_digit(char input)
  17         {
  18                 return input >= '0' && input <= '7';
  19         }
  20
  21         bool is_hex_digit(char input)
  22         {
  23                 return is_digit(input) || (input >= 'a' && input <= 'f') || (input >= 'A' && input <= 'F');
  24         }
  25
  26         bool is_whitespace(char input)
  27         {
  28                 return input == '\t' || input == '\n' || input == '\r' || input == ' ';
  29         }
  30
  31         char to_upper(char input)
  32         {
  33                 char output = input;
  34                 if(output >= 'a' && output <= 'z')
  35                         output -= 32;
  36                 return output;
  37         }
  38
  39         char to_lower(char input)
  40         {
  41                 char output = input;
  42                 if(output >= 'A' && output <= 'Z')
  43                         output += 32;
  44                 return output;
  45         }
  46
  47         std::string to_upper(std::string const & input)
  48         {
  49                 std::string output = input;
  50                 for(std::string::iterator i = output.begin(), end = output.end(); i != end; ++i)
  51                 {
  52                         char & current_char = *i;
  53                         current_char = to_upper(current_char);
  54                 }
  55                 return output;
  56         }
  57
  58         std::string to_lower(std::string const & input)
  59         {
  60                 std::string output = input;
  61                 for(std::string::iterator i = output.begin(), end = output.end(); i != end; ++i)
  62                 {
  63                         char & current_char = *i;
  64                         current_char = to_lower(current_char);
  65                 }
  66                 return output;
  67         }
  68
  69         std::string left_trim(std::string const & input)
  70         {
  71                 std::string output = input;
  72                 std::string::iterator
  73                         begin = output.begin(),
  74                         end = output.end();
  75
  76                 for(;; ++begin)
  77                 {
  78                         if(begin >= end)
  79                                 return "";
  80
  81                         if(is_whitespace(*begin) == false)
  82                                 break;
  83                 }
  84
  85                 output.erase(output.begin(), begin);
  86
  87                 return output;
  88         }
  89
  90         std::string right_trim(std::string const & input)
  91         {
  92                 std::string output = input;
  93                 std::string::iterator
  94                         end = output.end();
  95
  96                 for(end -= 1; is_whitespace(*end); --end);
  97
  98                 output.erase(end + 1, output.end());
  99
 100                 return output;
 101         }
 102
 103         std::string trim(std::string const & input)
 104         {
 105                 std::string output = input;
 106                 std::string::iterator
 107                         begin = output.begin(),
 108                         end = output.end();
 109
 110                 for(;; ++begin)
 111                 {
 112                         if(begin >= end)
 113                                 return "";
 114
 115                         if(is_whitespace(*begin) == false)
 116                                 break;
 117                 }
 118
 119                 for(end -= 1; is_whitespace(*end); --end);
 120
 121                 std::size_t offset_begin = begin - output.begin();
 122                 std::size_t offset_end = end - output.begin();
 123                 output = output.substr(offset_begin, offset_end - offset_begin + 1);
 124
 125                 return output;
 126         }
 127
 128         unsigned long count_strings(std::string const & input, std::string const & target)
 129         {
 130                 if(input.empty() == true)
 131                         return 0;
 132
 133                 if(target.empty() == true)
 134                         throw exception("Empty target");
 135
 136                 unsigned long output = 0;
 137
 138                 std::size_t target_length = target.length();
 139                 std::size_t result = input.find(target);
 140
 141                 while(result != std::string::npos)
 142                 {
 143                         ++output;
 144                         result = input.find(target, result + target_length);
 145                 }
 146
 147                 return output;
 148         }
 149
 150         std::string erase_string(std::string const & input, std::string const & target)
 151         {
 152                 std::stringstream output;
 153
 154                 if(target.empty())
 155                         return input;
 156
 157                 std::size_t
 158                         target_length = target.length(),
 159                         offset = input.find(target),
 160                         last_offset = 0;
 161
 162                 while(offset != std::string::npos)
 163                 {
 164                         output << input.substr(last_offset, offset - last_offset);
 165                         offset += target_length;
 166                         last_offset = offset;
 167                         offset = input.find(target, offset);
 168                 }
 169
 170                 output << input.substr(last_offset);
 171
 172                 return output.str();
 173         }
 174
 175         std::string replace_string(std::string const & input, std::string const & target, std::string const & replacement)
 176         {
 177                 std::string output = input;
 178
 179                 if(target.empty() == true)
 180                         throw exception("Empty target");
 181
 182                 if(target == replacement)
 183                         return input;
 184
 185                 std::size_t target_length = target.length();
 186                 std::size_t replacement_length = replacement.length();
 187
 188                 std::size_t result = output.find(target);
 189
 190                 while(result != std::string::npos)
 191                 {
 192                         output.replace(result, target_length, replacement);
 193                         result = output.find(target, result);
 194                 }
 195
 196                 return output;
 197         }
 198
 199         /*
 200         void tokenise(std::string const & input, string_vector & output, char delimiter)
 201         {
 202                 std::string token;
 203                 std::istringstream stream(input);
 204                 while(std::getline(stream, token, delimiter))
 205                                 output.push_back(token);
 206         }
 207         */
 208
 209         void tokenise(std::string const & input, std::string const & delimiter, string_vector & output)
 210         {
 211                 std::size_t
 212                         delimiter_length = delimiter.length(),
 213                         left = 0,
 214                         right = input.find(delimiter),
 215                         count = 1;
 216
 217                 while(right != std::string::npos)
 218                 {
 219                         std::string new_token(input.substr(left, right - left));
 220                         left = right + delimiter_length;
 221                         right = input.find(delimiter, left);
 222                         count++;
 223                 }
 224
 225                 left = 0;
 226                 right = input.find(delimiter);
 227
 228                 output.reserve(count);
 229
 230                 while(right != std::string::npos)
 231                 {
 232                         std::string new_token(input.substr(left, right - left));
 233                         output.push_back(new_token);
 234                         left = right + delimiter_length;
 235                         right = input.find(delimiter, left);
 236                 }
 237
 238                 output.push_back(input.substr(left));
 239         }
 240
 241         string_vector tokenise(std::string const & input, std::string const & delimiter)
 242         {
 243                 string_vector output;
 244                 tokenise(input, delimiter, output);
 245                 return output;
 246         }
 247
 248         std::string join_strings(std::vector<std::string> const & input, std::string const & delimiter)
 249         {
 250                 std::string output;
 251                 std::vector<std::string>::const_iterator
 252                         i = input.begin(),
 253                         end = input.end();
 254                 if(i != end)
 255                 {
 256                         output = *i;
 257                         for(++i; i != end; ++i)
 258                         {
 259                                 output += delimiter + *i;
 260                         }
 261                 }
 262                 return output;
 263         }
 264
 265         bool string_to_bool(std::string const & input, bool & output)
 266         {
 267                 if(input == "true" || input == "1")
 268                 {
 269                         output = true;
 270                         return true;
 271                 }
 272                 else if(input == "false" || input == "0")
 273                 {
 274                         output = false;
 275                         return true;
 276                 }
 277
 278                 return false;
 279         }
 280
 281         std::string bool_to_string(bool input)
 282         {
 283                 return input ? "true" : "false";
 284         }
 285
 286         bool wildcard_match(std::string const & target, std::string const & wildcard_string)
 287         {
 288                 std::string::const_iterator target_iterator = target.begin(), target_end = target.end();
 289                 for(std::string::const_iterator i = wildcard_string.begin(), end = wildcard_string.end(); i != end;     ++i, ++target_iterator)
 290                 {
 291                         char current_char = *i;
 292                         switch(current_char)
 293                         {
 294                                 case '*':
 295                                 {
 296                                         ++i;
 297                                         if(i == end)
 298                                                 return true;
 299                                         char next_char = *i;
 300                                         while(true)
 301                                         {
 302                                                 if(target_iterator == target_end)
 303                                                         return false;
 304                                                 if(*target_iterator == next_char)
 305                                                         break;
 306                                                 ++target_iterator;
 307                                         }
 308                                         break;
 309                                 }
 310
 311                                 case '?':
 312                                 {
 313                                         if(target_iterator == target_end)
 314                                                 return false;
 315                                         break;
 316                                 }
 317
 318                                 default:
 319                                 {
 320                                         if(target_iterator == target_end)
 321                                                 return false;
 322                                         if(current_char != *target_iterator)
 323                                                 return false;
 324                                         break;
 325                                 }
 326                         }
 327                 }
 328                 return (target_iterator == target_end);
 329         }
 330
 331         std::string consolify(std::string const & input)
 332         {
 333                 std::string output = input;
 334                 output = replace_string(output, "\b", "\\b");
 335                 output = replace_string(output, "\t", "\\t");
 336                 output = replace_string(output, "\n", "\\n");
 337                 output = replace_string(output, "\v", "\\v");
 338                 output = replace_string(output, "\f", "\\f");
 339                 output = replace_string(output, "\r", "\\r");
 340                 output = replace_string(output, "\x07", "\\x07");
 341                 return output;
 342         }
 343
 344         std::size_t locate_string(std::string const & input, std::string const & target, long occurence, std::size_t offset)
 345         {
 346                 for(; occurence > 0; occurence--)
 347                 {
 348                         offset = input.find(target, offset + 1);
 349                         if(offset == std::string::npos)
 350                                 break;
 351                 }
 352                 return offset;
 353         }
 354
 355         bool extract_string(std::string const & input, std::string const & left_target, std::string const & right_target, std::string & output, long occurence)
 356         {
 357                 std::size_t left_offset = locate_string(input, left_target, occurence, 0);
 358                 if(left_offset == std::string::npos)
 359                         return false;
 360                 left_offset += left_target.length();
 361                 std::size_t right_offset = input.find(right_target, left_offset);
 362                 if(right_offset == std::string::npos)
 363                         return false;
 364                 output = input.substr(left_offset, right_offset - left_offset);
 365                 return true;
 366         }
 367
 368         string_vector extract_strings(std::string const & input, std::string const & left_target, std::string const & right_target)
 369         {
 370                 string_vector output;
 371                 std::size_t last_offset = 0;
 372                 while(true)
 373                 {
 374                         std::size_t left_offset = input.find(left_target, last_offset);
 375                         if(left_offset == std::string::npos)
 376                                 break;
 377                         left_offset += left_target.length();
 378                         std::size_t right_offset = input.find(right_target, left_offset);
 379                         if(right_offset == std::string::npos)
 380                                 break;
 381                         std::string element = input.substr(left_offset, right_offset - left_offset);
 382                         output.push_back(element);
 383                         last_offset = right_offset + right_target.length();
 384                 }
 385                 return output;
 386         }
 387
 388         bool split_string(std::string const & input, std::string const & delimiter, std::string & left_string, std::string & right_string)
 389         {
 390                 std::size_t offset = input.find(delimiter);
 391                 if(offset == std::string::npos)
 392                 {
 393                         left_string = input;
 394                         right_string.clear();
 395                         return false;
 396                 }
 397                 left_string = input.substr(0, offset);
 398                 std::size_t right_offset = offset + delimiter.length();
 399                 right_string = input.substr(right_offset);
 400                 return true;
 401         }
 402
 403         std::string get_size_string(ullong size)
 404         {
 405                 std::string const size_strings[] =
 406                 {
 407                         "byte",
 408                         "KiB",
 409                         "MiB",
 410                         "GiB",
 411                         "TiB"
 412                 };
 413
 414                 double adjusted_size = static_cast<double>(size);
 415                 ullong const base = 1024;
 416                 double const divisor = static_cast<double>(base);
 417                 std::size_t size_index = 0;
 418                 for(std::size_t maximum = ail::countof(size_strings) - 1; adjusted_size > divisor && size_index < maximum; adjusted_size /= base, size_index++);
 419
 420                 std::stringstream stream;
 421                 stream << std::fixed;
 422
 423                 if(size_index > 0)
 424                 {
 425                         stream.precision(2);
 426                         stream << adjusted_size << " " << size_strings[size_index];
 427                         return stream.str();
 428                 }
 429                 else
 430                 {
 431                         stream << size << " " << size_strings[size_index];
 432                         std::string output = stream.str();
 433                         if(size != 1)
 434                                 output += "s";
 435                         return output;
 436                 }
 437         }
 438
 439         ulong binary_string_to_number(std::string const & input, bool big_endian)
 440         {
 441                 ulong output = 0;
 442
 443                 std::size_t
 444                         initial_value,
 445                         limit,
 446                         direction;
 447
 448                 if(big_endian)
 449                 {
 450                         initial_value = 0;
 451                         limit = input.size();
 452                         direction = 1;
 453                 }
 454                 else
 455                 {
 456                         initial_value = input.size() - 1;
 457                         limit = -1;
 458                         direction = -1;
 459                 }
 460
 461                 for(std::size_t i = initial_value; i != limit; i += direction)
 462                 {
 463                         output <<= 1;
 464                         output |= input[i] & 1;
 465                 }
 466
 467                 return output;
 468         }
 469
 470         std::string hex_string(ullong input, std::size_t bytes, bool prefix = true)
 471         {
 472                 std::stringstream output;
 473                 if(prefix)
 474                         output << "0x";
 475                 output.width(2 * bytes);
 476                 output.fill('0');
 477                 output << std::hex << input;
 478                 return output.str();
 479         }
 480
 481         std::string hex_string_8(ulong input)
 482         {
 483                 return hex_string(input, 1);
 484         }
 485
 486         std::string hex_string_16(ulong input)
 487         {
 488                 return hex_string(input, 2);
 489         }
 490
 491         std::string hex_string_32(ulong input)
 492         {
 493                 return hex_string(input, 4);
 494         }
 495
 496         std::string hex_string_64(ullong input)
 497         {
 498                 return hex_string(input, 8);
 499         }
 500
 501         std::string hex_string(std::string const & input)
 502         {
 503                 uchar const * data = reinterpret_cast<uchar const *>(input.c_str());
 504                 std::string output;
 505                 bool first = true;
 506                 for(std::size_t i = 0, end = input.size(); i < end; i++)
 507                 {
 508                         if(first)
 509                                 first = false;
 510                         else
 511                                 output += " ";
 512                         output += hex_string(data[i], 1, false);
 513                 }
 514                 return output;
 515         }
 516 }
 517
 518 std::string operator+(char left, std::string const & right)
 519 {
 520         std::string string;
 521         string += left;
 522         return string + right;
 523 }
 524
 525 std::string operator+(char const * left, std::string const & right)
 526 {
 527         return std::string(left) + right;
 528 }