Rename dictionary set and get methods

fpdfsdk/fpdfppo.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 "public/fpdf_ppo.h"
 
 #include <map>
 #include <memory>
@@ skipping 42 matching lines @@
   CPDF_Dictionary* pNewRoot = pDestPDFDoc->GetRoot();
   if (!pNewRoot)
     return FALSE;
 
   CPDF_Dictionary* DInfoDict = pDestPDFDoc->GetInfo();
   if (!DInfoDict)
     return FALSE;
 
   CFX_ByteString producerstr;
   producerstr.Format("PDFium");
-  DInfoDict->SetAt("Producer", new CPDF_String(producerstr, FALSE));
+  DInfoDict->SetFor("Producer", new CPDF_String(producerstr, FALSE));
 
-  CFX_ByteString cbRootType = pNewRoot->GetStringBy("Type", "");
+  CFX_ByteString cbRootType = pNewRoot->GetStringFor("Type", "");
   if (cbRootType.IsEmpty())
-    pNewRoot->SetAt("Type", new CPDF_Name("Catalog"));
+    pNewRoot->SetFor("Type", new CPDF_Name("Catalog"));
 
-  CPDF_Object* pElement = pNewRoot->GetObjectBy("Pages");
+  CPDF_Object* pElement = pNewRoot->GetObjectFor("Pages");
   CPDF_Dictionary* pNewPages =
       pElement ? ToDictionary(pElement->GetDirect()) : nullptr;
   if (!pNewPages) {
     pNewPages = new CPDF_Dictionary;
     uint32_t NewPagesON = pDestPDFDoc->AddIndirectObject(pNewPages);
-    pNewRoot->SetAt("Pages", new CPDF_Reference(pDestPDFDoc, NewPagesON));
+    pNewRoot->SetFor("Pages", new CPDF_Reference(pDestPDFDoc, NewPagesON));
   }
 
-  CFX_ByteString cbPageType = pNewPages->GetStringBy("Type", "");
+  CFX_ByteString cbPageType = pNewPages->GetStringFor("Type", "");
   if (cbPageType == "") {
-    pNewPages->SetAt("Type", new CPDF_Name("Pages"));
+    pNewPages->SetFor("Type", new CPDF_Name("Pages"));
   }
 
-  CPDF_Array* pKeysArray = pNewPages->GetArrayBy("Kids");
+  CPDF_Array* pKeysArray = pNewPages->GetArrayFor("Kids");
   if (!pKeysArray) {
     CPDF_Array* pNewKids = new CPDF_Array;
     uint32_t Kidsobjnum = pDestPDFDoc->AddIndirectObject(pNewKids);
 
-    pNewPages->SetAt("Kids", new CPDF_Reference(pDestPDFDoc, Kidsobjnum));
-    pNewPages->SetAt("Count", new CPDF_Number(0));
+    pNewPages->SetFor("Kids", new CPDF_Reference(pDestPDFDoc, Kidsobjnum));
+    pNewPages->SetFor("Count", new CPDF_Number(0));
   }
 
   return TRUE;
 }
 
 FX_BOOL CPDF_PageOrganizer::ExportPage(CPDF_Document* pSrcPDFDoc,
                                        std::vector<uint16_t>* pPageNums,
                                        CPDF_Document* pDestPDFDoc,
                                        int nIndex) {
   int curpage = nIndex;
   std::unique_ptr<ObjectNumberMap> pObjNumberMap(new ObjectNumberMap);
   int nSize = pdfium::CollectionSize<int>(*pPageNums);
   for (int i = 0; i < nSize; ++i) {
     CPDF_Dictionary* pCurPageDict = pDestPDFDoc->CreateNewPage(curpage);
     CPDF_Dictionary* pSrcPageDict = pSrcPDFDoc->GetPage(pPageNums->at(i) - 1);
     if (!pSrcPageDict || !pCurPageDict)
       return FALSE;
 
     // Clone the page dictionary
     for (const auto& it : *pSrcPageDict) {
       const CFX_ByteString& cbSrcKeyStr = it.first;
       CPDF_Object* pObj = it.second;
       if (cbSrcKeyStr.Compare(("Type")) && cbSrcKeyStr.Compare(("Parent"))) {
         if (pCurPageDict->KeyExist(cbSrcKeyStr))
-          pCurPageDict->RemoveAt(cbSrcKeyStr);
-        pCurPageDict->SetAt(cbSrcKeyStr, pObj->Clone());
+          pCurPageDict->RemoveFor(cbSrcKeyStr);
+        pCurPageDict->SetFor(cbSrcKeyStr, pObj->Clone());
       }
     }
 
     // inheritable item
     CPDF_Object* pInheritable = nullptr;
     // 1 MediaBox  //required
     if (!pCurPageDict->KeyExist("MediaBox")) {
       pInheritable = PageDictGetInheritableTag(pSrcPageDict, "MediaBox");
       if (!pInheritable) {
         // Search the "CropBox" from source page dictionary,
         // if not exists,we take the letter size.
         pInheritable = PageDictGetInheritableTag(pSrcPageDict, "CropBox");
         if (pInheritable) {
-          pCurPageDict->SetAt("MediaBox", pInheritable->Clone());
+          pCurPageDict->SetFor("MediaBox", pInheritable->Clone());
         } else {
           // Make the default size to be letter size (8.5'x11')
           CPDF_Array* pArray = new CPDF_Array;
           pArray->AddNumber(0);
           pArray->AddNumber(0);
           pArray->AddNumber(612);
           pArray->AddNumber(792);
-          pCurPageDict->SetAt("MediaBox", pArray);
+          pCurPageDict->SetFor("MediaBox", pArray);
         }
       } else {
-        pCurPageDict->SetAt("MediaBox", pInheritable->Clone());
+        pCurPageDict->SetFor("MediaBox", pInheritable->Clone());
       }
     }
     // 2 Resources //required
     if (!pCurPageDict->KeyExist("Resources")) {
       pInheritable = PageDictGetInheritableTag(pSrcPageDict, "Resources");
       if (!pInheritable)
         return FALSE;
-      pCurPageDict->SetAt("Resources", pInheritable->Clone());
+      pCurPageDict->SetFor("Resources", pInheritable->Clone());
     }
     // 3 CropBox  //Optional
     if (!pCurPageDict->KeyExist("CropBox")) {
       pInheritable = PageDictGetInheritableTag(pSrcPageDict, "CropBox");
       if (pInheritable)
-        pCurPageDict->SetAt("CropBox", pInheritable->Clone());
+        pCurPageDict->SetFor("CropBox", pInheritable->Clone());
     }
     // 4 Rotate  //Optional
     if (!pCurPageDict->KeyExist("Rotate")) {
       pInheritable = PageDictGetInheritableTag(pSrcPageDict, "Rotate");
       if (pInheritable)
-        pCurPageDict->SetAt("Rotate", pInheritable->Clone());
+        pCurPageDict->SetFor("Rotate", pInheritable->Clone());
     }
 
     // Update the reference
     uint32_t dwOldPageObj = pSrcPageDict->GetObjNum();
     uint32_t dwNewPageObj = pCurPageDict->GetObjNum();
 
     (*pObjNumberMap)[dwOldPageObj] = dwNewPageObj;
 
     UpdateReference(pCurPageDict, pDestPDFDoc, pObjNumberMap.get());
     ++curpage;
   }
 
   return TRUE;
 }
 
 CPDF_Object* CPDF_PageOrganizer::PageDictGetInheritableTag(
     CPDF_Dictionary* pDict,
     const CFX_ByteString& bsSrcTag) {
   if (!pDict || bsSrcTag.IsEmpty())
     return nullptr;
   if (!pDict->KeyExist("Parent") || !pDict->KeyExist("Type"))
     return nullptr;
 
-  CPDF_Object* pType = pDict->GetObjectBy("Type")->GetDirect();
+  CPDF_Object* pType = pDict->GetObjectFor("Type")->GetDirect();
   if (!ToName(pType))
     return nullptr;
   if (pType->GetString().Compare("Page"))
     return nullptr;
 
-  CPDF_Dictionary* pp = ToDictionary(pDict->GetObjectBy("Parent")->GetDirect());
+  CPDF_Dictionary* pp =
+      ToDictionary(pDict->GetObjectFor("Parent")->GetDirect());
   if (!pp)
     return nullptr;
 
   if (pDict->KeyExist(bsSrcTag))
-    return pDict->GetObjectBy(bsSrcTag);
+    return pDict->GetObjectFor(bsSrcTag);
 
   while (pp) {
     if (pp->KeyExist(bsSrcTag))
-      return pp->GetObjectBy(bsSrcTag);
+      return pp->GetObjectFor(bsSrcTag);
     if (!pp->KeyExist("Parent"))
       break;
-    pp = ToDictionary(pp->GetObjectBy("Parent")->GetDirect());
+    pp = ToDictionary(pp->GetObjectFor("Parent")->GetDirect());
   }
   return nullptr;
 }
 
 FX_BOOL CPDF_PageOrganizer::UpdateReference(CPDF_Object* pObj,
                                             CPDF_Document* pDoc,
                                             ObjectNumberMap* pObjNumberMap) {
   switch (pObj->GetType()) {
     case CPDF_Object::REFERENCE: {
       CPDF_Reference* pReference = pObj->AsReference();
       uint32_t newobjnum = GetNewObjId(pDoc, pObjNumberMap, pReference);
       if (newobjnum == 0)
         return FALSE;
       pReference->SetRef(pDoc, newobjnum);
       break;
     }
     case CPDF_Object::DICTIONARY: {
       CPDF_Dictionary* pDict = pObj->AsDictionary();
       auto it = pDict->begin();
       while (it != pDict->end()) {
         const CFX_ByteString& key = it->first;
         CPDF_Object* pNextObj = it->second;
         ++it;
         if (key == "Parent" || key == "Prev" || key == "First")
           continue;
         if (!pNextObj)
           return FALSE;
         if (!UpdateReference(pNextObj, pDoc, pObjNumberMap))
-          pDict->RemoveAt(key);
+          pDict->RemoveFor(key);
       }
       break;
     }
     case CPDF_Object::ARRAY: {
       CPDF_Array* pArray = pObj->AsArray();
       for (size_t i = 0; i < pArray->GetCount(); ++i) {
         CPDF_Object* pNextObj = pArray->GetObjectAt(i);
         if (!pNextObj)
           return FALSE;
         if (!UpdateReference(pNextObj, pDoc, pObjNumberMap))
@@ skipping 36 matching lines @@
   CPDF_Object* pDirect = pRef->GetDirect();
   if (!pDirect)
     return 0;
 
   CPDF_Object* pClone = pDirect->Clone();
   if (!pClone)
     return 0;
 
   if (CPDF_Dictionary* pDictClone = pClone->AsDictionary()) {
     if (pDictClone->KeyExist("Type")) {
-      CFX_ByteString strType = pDictClone->GetStringBy("Type");
+      CFX_ByteString strType = pDictClone->GetStringFor("Type");
       if (!FXSYS_stricmp(strType.c_str(), "Pages")) {
         pDictClone->Release();
         return 4;
       }
       if (!FXSYS_stricmp(strType.c_str(), "Page")) {
         pDictClone->Release();
         return 0;
       }
     }
   }
@@ skipping 88 matching lines @@
                                                        FPDF_DOCUMENT src_doc) {
   CPDF_Document* pDstDoc = CPDFDocumentFromFPDFDocument(dest_doc);
   if (!pDstDoc)
     return FALSE;
 
   CPDF_Document* pSrcDoc = CPDFDocumentFromFPDFDocument(src_doc);
   if (!pSrcDoc)
     return FALSE;
 
   CPDF_Dictionary* pSrcDict = pSrcDoc->GetRoot();
-  pSrcDict = pSrcDict->GetDictBy("ViewerPreferences");
+  pSrcDict = pSrcDict->GetDictFor("ViewerPreferences");
   if (!pSrcDict)
     return FALSE;
 
   CPDF_Dictionary* pDstDict = pDstDoc->GetRoot();
   if (!pDstDict)
     return FALSE;
 
-  pDstDict->SetAt("ViewerPreferences", pSrcDict->CloneDirectObject());
+  pDstDict->SetFor("ViewerPreferences", pSrcDict->CloneDirectObject());
   return TRUE;
 }