Remove CFX_ArrayTemplate in BC_QRCoderEncoder.

xfa/fxbarcode/qrcode/BC_QRCoderEncoder.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
 // Original code is licensed as follows:
 /*
  * Copyright 2008 ZXing authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ skipping 22 matching lines @@
 #include "xfa/fxbarcode/common/reedsolomon/BC_ReedSolomonGF256.h"
 #include "xfa/fxbarcode/qrcode/BC_QRCoder.h"
 #include "xfa/fxbarcode/qrcode/BC_QRCoderBitVector.h"
 #include "xfa/fxbarcode/qrcode/BC_QRCoderBlockPair.h"
 #include "xfa/fxbarcode/qrcode/BC_QRCoderECBlocks.h"
 #include "xfa/fxbarcode/qrcode/BC_QRCoderMaskUtil.h"
 #include "xfa/fxbarcode/qrcode/BC_QRCoderMatrixUtil.h"
 #include "xfa/fxbarcode/qrcode/BC_QRCoderMode.h"
 #include "xfa/fxbarcode/qrcode/BC_QRCoderVersion.h"
 
-const int32_t CBC_QRCoderEncoder::m_alphaNumbericTable[] = {
+namespace {
+
+const int8_t g_alphaNumericTable[] = {
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  44, -1, -1, -1, -1, -1,
     -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
     25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1};
 
+}  // namespace
+
 CBC_QRCoderEncoder::CBC_QRCoderEncoder() {}
 
 CBC_QRCoderEncoder::~CBC_QRCoderEncoder() {}
 
-class Make_Pair {
- public:
-  CBC_QRCoderMode* m_mode;
-  CFX_ByteString m_string;
-
- private:
-  Make_Pair(const Make_Pair& mode_string) {}
-  Make_Pair& operator=(Make_Pair& mode_string) {
-    if (this == &mode_string) {
-      return *this;
-    }
-    m_mode = mode_string.m_mode;
-    m_string = mode_string.m_string;
-    return *this;
-  }
-
- public:
-  Make_Pair(CBC_QRCoderMode* mode, const CFX_ByteString& str)
-      : m_mode(mode), m_string(str) {}
-  ~Make_Pair() {}
-};
 void CBC_QRCoderEncoder::Encode(const CFX_ByteString& content,
                                 CBC_QRCoderErrorCorrectionLevel* ecLevel,
                                 CBC_QRCoder* qrCode,
                                 int32_t& e,
                                 int32_t versionSpecify) {
   if (versionSpecify == 0) {
     EncodeWithAutoVersion(content, ecLevel, qrCode, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e)
   } else if (versionSpecify > 0 && versionSpecify <= 40) {
     EncodeWithSpecifyVersion(content, ecLevel, qrCode, versionSpecify, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
   } else {
     e = BCExceptionVersionMust1_40;
     BC_EXCEPTION_CHECK_ReturnVoid(e);
   }
 }
 
 void CBC_QRCoderEncoder::AppendECI(CBC_QRCoderBitVector* bits) {}
 
 void CBC_QRCoderEncoder::AppendDataModeLenghInfo(
-    const CFX_ArrayTemplate<Make_Pair*>& splitResult,
+    const std::vector<std::pair<CBC_QRCoderMode*, CFX_ByteString>>&
+        splitResults,
     CBC_QRCoderBitVector& headerAndDataBits,
     CBC_QRCoderMode* tempMode,
     CBC_QRCoder* qrCode,
     CFX_ByteString& encoding,
     int32_t& e) {
-  for (int32_t i = 0; i < splitResult.GetSize(); i++) {
-    tempMode = splitResult[i]->m_mode;
+  for (const auto& splitResult : splitResults) {
+    tempMode = splitResult.first;
     if (tempMode == CBC_QRCoderMode::sGBK) {
       AppendModeInfo(tempMode, &headerAndDataBits, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
-      AppendLengthInfo(splitResult[i]->m_string.GetLength(),
-                       qrCode->GetVersion(), tempMode, &headerAndDataBits, e);
+      AppendLengthInfo(splitResult.second.GetLength(), qrCode->GetVersion(),

[dsinclair, 2017/01/02 18:06:17]

Is it worth making a tempString = splitResults.second; to make it clearer what
.second is?

[Tom Sepez, 2017/01/03 22:25:59]

Prolly not, the type of splitResults is explicit on line 79.

+                       tempMode, &headerAndDataBits, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
-      AppendBytes(splitResult[i]->m_string, tempMode, &headerAndDataBits,
-                  encoding, e);
+      AppendBytes(splitResult.second, tempMode, &headerAndDataBits, encoding,
+                  e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else if (tempMode == CBC_QRCoderMode::sBYTE) {
       CFX_ByteArray bytes;
-      CBC_UtilCodingConvert::LocaleToUtf8(splitResult[i]->m_string, bytes);
+      CBC_UtilCodingConvert::LocaleToUtf8(splitResult.second, bytes);
       AppendModeInfo(tempMode, &headerAndDataBits, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
       AppendLengthInfo(bytes.GetSize(), qrCode->GetVersion(), tempMode,
                        &headerAndDataBits, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
       Append8BitBytes(bytes, &headerAndDataBits, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else if (tempMode == CBC_QRCoderMode::sALPHANUMERIC) {
       AppendModeInfo(tempMode, &headerAndDataBits, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
-      AppendLengthInfo(splitResult[i]->m_string.GetLength(),
-                       qrCode->GetVersion(), tempMode, &headerAndDataBits, e);
+      AppendLengthInfo(splitResult.second.GetLength(), qrCode->GetVersion(),
+                       tempMode, &headerAndDataBits, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
-      AppendBytes(splitResult[i]->m_string, tempMode, &headerAndDataBits,
-                  encoding, e);
+      AppendBytes(splitResult.second, tempMode, &headerAndDataBits, encoding,
+                  e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else if (tempMode == CBC_QRCoderMode::sNUMERIC) {
       AppendModeInfo(tempMode, &headerAndDataBits, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
-      AppendLengthInfo(splitResult[i]->m_string.GetLength(),
-                       qrCode->GetVersion(), tempMode, &headerAndDataBits, e);
+      AppendLengthInfo(splitResult.second.GetLength(), qrCode->GetVersion(),
+                       tempMode, &headerAndDataBits, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
-      AppendBytes(splitResult[i]->m_string, tempMode, &headerAndDataBits,
-                  encoding, e);
+      AppendBytes(splitResult.second, tempMode, &headerAndDataBits, encoding,
+                  e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
     } else {
       e = BCExceptionUnknown;
       BC_EXCEPTION_CHECK_ReturnVoid(e);
     }
   }
 }
 
-void CBC_QRCoderEncoder::SplitString(const CFX_ByteString& content,
-                                     CFX_ArrayTemplate<Make_Pair*>* result) {
+void CBC_QRCoderEncoder::SplitString(
+    const CFX_ByteString& content,
+    std::vector<std::pair<CBC_QRCoderMode*, CFX_ByteString>>* result) {
   int32_t index = 0, flag = 0;
   while (
       (((uint8_t)content[index] >= 0xA1 && (uint8_t)content[index] <= 0xAA) ||
        ((uint8_t)content[index] >= 0xB0 && (uint8_t)content[index] <= 0xFA)) &&
       (index < content.GetLength())) {
     index += 2;
   }
   if (index != flag) {
-    result->Add(
-        new Make_Pair(CBC_QRCoderMode::sGBK, content.Mid(flag, index - flag)));
+    result->push_back({CBC_QRCoderMode::sGBK, content.Mid(flag, index - flag)});
   }
   flag = index;
   if (index >= content.GetLength()) {
     return;
   }
   while (
       GetAlphaNumericCode((uint8_t)content[index]) == -1 &&
       !(((uint8_t)content[index] >= 0xA1 && (uint8_t)content[index] <= 0xAA) ||
         ((uint8_t)content[index] >= 0xB0 && (uint8_t)content[index] <= 0xFA)) &&
       (index < content.GetLength())) {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
     if (IsDBCSLeadByte((uint8_t)content[index]))
 #else
     if ((uint8_t)content[index] > 127)
 #endif
     {
       index += 2;
     } else {
       index++;
     }
   }
   if (index != flag) {
-    result->Add(
-        new Make_Pair(CBC_QRCoderMode::sBYTE, content.Mid(flag, index - flag)));
+    result->push_back(
+        {CBC_QRCoderMode::sBYTE, content.Mid(flag, index - flag)});
   }
   flag = index;
   if (index >= content.GetLength()) {
     return;
   }
   while (FXSYS_Isdigit((uint8_t)content[index]) &&
          (index < content.GetLength())) {
     index++;
   }
   if (index != flag) {
-    result->Add(new Make_Pair(CBC_QRCoderMode::sNUMERIC,
-                              content.Mid(flag, index - flag)));
+    result->push_back(
+        {CBC_QRCoderMode::sNUMERIC, content.Mid(flag, index - flag)});
   }
   flag = index;
   if (index >= content.GetLength()) {
     return;
   }
   while (GetAlphaNumericCode((uint8_t)content[index]) != -1 &&
          (index < content.GetLength())) {
     index++;
   }
   if (index != flag) {
-    result->Add(new Make_Pair(CBC_QRCoderMode::sALPHANUMERIC,
-                              content.Mid(flag, index - flag)));
+    result->push_back(
+        {CBC_QRCoderMode::sALPHANUMERIC, content.Mid(flag, index - flag)});
   }
   flag = index;
   if (index < content.GetLength())
     SplitString(content.Mid(index, content.GetLength() - index), result);
 }
 
 int32_t CBC_QRCoderEncoder::GetSpanByVersion(CBC_QRCoderMode* modeFirst,
                                              CBC_QRCoderMode* modeSecond,
                                              int32_t versionNum,
                                              int32_t& e) {
@@ skipping 33 matching lines @@
     } else if (versionNum >= 27 && versionNum <= 40) {
       return 9;
     } else {
       e = BCExceptionNoSuchVersion;
       BC_EXCEPTION_CHECK_ReturnValue(e, 0);
     }
   }
   return -1;
 }
 
-void CBC_QRCoderEncoder::MergeString(CFX_ArrayTemplate<Make_Pair*>* result,
-                                     int32_t versionNum,
-                                     int32_t& e) {
-  Make_Pair* first = nullptr;
-  Make_Pair* second = nullptr;
+void CBC_QRCoderEncoder::MergeString(
+    std::vector<std::pair<CBC_QRCoderMode*, CFX_ByteString>>* result,
+    int32_t versionNum,
+    int32_t& e) {
   size_t mergeNum = 0;
-  int32_t i;
-  for (i = 0; ((i < result->GetSize()) && (i + 1 < result->GetSize())); i++) {
-    first = (*result)[i];
-    second = (*result)[i + 1];
-    if (first->m_mode == CBC_QRCoderMode::sALPHANUMERIC) {
+  for (size_t i = 0; i + 1 < result->size(); i++) {
+    auto element1 = &(*result)[i];
+    auto element2 = &(*result)[i + 1];
+    if (element1->first == CBC_QRCoderMode::sALPHANUMERIC) {
       int32_t tmp = GetSpanByVersion(CBC_QRCoderMode::sALPHANUMERIC,
                                      CBC_QRCoderMode::sBYTE, versionNum, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
-      if ((second->m_mode == CBC_QRCoderMode::sBYTE) &&
-          (first->m_string.GetLength() < tmp)) {
-        CFX_ByteString str = first->m_string + second->m_string;
-        second->m_string = str;
-        delete first;
-        result->RemoveAt(i);
+      if (element2->first == CBC_QRCoderMode::sBYTE &&
+          element1->second.GetLength() < tmp) {
+        element2->second = element1->second + element2->second;
+        result->erase(result->begin() + i);
         i--;
         mergeNum++;
       }
-    } else if (first->m_mode == CBC_QRCoderMode::sBYTE) {
-      if (second->m_mode == CBC_QRCoderMode::sBYTE) {
-        first->m_string += second->m_string;
-        delete second;
-        result->RemoveAt(i + 1);
+    } else if (element1->first == CBC_QRCoderMode::sBYTE) {
+      if (element2->first == CBC_QRCoderMode::sBYTE) {
+        element1->second += element2->second;
+        result->erase(result->begin() + i + 1);
         i--;
         mergeNum++;
       }
-    } else if (first->m_mode == CBC_QRCoderMode::sNUMERIC) {
+    } else if (element1->first == CBC_QRCoderMode::sNUMERIC) {
       int32_t tmp = GetSpanByVersion(CBC_QRCoderMode::sNUMERIC,
                                      CBC_QRCoderMode::sBYTE, versionNum, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
-      if ((second->m_mode == CBC_QRCoderMode::sBYTE) &&
-          (first->m_string.GetLength() < tmp)) {
-        CFX_ByteString str = first->m_string + second->m_string;
-        second->m_string = str;
-        delete first;
-        result->RemoveAt(i);
+      if (element2->first == CBC_QRCoderMode::sBYTE &&
+          element1->second.GetLength() < tmp) {
+        element2->second = element1->second + element2->second;
+        result->erase(result->begin() + i);
         i--;
         mergeNum++;
       }
       tmp = GetSpanByVersion(CBC_QRCoderMode::sNUMERIC,
                              CBC_QRCoderMode::sALPHANUMERIC, versionNum, e);
       BC_EXCEPTION_CHECK_ReturnVoid(e);
-      if ((second->m_mode == CBC_QRCoderMode::sALPHANUMERIC) &&
-          (first->m_string.GetLength() < tmp)) {
-        CFX_ByteString str = first->m_string + second->m_string;
-        second->m_string = str;
-        delete first;
-        result->RemoveAt(i);
+      if (element2->first == CBC_QRCoderMode::sALPHANUMERIC &&
+          element1->second.GetLength() < tmp) {
+        element2->second = element1->second + element2->second;
+        result->erase(result->begin() + i);
         i--;
         mergeNum++;
       }
     }
   }
   if (mergeNum == 0) {
     return;
   }
   MergeString(result, versionNum, e);
   BC_EXCEPTION_CHECK_ReturnVoid(e);
@@ skipping 29 matching lines @@
 }
 
 void CBC_QRCoderEncoder::EncodeWithSpecifyVersion(
     const CFX_ByteString& content,
     CBC_QRCoderErrorCorrectionLevel* ecLevel,
     CBC_QRCoder* qrCode,
     int32_t versionSpecify,
     int32_t& e) {
   CFX_ByteString encoding = "utf8";
   CBC_QRCoderMode* mode = CBC_QRCoderMode::sBYTE;
-  CFX_ArrayTemplate<Make_Pair*> splitResult;
+  std::vector<std::pair<CBC_QRCoderMode*, CFX_ByteString>> splitResult;
   CBC_QRCoderBitVector dataBits;
   dataBits.Init();
   SplitString(content, &splitResult);
   MergeString(&splitResult, versionSpecify, e);
   BC_EXCEPTION_CHECK_ReturnVoid(e) CBC_QRCoderMode* tempMode = nullptr;
-  for (int32_t i = 0; i < splitResult.GetSize(); i++) {
-    AppendBytes(splitResult[i]->m_string, splitResult[i]->m_mode, &dataBits,
-                encoding, e);
-    if (e != BCExceptionNO) {
-      for (int32_t y = 0; y < splitResult.GetSize(); y++)
-        delete splitResult[y];
+  for (const auto& result : splitResult) {
+    AppendBytes(result.second, result.first, &dataBits, encoding, e);
+    if (e != BCExceptionNO)
       return;
-    }
   }
   int32_t numInputBytes = dataBits.sizeInBytes();
   CBC_QRCoderBitVector headerAndDataBits;
   headerAndDataBits.Init();
   InitQRCode(numInputBytes, versionSpecify, ecLevel, mode, qrCode, e);
-  if (e != BCExceptionNO) {
-    for (int32_t k = 0; k < splitResult.GetSize(); k++)
-      delete splitResult[k];
-    return;
-  }
-  AppendDataModeLenghInfo(splitResult, headerAndDataBits, tempMode, qrCode,
-                          encoding, e);
-  if (e != BCExceptionNO) {
-    for (int32_t k = 0; k < splitResult.GetSize(); k++)
-      delete splitResult[k];
-    return;
-  }
-  numInputBytes = headerAndDataBits.sizeInBytes();
-  TerminateBits(qrCode->GetNumDataBytes(), &headerAndDataBits, e);
-  for (int32_t j = 0; j < splitResult.GetSize(); j++) {
-    delete splitResult[j];
-  }
   if (e != BCExceptionNO)
     return;
 
+  AppendDataModeLenghInfo(splitResult, headerAndDataBits, tempMode, qrCode,
+                          encoding, e);
+  if (e != BCExceptionNO)
+    return;
+
+  numInputBytes = headerAndDataBits.sizeInBytes();
+  TerminateBits(qrCode->GetNumDataBytes(), &headerAndDataBits, e);
+  if (e != BCExceptionNO)
+    return;
+
   CBC_QRCoderBitVector finalBits;
   finalBits.Init();
   InterleaveWithECBytes(&headerAndDataBits, qrCode->GetNumTotalBytes(),
                         qrCode->GetNumDataBytes(), qrCode->GetNumRSBlocks(),
                         &finalBits, e);
   BC_EXCEPTION_CHECK_ReturnVoid(e);
   std::unique_ptr<CBC_CommonByteMatrix> matrix(new CBC_CommonByteMatrix(
       qrCode->GetMatrixWidth(), qrCode->GetMatrixWidth()));
   matrix->Init();
   int32_t maskPattern = ChooseMaskPattern(
@@ skipping 11 matching lines @@
   }
 }
 
 void CBC_QRCoderEncoder::EncodeWithAutoVersion(
     const CFX_ByteString& content,
     CBC_QRCoderErrorCorrectionLevel* ecLevel,
     CBC_QRCoder* qrCode,
     int32_t& e) {
   CFX_ByteString encoding = "utf8";
   CBC_QRCoderMode* mode = CBC_QRCoderMode::sBYTE;
-  CFX_ArrayTemplate<Make_Pair*> splitResult;
+  std::vector<std::pair<CBC_QRCoderMode*, CFX_ByteString>> splitResult;
   CBC_QRCoderBitVector dataBits;
   dataBits.Init();
   SplitString(content, &splitResult);
   MergeString(&splitResult, 8, e);
   BC_EXCEPTION_CHECK_ReturnVoid(e);
   CBC_QRCoderMode* tempMode = nullptr;
-  for (int32_t i = 0; i < splitResult.GetSize(); i++) {
-    AppendBytes(splitResult[i]->m_string, splitResult[i]->m_mode, &dataBits,
-                encoding, e);
-    if (e != BCExceptionNO) {
-      for (int32_t l = 0; l < splitResult.GetSize(); l++)
-        delete splitResult[l];
+  for (const auto& result : splitResult) {
+    AppendBytes(result.second, result.first, &dataBits, encoding, e);
+    if (e != BCExceptionNO)
       return;
-    }
   }
   int32_t numInputBytes = dataBits.sizeInBytes();
   InitQRCode(numInputBytes, ecLevel, mode, qrCode, e);
   BC_EXCEPTION_CHECK_ReturnVoid(e) CBC_QRCoderBitVector headerAndDataBits;
   headerAndDataBits.Init();
   tempMode = nullptr;
   int32_t versionNum = qrCode->GetVersion();
 sign:
   AppendDataModeLenghInfo(splitResult, headerAndDataBits, tempMode, qrCode,
                           encoding, e);
@@ skipping 12 matching lines @@
     if (e1 != BCExceptionNO) {
       e = e1;
       return;
     }
     versionNum++;
     if (versionNum <= 40) {
       headerAndDataBits.Clear();
       e = BCExceptionNO;
       goto sign;
     } else {
-      for (int32_t j = 0; j < splitResult.GetSize(); j++)
-        delete splitResult[j];
       return;
     }
   }
-  for (int32_t k = 0; k < splitResult.GetSize(); k++)
-    delete splitResult[k];
 
   CBC_QRCoderBitVector finalBits;
   finalBits.Init();
   InterleaveWithECBytes(&headerAndDataBits, qrCode->GetNumTotalBytes(),
                         qrCode->GetNumDataBytes(), qrCode->GetNumRSBlocks(),
                         &finalBits, e);
   BC_EXCEPTION_CHECK_ReturnVoid(e);
   std::unique_ptr<CBC_CommonByteMatrix> matrix(new CBC_CommonByteMatrix(
       qrCode->GetMatrixWidth(), qrCode->GetMatrixWidth()));
   matrix->Init();
@@ skipping 151 matching lines @@
   }
   if (hasAlphaNumeric) {
     return CBC_QRCoderMode::sALPHANUMERIC;
   } else if (hasNumeric) {
     return CBC_QRCoderMode::sNUMERIC;
   }
   return CBC_QRCoderMode::sBYTE;
 }
 
 int32_t CBC_QRCoderEncoder::GetAlphaNumericCode(int32_t code) {
-  if (code < 96 && code >= 0) {
-    return m_alphaNumbericTable[code];
-  }
-  return -1;
+  return (code >= 0 && code < 96) ? g_alphaNumericTable[code] : -1;
 }
 
 void CBC_QRCoderEncoder::AppendBytes(const CFX_ByteString& content,
                                      CBC_QRCoderMode* mode,
                                      CBC_QRCoderBitVector* bits,
                                      CFX_ByteString encoding,
                                      int32_t& e) {
   if (mode == CBC_QRCoderMode::sNUMERIC) {
     AppendNumericBytes(content, bits, e);
     BC_EXCEPTION_CHECK_ReturnVoid(e);
@@ skipping 290 matching lines @@
   CBC_ReedSolomonEncoder encode(CBC_ReedSolomonGF256::QRCodeField);
   encode.Init();
   encode.Encode(&toEncode, numEcBytesInBlock, e);
   BC_EXCEPTION_CHECK_ReturnValue(e, nullptr);
   CBC_CommonByteArray* ecBytes = new CBC_CommonByteArray(numEcBytesInBlock);
   for (int32_t j = 0; j < numEcBytesInBlock; j++) {
     ecBytes->Set(j, toEncode[numDataBytes + j]);
   }
   return ecBytes;
 }