Issue 6064 - Put C++ code into a configurable namespace

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 "base.h"
 #include "debug.h"
 #include "library.h"
 
 ABP_NS_BEGIN
 
 inline void String_assert_writable(bool isWritable);
 
 class String
@@ skipping 155 matching lines @@
       if (currChar >= u'A' && currChar <= u'Z')
         mBuf[i] = currChar + u'a' - u'A';
       else if (currChar >= 128)
       {
         mBuf[i] = CharToLower(currChar);
       }
     }
   }
 };
 
+#ifdef INSIDE_TESTS
+inline std::ostream& operator<<(std::ostream& os, const String& str)
+{
+  std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+  os << converter.to_bytes(str.data(), str.data() + str.length());
+  return os;
+}
+#endif
+
 class DependentString : public String
 {
 public:
   explicit DependentString()
       : String(nullptr, 0, INVALID)
   {
   }
 
   explicit DependentString(value_type* buf, size_type len)
       : String(buf, len, READ_WRITE)
@@ skipping 44 matching lines @@
     *this = DependentString(str, pos, len);
   }
 
   void erase()
   {
     *this = DependentString();
     mLen = DELETED;
   }
 };
 
+#ifdef INSIDE_TESTS
+inline std::ostream& operator<<(std::ostream& os, const DependentString& str)
+{
+  return os << static_cast<const String&>(str);
+}
+#endif
+
 inline DependentString operator "" _str(const String::value_type* str,
     String::size_type len)
 {
   return DependentString(str, len);
 }
 
 inline void String_assert_writable(bool isWritable)
 {
   assert2(isWritable, u"Writing access to a read-only string"_str);
 }
 
 class OwnedString : public String
 {
 private:
   void grow(size_type 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)
+    : String(nullptr, len, len ? READ_WRITE : INVALID)
   {
     if (len)
     {
       mBuf = new value_type[length()];
       annotate_address(mBuf, "String");
     }
     else
       mBuf = nullptr;
   }
 
   explicit OwnedString(const String& str)
       : OwnedString(str.length())
   {
-    if (length())
+    if (!str.is_invalid() && !length())
+      mLen = length() | READ_WRITE;
+    else if (length())
       std::memcpy(mBuf, str.mBuf, sizeof(value_type) * length());
   }
 
   OwnedString(const OwnedString& str)
       : OwnedString(static_cast<const String&>(str))
   {
   }
 
   explicit OwnedString(const value_type* str, size_type len)
       : OwnedString(DependentString(str, len))
   {
   }
 
   explicit OwnedString(OwnedString&& str)
       : OwnedString(0)
   {
     mBuf = str.mBuf;
     mLen = str.mLen;
     str.mBuf = nullptr;
     str.mLen = READ_WRITE | 0;
   }
 
   ~OwnedString()
   {
     if (mBuf)
       delete[] mBuf;
+  }
+
+  void reset(const String& str)
+  {
+    *this = str;
+  }
+
+  void erase()
+  {
+    if (mBuf)
+      delete[] mBuf;
+    mBuf = nullptr;
+    mLen = DELETED;
   }
 
   OwnedString& operator=(const String& str)
   {
     *this = OwnedString(str);
     return *this;
   }
 
   OwnedString& operator=(const OwnedString& str)
   {
@@ skipping 64 matching lines @@
       mBuf[pos++] = '-';
 
     for (int i = size - 1; i >= 0; i--)
     {
       mBuf[pos + i] = '0' + (num % 10);
       num /= 10;
     }
   }
 };
 
-ABP_NS_END
+#ifdef INSIDE_TESTS
+inline std::ostream& operator<<(std::ostream& os, const OwnedString& str)
+{
+  return os << static_cast<const String&>(str);
+}
+#endif
+ABP_NS_END