Merge to XFA: Add missing operators for CFX_xxxString combo patch.

core/include/fxcrt/fx_string.h

 // 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
 
 #ifndef _FX_STRING_H_
 #define _FX_STRING_H_
 
+#include <algorithm>
+
 #include "fx_memory.h"
 
 class CFX_ByteStringC;
 class CFX_ByteString;
 class CFX_WideStringC;
 class CFX_WideString;
 struct CFX_CharMap;
 class CFX_BinaryBuf;
 typedef int FX_STRSIZE;
 class CFX_ByteStringL;
 class CFX_WideStringL;
 
 // An immutable string with caller-provided storage which must outlive the
 // string itself.
-class CFX_ByteStringC 
+class CFX_ByteStringC
 {
 public:
     typedef FX_CHAR value_type;
 
     CFX_ByteStringC()
     {
         m_Ptr = NULL;
         m_Length = 0;
     }
 
@@ skipping 58 matching lines @@
 
     bool                        operator == (const CFX_ByteStringC& str) const
     {
         return  str.m_Length == m_Length && FXSYS_memcmp32(str.m_Ptr, m_Ptr, m_Length) == 0;
     }
 
     bool                        operator != (const CFX_ByteStringC& str) const
     {
         return  str.m_Length != m_Length || FXSYS_memcmp32(str.m_Ptr, m_Ptr, m_Length) != 0;
     }
-#define FXBSTR_ID(c1, c2, c3, c4) ((c1 << 24) | (c2 << 16) | (c3 << 8) | (c4))
 
     FX_DWORD            GetID(FX_STRSIZE start_pos = 0) const;
 
     FX_LPCBYTE          GetPtr() const
     {
         return m_Ptr;
     }
 
     FX_LPCSTR           GetCStr() const
     {
         return (FX_LPCSTR)m_Ptr;
     }
 
     FX_STRSIZE          GetLength() const
     {
         return m_Length;
     }
 
     bool                        IsEmpty() const
     {
         return m_Length == 0;
     }
 
-    operator            FX_LPCBYTE() const
-    {
-        return m_Ptr;
-    }
-
     FX_BYTE                     GetAt(FX_STRSIZE index) const
     {
         return m_Ptr[index];
     }
 
     CFX_ByteStringC     Mid(FX_STRSIZE index, FX_STRSIZE count = -1) const
     {
         if (index < 0) {
             index = 0;
         }
         if (index > m_Length) {
             return CFX_ByteStringC();
         }
         if (count < 0 || count > m_Length - index) {
             count = m_Length - index;
         }
         return CFX_ByteStringC(m_Ptr + index, count);
     }
+
+    const FX_BYTE& operator[] (size_t index) const
+    {
+        return m_Ptr[index];
+    }
+
+    bool operator< (const CFX_ByteStringC& that) const
+    {
+        int result = memcmp(m_Ptr, that.m_Ptr, std::min(m_Length, that.m_Length));
+        return result < 0 || (result == 0 && m_Length < that.m_Length);
+    }
+
 protected:
+    FX_LPCBYTE          m_Ptr;
+    FX_STRSIZE          m_Length;
 
-    FX_LPCBYTE          m_Ptr;
-
-    FX_STRSIZE          m_Length;
 private:
-
     void*                       operator new (size_t) throw()
     {
         return NULL;
     }
 };
 typedef const CFX_ByteStringC& FX_BSTR;
 #define FX_BSTRC(str) CFX_ByteStringC(str, sizeof str-1)
+#define FXBSTR_ID(c1, c2, c3, c4) ((c1 << 24) | (c2 << 16) | (c3 << 8) | (c4))
 struct CFX_StringData {
 
     long                m_nRefs;
 
     FX_STRSIZE  m_nDataLength;
 
     FX_STRSIZE  m_nAllocLength;
 
     FX_CHAR             m_String[1];
 };
@@ skipping 80 matching lines @@
     bool                                        operator != (FX_BSTR str) const
     {
         return !Equal(str);
     }
 
     bool                                        operator != (const CFX_ByteString& str) const
     {
         return !operator==(str);
     }
 
+    bool operator< (const CFX_ByteString& str) const
+    {
+        int result = FXSYS_memcmp32(c_str(), str.c_str(), std::min(GetLength(), str.GetLength()));
+        return result < 0 || (result == 0 && GetLength() < str.GetLength());
+    }
+
     void                                        Empty();
 
     const CFX_ByteString&       operator = (FX_LPCSTR str);
 
     const CFX_ByteString&       operator = (FX_BSTR bstrc);
 
     const CFX_ByteString&       operator = (const CFX_ByteString& stringSrc);
 
     const CFX_ByteString&       operator = (const CFX_BinaryBuf& buf);
 
@@ skipping 147 matching lines @@
     return CFX_ByteString(str1, str2);
 }
 inline CFX_ByteString operator + (const CFX_ByteString& str1, FX_BSTR str2)
 {
     return CFX_ByteString(str1, str2);
 }
 inline CFX_ByteString operator + (FX_BSTR str1, const CFX_ByteString& str2)
 {
     return CFX_ByteString(str1, str2);
 }
-class CFX_WideStringC 
+class CFX_WideStringC
 {
 public:
     typedef FX_WCHAR value_type;
 
     CFX_WideStringC()
     {
         m_Ptr = NULL;
         m_Length = 0;
     }
 
@@ skipping 101 matching lines @@
     CFX_WideStringC     Right(FX_STRSIZE count) const
     {
         if (count < 1) {
             return CFX_WideStringC();
         }
         if (count > m_Length) {
             count = m_Length;
         }
         return CFX_WideStringC(m_Ptr + m_Length - count, count);
     }
+
+    const FX_WCHAR& operator[] (size_t index) const
+    {
+        return m_Ptr[index];
+    }
+
+    bool operator< (const CFX_WideStringC& that) const
+    {
+        int result = wmemcmp(m_Ptr, that.m_Ptr, std::min(m_Length, that.m_Length));
+        return result < 0 || (result == 0 && m_Length < that.m_Length);
+     }
+
 protected:
+    FX_LPCWSTR          m_Ptr;
+    FX_STRSIZE          m_Length;
 
-    FX_LPCWSTR          m_Ptr;
-
-    FX_STRSIZE          m_Length;
 private:
-
     void*                       operator new (size_t) throw()
     {
         return NULL;
     }
 };
 typedef const CFX_WideStringC&  FX_WSTR;
 #define FX_WSTRC(wstr) CFX_WideStringC(wstr, FX_ArraySize(wstr) - 1)
 struct CFX_StringDataW {
 
     long                m_nRefs;
@@ skipping 69 matching lines @@
     const CFX_WideString&       operator =(const CFX_WideStringC& stringSrc);
 
     const CFX_WideString&       operator += (FX_LPCWSTR str);
 
     const CFX_WideString&       operator += (FX_WCHAR ch);
 
     const CFX_WideString&       operator += (const CFX_WideString& str);
 
     const CFX_WideString&       operator += (const CFX_WideStringC& str);
 
+    bool operator< (const CFX_WideString& str) const {
+        int result = wmemcmp(c_str(), str.c_str(), std::min(GetLength(), str.GetLength()));
+        return result < 0 || (result == 0 && GetLength() < str.GetLength());
+    }
+
     FX_WCHAR                            GetAt(FX_STRSIZE nIndex) const
     {
         return m_pData ? m_pData->m_String[nIndex] : 0;
     }
 
     FX_WCHAR                            operator[](FX_STRSIZE nIndex) const
     {
         return m_pData ? m_pData->m_String[nIndex] : 0;
     }
 
@@ skipping 152 matching lines @@
 CFX_ByteString  FX_UTF8Encode(FX_LPCWSTR pwsStr, FX_STRSIZE len);
 inline CFX_ByteString   FX_UTF8Encode(FX_WSTR wsStr)
 {
     return FX_UTF8Encode(wsStr.GetPtr(), wsStr.GetLength());
 }
 inline CFX_ByteString   FX_UTF8Encode(const CFX_WideString &wsStr)
 {
     return FX_UTF8Encode(wsStr.c_str(), wsStr.GetLength());
 }
 #endif