Member function name refactoring

core/src/fpdfdoc/doc_basic.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 "core/include/fpdfdoc/fpdf_doc.h"
 
 const int nMaxRecursion = 32;
 int CPDF_Dest::GetPageIndex(CPDF_Document* pDoc) {
@@ skipping 38 matching lines @@
   while (g_sZoomModes[i][0] != '\0') {
     if (mode == g_sZoomModes[i]) {
       return i + 1;
     }
     i++;
   }
   return 0;
 }
 FX_FLOAT CPDF_Dest::GetParam(int index) {
   CPDF_Array* pArray = ToArray(m_pObj);
-  return pArray ? pArray->GetNumber(2 + index) : 0;
+  return pArray ? pArray->GetNumberAt(2 + index) : 0;
 }
 CFX_ByteString CPDF_Dest::GetRemoteName() {
   return m_pObj ? m_pObj->GetString() : CFX_ByteString();
 }
 CPDF_NameTree::CPDF_NameTree(CPDF_Document* pDoc,
                              const CFX_ByteStringC& category) {
-  if (pDoc->GetRoot() && pDoc->GetRoot()->GetDict("Names"))
-    m_pRoot = pDoc->GetRoot()->GetDict("Names")->GetDict(category);
+  if (pDoc->GetRoot() && pDoc->GetRoot()->GetDictBy("Names"))
+    m_pRoot = pDoc->GetRoot()->GetDictBy("Names")->GetDictBy(category);
   else
     m_pRoot = NULL;
 }
 static CPDF_Object* SearchNameNode(CPDF_Dictionary* pNode,
                                    const CFX_ByteString& csName,
                                    int& nIndex,
                                    CPDF_Array** ppFind,
                                    int nLevel = 0) {
   if (nLevel > nMaxRecursion) {
     return NULL;
   }
-  CPDF_Array* pLimits = pNode->GetArray("Limits");
+  CPDF_Array* pLimits = pNode->GetArrayBy("Limits");
   if (pLimits) {
-    CFX_ByteString csLeft = pLimits->GetString(0);
-    CFX_ByteString csRight = pLimits->GetString(1);
+    CFX_ByteString csLeft = pLimits->GetStringAt(0);
+    CFX_ByteString csRight = pLimits->GetStringAt(1);
     if (csLeft.Compare(csRight) > 0) {
       CFX_ByteString csTmp = csRight;
       csRight = csLeft;
       csLeft = csTmp;
     }
     if (csName.Compare(csLeft) < 0 || csName.Compare(csRight) > 0) {
       return NULL;
     }
   }
-  CPDF_Array* pNames = pNode->GetArray("Names");
+  CPDF_Array* pNames = pNode->GetArrayBy("Names");
   if (pNames) {
     FX_DWORD dwCount = pNames->GetCount() / 2;
     for (FX_DWORD i = 0; i < dwCount; i++) {
-      CFX_ByteString csValue = pNames->GetString(i * 2);
+      CFX_ByteString csValue = pNames->GetStringAt(i * 2);
       int32_t iCompare = csValue.Compare(csName);
       if (iCompare <= 0) {
         if (ppFind) {
           *ppFind = pNames;
         }
         if (iCompare < 0) {
           continue;
         }
       } else {
         break;
       }
       nIndex += i;
       return pNames->GetElementValue(i * 2 + 1);
     }
     nIndex += dwCount;
     return NULL;
   }
-  CPDF_Array* pKids = pNode->GetArray("Kids");
+  CPDF_Array* pKids = pNode->GetArrayBy("Kids");
   if (!pKids) {
     return NULL;
   }
   for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
-    CPDF_Dictionary* pKid = pKids->GetDict(i);
+    CPDF_Dictionary* pKid = pKids->GetDictAt(i);
     if (!pKid) {
       continue;
     }
     CPDF_Object* pFound =
         SearchNameNode(pKid, csName, nIndex, ppFind, nLevel + 1);
     if (pFound) {
       return pFound;
     }
   }
   return NULL;
 }
 static CPDF_Object* SearchNameNode(CPDF_Dictionary* pNode,
                                    int nIndex,
                                    int& nCurIndex,
                                    CFX_ByteString& csName,
                                    CPDF_Array** ppFind,
                                    int nLevel = 0) {
   if (nLevel > nMaxRecursion) {
     return NULL;
   }
-  CPDF_Array* pNames = pNode->GetArray("Names");
+  CPDF_Array* pNames = pNode->GetArrayBy("Names");
   if (pNames) {
     int nCount = pNames->GetCount() / 2;
     if (nIndex >= nCurIndex + nCount) {
       nCurIndex += nCount;
       return NULL;
     }
     if (ppFind) {
       *ppFind = pNames;
     }
-    csName = pNames->GetString((nIndex - nCurIndex) * 2);
+    csName = pNames->GetStringAt((nIndex - nCurIndex) * 2);
     return pNames->GetElementValue((nIndex - nCurIndex) * 2 + 1);
   }
-  CPDF_Array* pKids = pNode->GetArray("Kids");
+  CPDF_Array* pKids = pNode->GetArrayBy("Kids");
   if (!pKids) {
     return NULL;
   }
   for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
-    CPDF_Dictionary* pKid = pKids->GetDict(i);
+    CPDF_Dictionary* pKid = pKids->GetDictAt(i);
     if (!pKid) {
       continue;
     }
     CPDF_Object* pFound =
         SearchNameNode(pKid, nIndex, nCurIndex, csName, ppFind, nLevel + 1);
     if (pFound) {
       return pFound;
     }
   }
   return NULL;
 }
 static int CountNames(CPDF_Dictionary* pNode, int nLevel = 0) {
   if (nLevel > nMaxRecursion) {
     return 0;
   }
-  CPDF_Array* pNames = pNode->GetArray("Names");
+  CPDF_Array* pNames = pNode->GetArrayBy("Names");
   if (pNames) {
     return pNames->GetCount() / 2;
   }
-  CPDF_Array* pKids = pNode->GetArray("Kids");
+  CPDF_Array* pKids = pNode->GetArrayBy("Kids");
   if (!pKids) {
     return 0;
   }
   int nCount = 0;
   for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
-    CPDF_Dictionary* pKid = pKids->GetDict(i);
+    CPDF_Dictionary* pKid = pKids->GetDictAt(i);
     if (!pKid) {
       continue;
     }
     nCount += CountNames(pKid, nLevel + 1);
   }
   return nCount;
 }
 int CPDF_NameTree::GetCount() const {
   if (!m_pRoot) {
     return 0;
@@ skipping 22 matching lines @@
   if (!m_pRoot) {
     return NULL;
   }
   int nIndex = 0;
   return SearchNameNode(m_pRoot, csName, nIndex, NULL);
 }
 CPDF_Array* CPDF_NameTree::LookupNamedDest(CPDF_Document* pDoc,
                                            const CFX_ByteStringC& sName) {
   CPDF_Object* pValue = LookupValue(sName);
   if (!pValue) {
-    CPDF_Dictionary* pDests = pDoc->GetRoot()->GetDict("Dests");
+    CPDF_Dictionary* pDests = pDoc->GetRoot()->GetDictBy("Dests");
     if (!pDests)
       return nullptr;
     pValue = pDests->GetElementValue(sName);
   }
   if (!pValue)
     return nullptr;
   if (CPDF_Array* pArray = pValue->AsArray())
     return pArray;
   if (CPDF_Dictionary* pDict = pValue->AsDictionary())
-    return pDict->GetArray("D");
+    return pDict->GetArrayBy("D");
   return nullptr;
 }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ || \
     _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 static CFX_WideString ChangeSlashToPlatform(const FX_WCHAR* str) {
   CFX_WideString result;
   while (*str) {
     if (*str == '/') {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
       result += ':';
@@ skipping 49 matching lines @@
   return result;
 #else
   return filepath;
 #endif
 }
 FX_BOOL CPDF_FileSpec::GetFileName(CFX_WideString& csFileName) const {
   if (!m_pObj) {
     return FALSE;
   }
   if (CPDF_Dictionary* pDict = m_pObj->AsDictionary()) {
-    csFileName = pDict->GetUnicodeText("UF");
+    csFileName = pDict->GetUnicodeTextBy("UF");
     if (csFileName.IsEmpty()) {
-      csFileName = CFX_WideString::FromLocal(pDict->GetString("F"));
+      csFileName = CFX_WideString::FromLocal(pDict->GetStringBy("F"));
     }
-    if (pDict->GetString("FS") == "URL") {
+    if (pDict->GetStringBy("FS") == "URL") {
       return TRUE;
     }
     if (csFileName.IsEmpty()) {
       if (pDict->KeyExist("DOS")) {
-        csFileName = CFX_WideString::FromLocal(pDict->GetString("DOS"));
+        csFileName = CFX_WideString::FromLocal(pDict->GetStringBy("DOS"));
       } else if (pDict->KeyExist("Mac")) {
-        csFileName = CFX_WideString::FromLocal(pDict->GetString("Mac"));
+        csFileName = CFX_WideString::FromLocal(pDict->GetStringBy("Mac"));
       } else if (pDict->KeyExist("Unix")) {
-        csFileName = CFX_WideString::FromLocal(pDict->GetString("Unix"));
+        csFileName = CFX_WideString::FromLocal(pDict->GetStringBy("Unix"));
       } else {
         return FALSE;
       }
     }
   } else {
     csFileName = CFX_WideString::FromLocal(m_pObj->GetString());
   }
   csFileName = FILESPEC_DecodeFileName(csFileName);
   return TRUE;
 }
 CPDF_FileSpec::CPDF_FileSpec() {
   m_pObj = new CPDF_Dictionary;
   if (CPDF_Dictionary* pDict = ToDictionary(m_pObj)) {
     pDict->SetAtName("Type", "Filespec");
   }
 }
 FX_BOOL CPDF_FileSpec::IsURL() const {
   if (CPDF_Dictionary* pDict = ToDictionary(m_pObj)) {
-    return pDict->GetString("FS") == "URL";
+    return pDict->GetStringBy("FS") == "URL";
   }
   return FALSE;
 }
 CFX_WideString FILESPEC_EncodeFileName(const CFX_WideStringC& filepath) {
   if (filepath.GetLength() <= 1) {
     return CFX_WideString();
   }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
   if (filepath.GetAt(1) == ':') {
     CFX_WideString result;
@@ skipping 25 matching lines @@
   return ChangeSlashToPDF(filepath.GetPtr());
 #else
   return filepath;
 #endif
 }
 CPDF_Stream* CPDF_FileSpec::GetFileStream() const {
   if (!m_pObj)
     return nullptr;
   if (CPDF_Stream* pStream = m_pObj->AsStream())
     return pStream;
-  if (CPDF_Dictionary* pEF = m_pObj->AsDictionary()->GetDict("EF"))
-    return pEF->GetStream("F");
+  if (CPDF_Dictionary* pEF = m_pObj->AsDictionary()->GetDictBy("EF"))
+    return pEF->GetStreamBy("F");
   return nullptr;
 }
 static void FPDFDOC_FILESPEC_SetFileName(CPDF_Object* pObj,
                                          const CFX_WideStringC& wsFileName,
                                          FX_BOOL bURL) {
   CFX_WideString wsStr;
   if (bURL) {
     wsStr = wsFileName;
   } else {
     wsStr = FILESPEC_EncodeFileName(wsFileName);
@@ skipping 71 matching lines @@
 }
 CFX_WideString CPDF_PageLabel::GetLabel(int nPage) const {
   CFX_WideString wsLabel;
   if (!m_pDocument) {
     return wsLabel;
   }
   CPDF_Dictionary* pPDFRoot = m_pDocument->GetRoot();
   if (!pPDFRoot) {
     return wsLabel;
   }
-  CPDF_Dictionary* pLabels = pPDFRoot->GetDict("PageLabels");
+  CPDF_Dictionary* pLabels = pPDFRoot->GetDictBy("PageLabels");
   CPDF_NumberTree numberTree(pLabels);
   CPDF_Object* pValue = NULL;
   int n = nPage;
   while (n >= 0) {
     pValue = numberTree.LookupValue(n);
     if (pValue) {
       break;
     }
     n--;
   }
   if (pValue) {
     pValue = pValue->GetDirect();
     if (CPDF_Dictionary* pLabel = pValue->AsDictionary()) {
       if (pLabel->KeyExist("P")) {
-        wsLabel += pLabel->GetUnicodeText("P");
+        wsLabel += pLabel->GetUnicodeTextBy("P");
       }
-      CFX_ByteString bsNumberingStyle = pLabel->GetString("S", NULL);
-      int nLabelNum = nPage - n + pLabel->GetInteger("St", 1);
+      CFX_ByteString bsNumberingStyle = pLabel->GetStringBy("S", NULL);
+      int nLabelNum = nPage - n + pLabel->GetIntegerBy("St", 1);
       CFX_WideString wsNumPortion =
           _GetLabelNumPortion(nLabelNum, bsNumberingStyle);
       wsLabel += wsNumPortion;
       return wsLabel;
     }
   }
   wsLabel.Format(L"%d", nPage + 1);
   return wsLabel;
 }
 int32_t CPDF_PageLabel::GetPageByLabel(const CFX_ByteStringC& bsLabel) const {
@@ skipping 17 matching lines @@
   int nPage = FXSYS_atoi(bsLbl);
   if (nPage > 0 && nPage <= nPages) {
     return nPage;
   }
   return -1;
 }
 int32_t CPDF_PageLabel::GetPageByLabel(const CFX_WideStringC& wsLabel) const {
   CFX_ByteString bsLabel = PDF_EncodeText(wsLabel.GetPtr());
   return GetPageByLabel(bsLabel);
 }