Noissue - rename functions checking that the String is writable

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>
 
 #include "debug.h"
 #include "library.h"
 
-inline void String_assert_readonly(bool readOnly);
+inline void String_assert_writable(bool isWritable);
 
 class String
 {
   friend class DependentString;
   friend class OwnedString;
 
 public:
   typedef char16_t value_type;
   typedef size_t size_type;
 
@@ skipping 38 matching lines @@
     return !(mLen & LENGTH_MASK);
   }
 
   const value_type* data() const
   {
     return mBuf;
   }
 
   value_type* data()
   {
-    String_assert_readonly(is_readOnly());
+    String_assert_writable(is_writable());
     return mBuf;
   }
 
   const value_type& operator[](size_type pos) const
   {
     return mBuf[pos];
   }
 
   value_type& operator[](size_type pos)
   {
-    String_assert_readonly(is_readOnly());
+    String_assert_writable(is_writable());
     return mBuf[pos];
   }
 
-  bool is_readOnly() const
+  bool is_writable() const
   {
-    return (mLen & FLAGS_MASK) != READ_WRITE;
+    return (mLen & FLAGS_MASK) == READ_WRITE;
   }
 
   bool equals(const String& other) const
   {
     if (length() != other.length())
       return false;
 
     return std::memcmp(mBuf, other.mBuf, sizeof(value_type) * length()) == 0;
   }
 
@@ skipping 93 matching lines @@
 
   explicit DependentString(const value_type* buf, size_type len)
       : String(const_cast<value_type*>(buf), len, READ_ONLY)
   {
   }
 
   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
+          str.is_writable() ? READ_WRITE: READ_ONLY
         )
   {
   }
 
   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
@@ skipping 27 matching lines @@
     mLen = DELETED;
   }
 };
 
 inline DependentString operator "" _str(const String::value_type* str,
     String::size_type len)
 {
   return DependentString(str, len);
 }
 
-inline void String_assert_readonly(bool readOnly)
+inline void String_assert_writable(bool isWritable)
 {
-  assert(!readOnly, u"Writing access to a read-only string"_str);
+  assert(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());
@@ skipping 119 matching lines @@
     if (negative)
       mBuf[pos++] = '-';
 
     for (int i = size - 1; i >= 0; i--)
     {
       mBuf[pos + i] = '0' + (num % 10);
       num /= 10;
     }
   }
 };