Use std::vector for fx_ucd.h arrays.

xfa/fgas/layout/fgas_textbreak.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 "xfa/fgas/layout/fgas_textbreak.h"
 
 #include <algorithm>
 
@@ skipping 260 matching lines @@
 void CFX_TxtBreak::SetCharSpace(FX_FLOAT fCharSpace) {
   m_iCharSpace = FXSYS_round(fCharSpace * 20000.0f);
 }
 
 static const int32_t gs_FX_TxtLineRotations[8] = {0, 3, 1, 0, 2, 1, 3, 2};
 int32_t CFX_TxtBreak::GetLineRotation(uint32_t dwStyles) const {
   return gs_FX_TxtLineRotations[(dwStyles & 0x0E) >> 1];
 }
 
 CFX_TxtChar* CFX_TxtBreak::GetLastChar(int32_t index, bool bOmitChar) const {
-  CFX_TxtCharArray& ca = *m_pCurLine->m_pLineChars.get();
-  int32_t iCount = ca.GetSize();
+  std::vector<CFX_TxtChar>& ca = *m_pCurLine->m_pLineChars.get();
+  int32_t iCount = pdfium::CollectionSize<int32_t>(ca);
   if (index < 0 || index >= iCount) {
     return nullptr;
   }
-  CFX_TxtChar* pTC;
   int32_t iStart = iCount - 1;
   while (iStart > -1) {
-    pTC = ca.GetDataPtr(iStart--);
+    CFX_TxtChar* pTC = &ca[iStart--];
     if (bOmitChar && pTC->GetCharType() == FX_CHARTYPE_Combination) {
       continue;
     }
     if (--index < 0) {
       return pTC;
     }
   }
   return nullptr;
 }
 
@@ skipping 288 matching lines @@
                  (m_dwPolicies & FX_TXTBREAKPOLICY_SpaceBreak) != 0);
   if (!m_bSingleLine && bBreak && iLineWidth > m_iLineWidth + m_iTolerance) {
     return EndBreak(FX_TXTBREAK_LineBreak);
   }
   return FX_TXTBREAK_None;
 }
 
 uint32_t CFX_TxtBreak::AppendChar(FX_WCHAR wch) {
   uint32_t dwProps = kTextLayoutCodeProperties[(uint16_t)wch];
   FX_CHARTYPE chartype = GetCharTypeFromProp(dwProps);
-  CFX_TxtChar* pCurChar = m_pCurLine->m_pLineChars->AddSpace();
+  m_pCurLine->m_pLineChars->emplace_back();
+  CFX_TxtChar* pCurChar = &m_pCurLine->m_pLineChars->back();
   pCurChar->m_wCharCode = (uint16_t)wch;
   pCurChar->m_nRotation = m_iCharRotation;
   pCurChar->m_dwCharProps = dwProps;
   pCurChar->m_dwCharStyles = 0;
   pCurChar->m_iCharWidth = 0;
   pCurChar->m_iHorizontalScale = m_iHorScale;
   pCurChar->m_iVertialScale = m_iVerScale;
   pCurChar->m_dwStatus = 0;
   pCurChar->m_iBidiClass = 0;
   pCurChar->m_iBidiLevel = 0;
   pCurChar->m_iBidiPos = 0;
   pCurChar->m_iBidiOrder = 0;
   pCurChar->m_pUserData = nullptr;
   AppendChar_PageLoad(pCurChar, dwProps);
   uint32_t dwRet1 = FX_TXTBREAK_None;
   if (chartype != FX_CHARTYPE_Combination &&
       GetUnifiedCharType(m_eCharType) != GetUnifiedCharType(chartype)) {
     if (m_eCharType != FX_CHARTYPE_Unknown &&
         m_pCurLine->m_iWidth > m_iLineWidth + m_iTolerance && !m_bSingleLine) {
       if (m_eCharType != FX_CHARTYPE_Space || chartype != FX_CHARTYPE_Control) {
         dwRet1 = EndBreak(FX_TXTBREAK_LineBreak);
         int32_t iCount = m_pCurLine->CountChars();
         if (iCount > 0) {
-          pCurChar = m_pCurLine->m_pLineChars->GetDataPtr(iCount - 1);
+          pCurChar = &(*m_pCurLine->m_pLineChars)[iCount - 1];
         }
       }
     }
   }
   int32_t iRotation = m_iRotation;
   if (m_bVertical && (dwProps & 0x8000) != 0) {
     iRotation = (iRotation + 1) % 4;
   }
   uint32_t dwRet2 =
       (this->*g_FX_TxtBreak_lpfAppendChar[chartype >> FX_CHARTYPEBITS])(
@@ skipping 104 matching lines @@
     GetBreakPos(*m_pCurLine->m_pLineChars.get(), iEndPos, bAllChars, true);
   }
   return false;
 }
 
 void CFX_TxtBreak::EndBreak_BidiLine(CFX_TPOArray& tpos, uint32_t dwStatus) {
   CFX_TxtPiece tp;
   FX_TPO tpo;
   CFX_TxtChar* pTC;
   int32_t i, j;
-  CFX_TxtCharArray& chars = *m_pCurLine->m_pLineChars.get();
+  std::vector<CFX_TxtChar>& chars = *m_pCurLine->m_pLineChars.get();
   int32_t iCount = m_pCurLine->CountChars();
   bool bDone = (m_pCurLine->m_iArabicChars > 0 || m_bCurRTL);
   if (!m_bPagination && bDone) {
     int32_t iBidiNum = 0;
     for (i = 0; i < iCount; i++) {
-      pTC = chars.GetDataPtr(i);
+      pTC = &chars[i];
       pTC->m_iBidiPos = i;
       if (pTC->GetCharType() != FX_CHARTYPE_Control) {
         iBidiNum = i;
       }
       if (i == 0) {
         pTC->m_iBidiLevel = 1;
       }
     }
     FX_BidiLine(chars, iBidiNum + 1, m_bCurRTL ? 1 : 0);
   }
   CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces.get();
   if (!m_bPagination &&
       (bDone || (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_MutipleFormat) != 0)) {
     tp.m_dwStatus = FX_TXTBREAK_PieceBreak;
     tp.m_iStartPos = m_pCurLine->m_iStart;
     tp.m_pChars = m_pCurLine->m_pLineChars.get();
     int32_t iBidiLevel = -1, iCharWidth;
     i = 0, j = -1;
     while (i < iCount) {
-      pTC = chars.GetDataPtr(i);
+      pTC = &chars[i];
       if (iBidiLevel < 0) {
         iBidiLevel = pTC->m_iBidiLevel;
         tp.m_iWidth = 0;
         tp.m_iBidiLevel = iBidiLevel;
         tp.m_iBidiPos = pTC->m_iBidiOrder;
         tp.m_dwCharStyles = pTC->m_dwCharStyles;
         tp.m_pUserData = pTC->m_pUserData;
         tp.m_iHorizontalScale = pTC->m_iHorizontalScale;
         tp.m_iVerticalScale = pTC->m_iVertialScale;
         tp.m_dwStatus = FX_TXTBREAK_PieceBreak;
@@ skipping 46 matching lines @@
       ttp.m_dwStatus = dwStatus;
     }
   } else {
     tp.m_dwStatus = dwStatus;
     tp.m_iStartPos = m_pCurLine->m_iStart;
     tp.m_iWidth = m_pCurLine->m_iWidth;
     tp.m_iStartChar = 0;
     tp.m_iChars = iCount;
     tp.m_pChars = m_pCurLine->m_pLineChars.get();
     tp.m_pUserData = m_pUserData;
-    pTC = chars.GetDataPtr(0);
+    pTC = &chars[0];
     tp.m_dwCharStyles = pTC->m_dwCharStyles;
     tp.m_iHorizontalScale = pTC->m_iHorizontalScale;
     tp.m_iVerticalScale = pTC->m_iVertialScale;
     pCurPieces->Add(tp);
     tpo.index = 0;
     tpo.pos = 0;
     tpos.Add(tpo);
   }
 }
 
@@ skipping 148 matching lines @@
   m_pCurLine = pNextLine;
   pTC = GetLastChar(0, false);
   m_eCharType = pTC ? pTC->GetCharType() : FX_CHARTYPE_Unknown;
   if (dwStatus == FX_TXTBREAK_ParagraphBreak) {
     m_iArabicContext = m_iCurArabicContext = 1;
     ResetArabicContext();
   }
   return dwStatus;
 }
 
-int32_t CFX_TxtBreak::GetBreakPos(CFX_TxtCharArray& ca,
+int32_t CFX_TxtBreak::GetBreakPos(std::vector<CFX_TxtChar>& ca,
                                   int32_t& iEndPos,
                                   bool bAllChars,
                                   bool bOnlyBrk) {
-  int32_t iLength = ca.GetSize() - 1;
+  int32_t iLength = pdfium::CollectionSize<int32_t>(ca) - 1;
   if (iLength < 1) {
     return iLength;
   }
   int32_t iBreak = -1, iBreakPos = -1, iIndirect = -1, iIndirectPos = -1,
           iLast = -1, iLastPos = -1;
   if (m_bSingleLine || iEndPos <= m_iLineWidth) {
     if (!bAllChars) {
       return iLength;
     }
     iBreak = iLength;
     iBreakPos = iEndPos;
   }
   bool bSpaceBreak = (m_dwPolicies & FX_TXTBREAKPOLICY_SpaceBreak) != 0;
   bool bNumberBreak = (m_dwPolicies & FX_TXTBREAKPOLICY_NumberBreak) != 0;
   FX_LINEBREAKTYPE eType;
   uint32_t nCodeProp, nCur, nNext;
-  CFX_Char* pCur = ca.GetDataPtr(iLength--);
+  CFX_Char* pCur = &ca[iLength--];
   if (bAllChars) {
     pCur->m_nBreakType = FX_LBT_UNKNOWN;
   }
   nCodeProp = pCur->m_dwCharProps;
   nNext = nCodeProp & 0x003F;
   int32_t iCharWidth = pCur->m_iCharWidth;
   if (iCharWidth > 0) {
     iEndPos -= iCharWidth;
   }
   while (iLength >= 0) {
-    pCur = ca.GetDataPtr(iLength);
+    pCur = &ca[iLength];
     nCodeProp = pCur->m_dwCharProps;
     nCur = nCodeProp & 0x003F;
     if (nCur == FX_CBP_SP) {
       if (nNext == FX_CBP_SP) {
         eType = bSpaceBreak ? FX_LBT_DIRECT_BRK : FX_LBT_PROHIBITED_BRK;
       } else {
         eType = gs_FX_LineBreak_PairTable[nCur][nNext];
       }
     } else if (bNumberBreak && nCur == FX_CBP_NU && nNext == FX_CBP_NU) {
       eType = FX_LBT_DIRECT_BRK;
@@ skipping 53 matching lines @@
 
 void CFX_TxtBreak::SplitTextLine(CFX_TxtLine* pCurLine,
                                  CFX_TxtLine* pNextLine,
                                  bool bAllChars) {
   ASSERT(pCurLine && pNextLine);
   int32_t iCount = pCurLine->CountChars();
   if (iCount < 2) {
     return;
   }
   int32_t iEndPos = pCurLine->m_iWidth;
-  CFX_TxtCharArray& curChars = *pCurLine->m_pLineChars.get();
+  std::vector<CFX_TxtChar>& curChars = *pCurLine->m_pLineChars.get();
   int32_t iCharPos = GetBreakPos(curChars, iEndPos, bAllChars, false);
   if (iCharPos < 0) {
     iCharPos = 0;
   }
   iCharPos++;
   if (iCharPos >= iCount) {
     pNextLine->RemoveAll(true);
-    CFX_Char* pTC = curChars.GetDataPtr(iCharPos - 1);
+    CFX_Char* pTC = &curChars[iCharPos - 1];
     pTC->m_nBreakType = FX_LBT_UNKNOWN;
     return;
   }
-  CFX_TxtCharArray& nextChars = *pNextLine->m_pLineChars.get();
-  int cur_size = curChars.GetSize();
-  nextChars.SetSize(cur_size - iCharPos);
-  FXSYS_memcpy(nextChars.GetData(), curChars.GetDataPtr(iCharPos),
+  std::vector<CFX_TxtChar>& nextChars = *pNextLine->m_pLineChars.get();
+  int cur_size = pdfium::CollectionSize<int>(curChars);
+  nextChars.resize(cur_size - iCharPos);
+  FXSYS_memcpy(nextChars.data(), curChars.data() + iCharPos,

[dsinclair, 2017/01/24 18:43:59]

std::copy

[Tom Sepez, 2017/01/24 19:16:12]

Even better is new vector ctor from iterators and move assign, then clean up the
indexing so its obvious ...

                (cur_size - iCharPos) * sizeof(CFX_TxtChar));
   iCount -= iCharPos;
-  cur_size = curChars.GetSize();
-  curChars.RemoveAt(cur_size - iCount, iCount);
+  cur_size = pdfium::CollectionSize<int>(curChars);
+  curChars.erase(curChars.begin() + cur_size - iCount,
+                 curChars.begin() + cur_size);
   pCurLine->m_iWidth = iEndPos;
-  CFX_TxtChar* pTC = curChars.GetDataPtr(iCharPos - 1);
+  CFX_TxtChar* pTC = &curChars[iCharPos - 1];
   pTC->m_nBreakType = FX_LBT_UNKNOWN;
-  iCount = nextChars.GetSize();
+  iCount = pdfium::CollectionSize<int>(nextChars);
   int32_t iCharWidth, iWidth = 0;
   for (int32_t i = 0; i < iCount; i++) {
-    pTC = nextChars.GetDataPtr(i);
+    pTC = &nextChars[i];
     if (pTC->GetCharType() >= FX_CHARTYPE_ArabicAlef) {
       pCurLine->m_iArabicChars--;
       pNextLine->m_iArabicChars++;
     }
     iCharWidth = pTC->m_iCharWidth;
     if (iCharWidth > 0) {
       iWidth += iCharWidth;
     }
     if (m_bPagination) {
       continue;
@@ skipping 573 matching lines @@
       m_iChars(0),
       m_iBidiLevel(0),
       m_iBidiPos(0),
       m_iHorizontalScale(100),
       m_iVerticalScale(100),
       m_dwCharStyles(0),
       m_pChars(nullptr),
       m_pUserData(nullptr) {}
 
 CFX_TxtLine::CFX_TxtLine(int32_t iBlockSize)
-    : m_pLineChars(new CFX_TxtCharArray),
+    : m_pLineChars(new std::vector<CFX_TxtChar>),
       m_pLinePieces(new CFX_TxtPieceArray(16)),
       m_iStart(0),
       m_iWidth(0),
       m_iArabicChars(0) {}
 
 CFX_TxtLine::~CFX_TxtLine() {
   RemoveAll();
 }