Noissue - implement a couple of common lexical_cast cases.

compiled/String.h

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #pragma once
 
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
 #include <type_traits>
 #ifdef INSIDE_TESTS
 #include <iostream>
 #include <codecvt>
 #endif
 #include <utility>
+#include <limits>
 
 #include "base.h"
 #include "debug.h"
 #include "library.h"
 
 ABP_NS_BEGIN
 
 inline void String_assert_writable(bool isWritable);
 
 class String
@@ skipping 411 matching lines @@
   }
 };
 
 #ifdef INSIDE_TESTS
 inline std::ostream& operator<<(std::ostream& os, const OwnedString& str)
 {
   return os << static_cast<const String&>(str);
 }
 #endif
 
+template<typename T>
+struct LexicalCastImpl;
+
+/// Performs common conversions of a text represented value.
+template<typename T>
+inline T lexical_cast(const String& value)
+{
+  return LexicalCastImpl<T>::Convert(value);
+}
+
+template<>
+struct LexicalCastImpl<bool>
+{
+  static bool Convert(const String& value)
+  {
+    return value == u"true"_str;
+  }
+};
+
+template<typename T>
+struct LexicalCastImpl
+{
+  static_assert(std::is_integral<T>::value, "T should be a number");
+  static T Convert(const String& value)
+  {
+    String::size_type len = value.length();
+    if (len == 0)
+      return 0;
+    String::size_type pos = 0;
+    bool negative = std::numeric_limits<T>::is_signed && value[0] == u'-';
+    if (negative)
+    {
+      ++pos;
+    }
+    T result = 0;
+    for (; pos < len && value[pos] >= u'0' && value[pos] <= u'9'; ++pos)

[hub, 2018/03/05 19:24:49]

If the condition `value[pos] >= u'0' && value[pos] <= u'9'` is false, then we
should have an error.

I'm comparing this to the behaviour of `boost::lexical_cast<>` where
`lexical_cast<int>(" 123")` is an error, so is `lexical_cast<int>("123 ")`,
because of the space.

This would also be consistent with `LexicalCastImpl<bool>::Convert()` above that
does a strict equality with `u"true"_str`.

[sergei, 2018/03/06 10:36:26]

Done, but I'm not sure about "123 ", anyway we can always fix it later.

+    {
+      // isDengerous is the optimization because there is no need for some checks

[hub, 2018/03/05 19:24:49]

isDangerous (typo)

[sergei, 2018/03/06 10:36:26]

Done.

+      // when the values are far from edge cases.
+      // It targets the normal values, when a value is prefixed with several
+      // zeros additional checks start to work earlier than the actual value of
+      // result reaches an edge case, but it does not affect the result.
+      bool isDangerous = pos >= std::numeric_limits<T>::digits10;
+      // It also invalidates the parsing of too big numbers in comparison with
+      // stopping when it encounters a non numerical character.
+      // cast<uint8_t>(u"1230"_str) -> 0
+      // cast<uint8_t>(u"123E"_str) -> 123
+      if (isDangerous && std::numeric_limits<T>::max() / 10 < result)
+      {
+        return 0;
+      }
+      result *= 10;
+      uint8_t digit = value[pos] - u'0';
+      if (isDangerous && (std::numeric_limits<T>::max() - digit < result - (negative ? 1 : 0)))
+      {
+        return 0;
+      }
+      result += digit;
+    }
+    return negative ? -result : result;
+  }
+};
+
+template<>
+inline OwnedString lexical_cast<OwnedString>(const String& value)
+{
+  return OwnedString{value};
+}
+
 DependentString TrimSpaces(const String& value);
 
 // Splits the `value` string into two `DependentString`s excluding the character staying at `separatorPos`.
 // Useful for parsing.
 std::pair<DependentString, DependentString> SplitString(const String& value, String::size_type separatorPos);
 
 ABP_NS_END