Make code compile with clang_use_chrome_plugin (part II)

core/fxcrt/fx_basic_bstring.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cctype>
@@ skipping 76 matching lines @@
     m_pData.Reset(StringData::Create(pStr, nLen));
 }
 
 CFX_ByteString::CFX_ByteString(const uint8_t* pStr, FX_STRSIZE nLen) {
   if (nLen > 0) {
     m_pData.Reset(
         StringData::Create(reinterpret_cast<const FX_CHAR*>(pStr), nLen));
   }
 }
 
+CFX_ByteString::CFX_ByteString() {}
+
+CFX_ByteString::CFX_ByteString(const CFX_ByteString& other)
+    : m_pData(other.m_pData) {}
+
+CFX_ByteString::CFX_ByteString(CFX_ByteString&& other) {
+  m_pData.Swap(other.m_pData);
+}
+
 CFX_ByteString::CFX_ByteString(char ch) {
   m_pData.Reset(StringData::Create(1));
   m_pData->m_String[0] = ch;
 }
 
+CFX_ByteString::CFX_ByteString(const FX_CHAR* ptr)
+    : CFX_ByteString(ptr, ptr ? FXSYS_strlen(ptr) : 0) {}
+
 CFX_ByteString::CFX_ByteString(const CFX_ByteStringC& stringSrc) {
   if (!stringSrc.IsEmpty())
     m_pData.Reset(StringData::Create(stringSrc.c_str(), stringSrc.GetLength()));
 }
 
 CFX_ByteString::CFX_ByteString(const CFX_ByteStringC& str1,
                                const CFX_ByteStringC& str2) {
   int nNewLen = str1.GetLength() + str2.GetLength();
   if (nNewLen == 0)
     return;
 
   m_pData.Reset(StringData::Create(nNewLen));
   m_pData->CopyContents(str1.c_str(), str1.GetLength());
   m_pData->CopyContentsAt(str1.GetLength(), str2.c_str(), str2.GetLength());
 }
 
 CFX_ByteString::~CFX_ByteString() {}
 
+void CFX_ByteString::clear() {
+  m_pData.Reset();
+}
+
 const CFX_ByteString& CFX_ByteString::operator=(const FX_CHAR* pStr) {
   if (!pStr || !pStr[0])
     clear();
   else
     AssignCopy(pStr, FXSYS_strlen(pStr));
 
   return *this;
 }
 
 const CFX_ByteString& CFX_ByteString::operator=(
@@ skipping 64 matching lines @@
     return other.IsEmpty();
 
   if (other.IsEmpty())
     return false;
 
   return other.m_pData->m_nDataLength == m_pData->m_nDataLength &&
          FXSYS_memcmp(other.m_pData->m_String, m_pData->m_String,
                       m_pData->m_nDataLength) == 0;
 }
 
+bool CFX_ByteString::operator!=(const char* ptr) const {
+  return !(*this == ptr);
+}
+
+bool CFX_ByteString::operator!=(const CFX_ByteStringC& str) const {
+  return !(*this == str);
+}
+
+bool CFX_ByteString::operator!=(const CFX_ByteString& other) const {
+  return !(*this == other);
+}
+
+bool CFX_ByteString::operator<(const CFX_ByteString& str) const {
+  int result = FXSYS_memcmp(c_str(), str.c_str(),
+                            std::min(GetLength(), str.GetLength()));
+  return result < 0 || (result == 0 && GetLength() < str.GetLength());
+}
+
+uint8_t CFX_ByteString::GetAt(FX_STRSIZE nIndex) const {
+  return m_pData ? m_pData->m_String[nIndex] : 0;
+}
+
+uint8_t CFX_ByteString::operator[](FX_STRSIZE nIndex) const {
+  return m_pData ? m_pData->m_String[nIndex] : 0;
+}
+
 bool CFX_ByteString::EqualNoCase(const CFX_ByteStringC& str) const {
   if (!m_pData)
     return str.IsEmpty();
 
   FX_STRSIZE len = str.GetLength();
   if (m_pData->m_nDataLength != len)
     return false;
 
   const uint8_t* pThis = (const uint8_t*)m_pData->m_String;
   const uint8_t* pThat = str.raw_str();
@@ skipping 614 matching lines @@
                                            FX_STRSIZE len) {
   FX_STRSIZE str_len = len >= 0 ? len : FXSYS_wcslen(str);
   return FromUnicode(CFX_WideString(str, str_len));
 }
 
 // static
 CFX_ByteString CFX_ByteString::FromUnicode(const CFX_WideString& str) {
   return CFX_CharMap::GetByteString(0, str.AsStringC());
 }
 
+const FX_CHAR* CFX_ByteString::c_str() const {
+  return m_pData ? m_pData->m_String : "";
+}
+
+const uint8_t* CFX_ByteString::raw_str() const {
+  return m_pData ? reinterpret_cast<const uint8_t*>(m_pData->m_String)
+                 : nullptr;
+}
+
+CFX_ByteStringC CFX_ByteString::AsStringC() const {
+  return CFX_ByteStringC(raw_str(), GetLength());
+}
+
+FX_STRSIZE CFX_ByteString::GetLength() const {
+  return m_pData ? m_pData->m_nDataLength : 0;
+}
+
+bool CFX_ByteString::IsEmpty() const {
+  return !GetLength();
+}
+
 int CFX_ByteString::Compare(const CFX_ByteStringC& str) const {
   if (!m_pData) {
     return str.IsEmpty() ? 0 : -1;
   }
   int this_len = m_pData->m_nDataLength;
   int that_len = str.GetLength();
   int min_len = this_len < that_len ? this_len : that_len;
   for (int i = 0; i < min_len; i++) {
     if ((uint8_t)m_pData->m_String[i] < str.GetAt(i)) {
       return -1;
@@ skipping 128 matching lines @@
     fraction %= scale;
     scale /= 10;
   }
   return buf_size;
 }
 CFX_ByteString CFX_ByteString::FormatFloat(FX_FLOAT d, int precision) {
   FX_CHAR buf[32];
   FX_STRSIZE len = FX_ftoa(d, buf);
   return CFX_ByteString(buf, len);
 }