Issue 4127 - [emscripten] Convert subscription classes to C++ - Part 1

compiled/String.h

+/*
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2017 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 <algorithm>
+#include <type_traits>
 
 #include <emscripten.h>
 
 #include "debug.h"
 
 inline void String_assert_readonly(bool readOnly);
 
 class String
 {
   friend class DependentString;
@@ skipping 165 matching lines @@
   explicit DependentString(value_type* buf, size_type len)
       : String(buf, len, READ_WRITE)
   {
   }
 
   explicit DependentString(const value_type* buf, size_type len)
       : String(const_cast<value_type*>(buf), len, READ_ONLY)
   {
   }
 
-  DependentString(String& str, size_type pos = 0, size_type len = npos)
+  explicit DependentString(String& str, size_type pos = 0, size_type len = npos)
       : String(
           str.mBuf + std::min(pos, str.length()),
           std::min(len, str.length() - std::min(pos, str.length())),
           str.is_readOnly() ? READ_ONLY : READ_WRITE
         )
   {
   }
 
-  DependentString(const String& str, size_type pos = 0,
+  explicit DependentString(const String& str, size_type pos = 0,
       size_type len = npos)
       : String(
           str.mBuf + std::min(pos, str.length()),
           std::min(len, str.length() - std::min(pos, str.length())),
           READ_ONLY
         )
   {
   }
 
   void reset(value_type* buf, size_type len)
@@ skipping 32 matching lines @@
 inline void String_assert_readonly(bool readOnly)
 {
   assert(!readOnly, u"Writing access to a read-only string"_str);
 }
 
 class OwnedString : public String
 {
 private:
   void grow(size_type additionalSize)
   {
-    auto newValue = OwnedString(length() + additionalSize);
+    OwnedString newValue(length() + additionalSize);
     if (length() > 0)
       std::memcpy(newValue.mBuf, mBuf, sizeof(value_type) * length());
     *this = std::move(newValue);
   }
 
 public:
   explicit OwnedString(size_type len = 0)
       : String(nullptr, len, READ_WRITE)
   {
     if (len)
@@ skipping 81 matching lines @@
 
   void append(const String& str)
   {
     append(str.mBuf, str.length());
   }
 
   void append(value_type c)
   {
     append(&c, 1);
   }
+
+  template<typename T,
+      typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+  void append(T num)
+  {
+    bool negative = false;
+    if (num < 0)
+    {
+      negative = true;
+      num = -num;
+    }
+
+    size_type size = 0;
+    for (T i = num; i; i /= 10)
+      size++;
+    size = (size ? size : 1);
+
+    size_type pos = length();
+    grow((negative ? 1 : 0) + size);
+
+    if (negative)
+      mBuf[pos++] = '-';
+
+    for (int i = size - 1; i >= 0; i--)
+    {
+      mBuf[pos + i] = '0' + (num % 10);
+      num /= 10;
+    }
+  }
 };