tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

string_number_conversions.cc (4829B)

      1 // Copyright 2012 The Chromium Authors
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/strings/string_number_conversions.h"
      6 
      7 #include <iterator>
      8 #include <string>
      9 
     10 #include "base/containers/span.h"
     11 #include "base/logging.h"
     12 #include "base/strings/string_number_conversions_internal.h"
     13 #include "base/strings/string_piece.h"
     14 
     15 namespace base {
     16 
     17 std::string NumberToString(int value) {
     18  return internal::IntToStringT<std::string>(value);
     19 }
     20 
     21 std::u16string NumberToString16(int value) {
     22  return internal::IntToStringT<std::u16string>(value);
     23 }
     24 
     25 std::string NumberToString(unsigned value) {
     26  return internal::IntToStringT<std::string>(value);
     27 }
     28 
     29 std::u16string NumberToString16(unsigned value) {
     30  return internal::IntToStringT<std::u16string>(value);
     31 }
     32 
     33 std::string NumberToString(long value) {
     34  return internal::IntToStringT<std::string>(value);
     35 }
     36 
     37 std::u16string NumberToString16(long value) {
     38  return internal::IntToStringT<std::u16string>(value);
     39 }
     40 
     41 std::string NumberToString(unsigned long value) {
     42  return internal::IntToStringT<std::string>(value);
     43 }
     44 
     45 std::u16string NumberToString16(unsigned long value) {
     46  return internal::IntToStringT<std::u16string>(value);
     47 }
     48 
     49 std::string NumberToString(long long value) {
     50  return internal::IntToStringT<std::string>(value);
     51 }
     52 
     53 std::u16string NumberToString16(long long value) {
     54  return internal::IntToStringT<std::u16string>(value);
     55 }
     56 
     57 std::string NumberToString(unsigned long long value) {
     58  return internal::IntToStringT<std::string>(value);
     59 }
     60 
     61 std::u16string NumberToString16(unsigned long long value) {
     62  return internal::IntToStringT<std::u16string>(value);
     63 }
     64 
     65 std::string NumberToString(double value) {
     66  return internal::DoubleToStringT<std::string>(value);
     67 }
     68 
     69 std::u16string NumberToString16(double value) {
     70  return internal::DoubleToStringT<std::u16string>(value);
     71 }
     72 
     73 bool StringToInt(StringPiece input, int* output) {
     74  return internal::StringToIntImpl(input, *output);
     75 }
     76 
     77 bool StringToInt(StringPiece16 input, int* output) {
     78  return internal::StringToIntImpl(input, *output);
     79 }
     80 
     81 bool StringToUint(StringPiece input, unsigned* output) {
     82  return internal::StringToIntImpl(input, *output);
     83 }
     84 
     85 bool StringToUint(StringPiece16 input, unsigned* output) {
     86  return internal::StringToIntImpl(input, *output);
     87 }
     88 
     89 bool StringToInt64(StringPiece input, int64_t* output) {
     90  return internal::StringToIntImpl(input, *output);
     91 }
     92 
     93 bool StringToInt64(StringPiece16 input, int64_t* output) {
     94  return internal::StringToIntImpl(input, *output);
     95 }
     96 
     97 bool StringToUint64(StringPiece input, uint64_t* output) {
     98  return internal::StringToIntImpl(input, *output);
     99 }
    100 
    101 bool StringToUint64(StringPiece16 input, uint64_t* output) {
    102  return internal::StringToIntImpl(input, *output);
    103 }
    104 
    105 bool StringToSizeT(StringPiece input, size_t* output) {
    106  return internal::StringToIntImpl(input, *output);
    107 }
    108 
    109 bool StringToSizeT(StringPiece16 input, size_t* output) {
    110  return internal::StringToIntImpl(input, *output);
    111 }
    112 
    113 bool StringToDouble(StringPiece input, double* output) {
    114  return internal::StringToDoubleImpl(input, input.data(), *output);
    115 }
    116 
    117 bool StringToDouble(StringPiece16 input, double* output) {
    118  return internal::StringToDoubleImpl(
    119      input, reinterpret_cast<const uint16_t*>(input.data()), *output);
    120 }
    121 
    122 std::string HexEncode(const void* bytes, size_t size) {
    123  return HexEncode(span(reinterpret_cast<const uint8_t*>(bytes), size));
    124 }
    125 
    126 std::string HexEncode(span<const uint8_t> bytes) {
    127  // Each input byte creates two output hex characters.
    128  std::string ret;
    129  ret.reserve(bytes.size() * 2);
    130 
    131  for (uint8_t byte : bytes) {
    132    AppendHexEncodedByte(byte, ret);
    133  }
    134  return ret;
    135 }
    136 
    137 bool HexStringToInt(StringPiece input, int* output) {
    138  return internal::HexStringToIntImpl(input, *output);
    139 }
    140 
    141 bool HexStringToUInt(StringPiece input, uint32_t* output) {
    142  return internal::HexStringToIntImpl(input, *output);
    143 }
    144 
    145 bool HexStringToInt64(StringPiece input, int64_t* output) {
    146  return internal::HexStringToIntImpl(input, *output);
    147 }
    148 
    149 bool HexStringToUInt64(StringPiece input, uint64_t* output) {
    150  return internal::HexStringToIntImpl(input, *output);
    151 }
    152 
    153 bool HexStringToBytes(StringPiece input, std::vector<uint8_t>* output) {
    154  DCHECK(output->empty());
    155  return internal::HexStringToByteContainer<uint8_t>(
    156      input, std::back_inserter(*output));
    157 }
    158 
    159 bool HexStringToString(StringPiece input, std::string* output) {
    160  DCHECK(output->empty());
    161  return internal::HexStringToByteContainer<char>(input,
    162                                                  std::back_inserter(*output));
    163 }
    164 
    165 bool HexStringToSpan(StringPiece input, span<uint8_t> output) {
    166  if (input.size() / 2 != output.size())
    167    return false;
    168 
    169  return internal::HexStringToByteContainer<uint8_t>(input, output.begin());
    170 }
    171 
    172 }  // namespace base