LCOV - code coverage report
Current view: top level - src/inspector - string-16.h (source / functions) Hit Total Coverage
Test: app.info Lines: 42 42 100.0 %
Date: 2017-04-26 Functions: 11 11 100.0 %

          Line data    Source code
       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_INSPECTOR_STRING16_H_
       6             : #define V8_INSPECTOR_STRING16_H_
       7             : 
       8             : #include <stdint.h>
       9             : #include <cctype>
      10             : #include <climits>
      11             : #include <cstring>
      12             : #include <string>
      13             : #include <vector>
      14             : 
      15             : namespace v8_inspector {
      16             : 
      17             : using UChar = uint16_t;
      18             : 
      19          84 : class String16 {
      20             :  public:
      21             :   static const size_t kNotFound = static_cast<size_t>(-1);
      22             : 
      23   116310545 :   String16() {}
      24             :   String16(const String16& other)
      25   315550495 :       : m_impl(other.m_impl), hash_code(other.hash_code) {}
      26             :   String16(String16&& other)
      27     9971027 :       : m_impl(std::move(other.m_impl)), hash_code(other.hash_code) {}
      28    69384013 :   String16(const UChar* characters, size_t size) : m_impl(characters, size) {}
      29             :   String16(const UChar* characters)  // NOLINT(runtime/explicit)
      30             :       : m_impl(characters) {}
      31   233107419 :   String16(const char* characters)  // NOLINT(runtime/explicit)
      32   233107419 :       : String16(characters, std::strlen(characters)) {}
      33   466226572 :   String16(const char* characters, size_t size) {
      34   233113286 :     m_impl.resize(size);
      35  1791235731 :     for (size_t i = 0; i < size; ++i) m_impl[i] = characters[i];
      36   233113286 :   }
      37      977303 :   explicit String16(const std::basic_string<UChar>& impl) : m_impl(impl) {}
      38             : 
      39             :   String16& operator=(const String16& other) {
      40    83369347 :     m_impl = other.m_impl;
      41    83370019 :     hash_code = other.hash_code;
      42             :     return *this;
      43             :   }
      44             :   String16& operator=(String16&& other) {
      45             :     m_impl = std::move(other.m_impl);
      46    11498516 :     hash_code = other.hash_code;
      47             :     return *this;
      48             :   }
      49             : 
      50             :   static String16 fromInteger(int);
      51             :   static String16 fromInteger(size_t);
      52             :   static String16 fromDouble(double);
      53             :   static String16 fromDouble(double, int precision);
      54             : 
      55             :   int toInteger(bool* ok = nullptr) const;
      56             :   String16 stripWhiteSpace() const;
      57             :   const UChar* characters16() const { return m_impl.c_str(); }
      58             :   size_t length() const { return m_impl.length(); }
      59        7422 :   bool isEmpty() const { return !m_impl.length(); }
      60  1751461264 :   UChar operator[](size_t index) const { return m_impl[index]; }
      61      210394 :   String16 substring(size_t pos, size_t len = UINT_MAX) const {
      62      420788 :     return String16(m_impl.substr(pos, len));
      63             :   }
      64             :   size_t find(const String16& str, size_t start = 0) const {
      65      209619 :     return m_impl.find(str.m_impl, start);
      66             :   }
      67             :   size_t reverseFind(const String16& str, size_t start = UINT_MAX) const {
      68         368 :     return m_impl.rfind(str.m_impl, start);
      69             :   }
      70         576 :   size_t find(UChar c, size_t start = 0) const { return m_impl.find(c, start); }
      71             :   size_t reverseFind(UChar c, size_t start = UINT_MAX) const {
      72             :     return m_impl.rfind(c, start);
      73             :   }
      74             :   void swap(String16& other) {
      75             :     m_impl.swap(other.m_impl);
      76             :     std::swap(hash_code, other.hash_code);
      77             :   }
      78             : 
      79             :   // Convenience methods.
      80             :   std::string utf8() const;
      81             :   static String16 fromUTF8(const char* stringStart, size_t length);
      82             : 
      83   300897007 :   std::size_t hash() const {
      84   300897007 :     if (!hash_code) {
      85  1697394795 :       for (char c : m_impl) hash_code = 31 * hash_code + c;
      86             :       // Map hash code 0 to 1. This double the number of hash collisions for 1,
      87             :       // but avoids recomputing the hash code.
      88   170880752 :       if (!hash_code) ++hash_code;
      89             :     }
      90   300897007 :     return hash_code;
      91             :   }
      92             : 
      93             :   inline bool operator==(const String16& other) const {
      94    90637207 :     return m_impl == other.m_impl;
      95             :   }
      96             :   inline bool operator<(const String16& other) const {
      97         252 :     return m_impl < other.m_impl;
      98             :   }
      99             :   inline bool operator!=(const String16& other) const {
     100             :     return m_impl != other.m_impl;
     101             :   }
     102      766909 :   inline String16 operator+(const String16& other) const {
     103     1533818 :     return String16(m_impl + other.m_impl);
     104             :   }
     105             : 
     106             :   // Defined later, since it uses the String16Builder.
     107             :   template <typename... T>
     108             :   static String16 concat(T... args);
     109             : 
     110             :  private:
     111             :   std::basic_string<UChar> m_impl;
     112             :   mutable std::size_t hash_code = 0;
     113             : };
     114             : 
     115      191821 : inline String16 operator+(const char* a, const String16& b) {
     116      383642 :   return String16(a) + b;
     117             : }
     118             : 
     119             : class String16Builder {
     120             :  public:
     121             :   String16Builder();
     122             :   void append(const String16&);
     123             :   void append(UChar);
     124             :   void append(char);
     125             :   void append(const UChar*, size_t);
     126             :   void append(const char*, size_t);
     127             :   void appendNumber(int);
     128             :   void appendNumber(size_t);
     129             :   String16 toString();
     130             :   void reserveCapacity(size_t);
     131             : 
     132             :   template <typename T, typename... R>
     133        1712 :   void appendAll(T first, R... rest) {
     134        2818 :     append(first);
     135        2518 :     appendAll(rest...);
     136        1712 :   }
     137             :   void appendAll() {}
     138             : 
     139             :  private:
     140             :   std::vector<UChar> m_buffer;
     141             : };
     142             : 
     143             : template <typename... T>
     144         806 : String16 String16::concat(T... args) {
     145         806 :   String16Builder builder;
     146        3224 :   builder.appendAll(args...);
     147        1612 :   return builder.toString();
     148             : }
     149             : 
     150             : }  // namespace v8_inspector
     151             : 
     152             : #if !defined(__APPLE__) || defined(_LIBCPP_VERSION)
     153             : 
     154             : namespace std {
     155             : template <>
     156             : struct hash<v8_inspector::String16> {
     157             :   std::size_t operator()(const v8_inspector::String16& string) const {
     158   300897007 :     return string.hash();
     159             :   }
     160             : };
     161             : 
     162             : }  // namespace std
     163             : 
     164             : #endif  // !defined(__APPLE__) || defined(_LIBCPP_VERSION)
     165             : 
     166             : #endif  // V8_INSPECTOR_STRING16_H_

Generated by: LCOV version 1.10