changed all Ref to QSharedPointer

ftylitak · ftylitak · Aug 8, 2021 · Aug 1, 2021 · Aug 1, 2021 · Aug 1, 2021
commit d601d8e74c768f7c09fb184096912ac807ff7f8f
diff --git a/src/CameraImageWrapper.cpp b/src/CameraImageWrapper.cpp
@@ -71,7 +71,7 @@ CameraImageWrapper::CameraImageWrapper(const QImage &sourceImage) : LuminanceSou
 {
     updateImageAsGrayscale( sourceImage );
 
-    delegate = Ref<GreyscaleLuminanceSource>(
+    delegate = QSharedPointer<GreyscaleLuminanceSource>(
                 new GreyscaleLuminanceSource(getMatrixP(), sourceImage.width(), sourceImage.height(),0, 0, sourceImage.width(), sourceImage.height()));
 }
 
@@ -130,7 +130,7 @@ bool CameraImageWrapper::isCropSupported() const
         return LuminanceSource::isCropSupported();
 }
 
-Ref<LuminanceSource> CameraImageWrapper::crop(int left, int top, int width, int height) const
+QSharedPointer<LuminanceSource> CameraImageWrapper::crop(int left, int top, int width, int height) const
 {
     if(delegate)
         return delegate->crop(left, top, width, height);
@@ -146,15 +146,15 @@ bool CameraImageWrapper::isRotateSupported() const
         return LuminanceSource::isRotateSupported();
 }
 
-Ref<LuminanceSource> CameraImageWrapper::invert() const
+QSharedPointer<LuminanceSource> CameraImageWrapper::invert() const
 {
     if(delegate)
         return delegate->invert();
     else
         return LuminanceSource::invert();
 }
 
-Ref<LuminanceSource> CameraImageWrapper::rotateCounterClockwise() const
+QSharedPointer<LuminanceSource> CameraImageWrapper::rotateCounterClockwise() const
 {
     if(delegate)
         return delegate->rotateCounterClockwise();

diff --git a/src/CameraImageWrapper.h b/src/CameraImageWrapper.h
@@ -34,16 +34,16 @@ class CameraImageWrapper : public LuminanceSource
     static CameraImageWrapper* Factory(const QImage& image, int maxWidth=-1, int maxHeight=-1, bool smoothTransformation=false);
 
     QSharedPointer<std::vector<QSharedPointer<std::vector<zxing::byte>> > getOriginalImage();
-    Ref<GreyscaleLuminanceSource> getDelegate() { return delegate; }
+    QSharedPointer<GreyscaleLuminanceSource> getDelegate() { return delegate; }
 
     QSharedPointer<std::vector<zxing::byte>> getRow(int y, QSharedPointer<std::vector<zxing::byte>> row) const;
     QSharedPointer<std::vector<zxing::byte>> getMatrix() const;
 
     bool isCropSupported() const;
-    Ref<LuminanceSource> crop(int left, int top, int width, int height) const;
+    QSharedPointer<LuminanceSource> crop(int left, int top, int width, int height) const;
     bool isRotateSupported() const;
-    Ref<LuminanceSource> invert() const;
-    Ref<LuminanceSource> rotateCounterClockwise() const;
+    QSharedPointer<LuminanceSource> invert() const;
+    QSharedPointer<LuminanceSource> rotateCounterClockwise() const;
 
     inline zxing::byte gray(const unsigned int r, const unsigned int g, const unsigned int b);
 
@@ -52,7 +52,7 @@ class CameraImageWrapper : public LuminanceSource
     QSharedPointer<std::vector<zxing::byte>> getMatrixP() const;
     void updateImageAsGrayscale(const QImage &origin);
 
-    Ref<GreyscaleLuminanceSource> delegate;
+    QSharedPointer<GreyscaleLuminanceSource> delegate;
     QSharedPointer<std::vector<QSharedPointer<std::vector<zxing::byte>>> imageBytesPerRow;
     QSharedPointer<std::vector<zxing::byte>> imageBytes;
 

diff --git a/src/QZXing.cpp b/src/QZXing.cpp
@@ -345,7 +345,7 @@ void QZXing::setDecoder(const uint &hint)
  * \param bitMatrix
  * \return
  */
-QRectF getTagRect(const QSharedPointer<std::vector<Ref<ResultPoint>> > &resultPoints, const Ref<BitMatrix> &bitMatrix)
+QRectF getTagRect(const QSharedPointer<std::vector<QSharedPointer<ResultPoint>> > &resultPoints, const QSharedPointer<BitMatrix> &bitMatrix)
 {
     if (resultPoints->size() < 2)
         return QRectF();
@@ -355,7 +355,7 @@ QRectF getTagRect(const QSharedPointer<std::vector<Ref<ResultPoint>> > &resultPo
     // 1D barcode
     if (resultPoints->size() == 2) {
         WhiteRectangleDetector detector(bitMatrix);
-        std::vector<Ref<ResultPoint> > resultRectPoints = detector.detect();
+        std::vector<QSharedPointer<ResultPoint> > resultRectPoints = detector.detect();
 
         if (resultRectPoints.size() != 4)
             return QRectF();
@@ -414,7 +414,7 @@ QString QZXing::decodeImage(const QImage &image, int maxWidth, int maxHeight, bo
     QElapsedTimer t;
     t.start();
     processingTime = -1;
-    Ref<Result> res;
+    QSharedPointer<Result> res;
     emit decodingStarted();
 
     if(image.isNull())
@@ -434,10 +434,10 @@ QString QZXing::decodeImage(const QImage &image, int maxWidth, int maxHeight, bo
 
     QString errorMessage = "Unknown";
 
-    Ref<LuminanceSource> imageRefOriginal = Ref<LuminanceSource>(ciw);
-    Ref<LuminanceSource> imageRef = imageRefOriginal;
-    Ref<GlobalHistogramBinarizer> binz;
-    Ref<BinaryBitmap> bb;
+    QSharedPointer<LuminanceSource> imageRefOriginal = QSharedPointer<LuminanceSource>(ciw);
+    QSharedPointer<LuminanceSource> imageRef = imageRefOriginal;
+    QSharedPointer<GlobalHistogramBinarizer> binz;
+    QSharedPointer<BinaryBitmap> bb;
 
     size_t numberOfIterations = 0;
     if (imageSourceFilter & SourceFilter_ImageNormal)
@@ -451,10 +451,10 @@ QString QZXing::decodeImage(const QImage &image, int maxWidth, int maxHeight, bo
         try {
             if((numberOfIterations == 1 && (imageSourceFilter & SourceFilter_ImageInverted)) || i == 1) {
                 //qDebug() << "Selecting Inverted Luminance source";
-                imageRef = Ref<LuminanceSource>((LuminanceSource*)(new InvertedLuminanceSource(imageRefOriginal)));
+                imageRef = QSharedPointer<LuminanceSource>((LuminanceSource*)(new InvertedLuminanceSource(imageRefOriginal)));
             }
-            binz = Ref<GlobalHistogramBinarizer>( new GlobalHistogramBinarizer(imageRef) );
-            bb = Ref<BinaryBitmap>( new BinaryBitmap(binz) );
+            binz = QSharedPointer<GlobalHistogramBinarizer>( new GlobalHistogramBinarizer(imageRef) );
+            bb = QSharedPointer<BinaryBitmap>( new BinaryBitmap(binz) );
 
             DecodeHints hints(static_cast<DecodeHintType>(enabledDecoders));
 
@@ -493,13 +493,13 @@ QString QZXing::decodeImage(const QImage &image, int maxWidth, int maxHeight, bo
             }
 
             if (!lastDecodeOperationSucceded_&& tryHarder_ && (tryHarderType & TryHarderBehaviour_Rotate) && bb->isRotateSupported()) {
-                Ref<BinaryBitmap> bbTmp = bb;
+                QSharedPointer<BinaryBitmap> bbTmp = bb;
 
                 //qDebug() << "Decoding phase 2, rotate: starting";
 
                 hints.setTryHarder(true);
                 for (int i=0; (i<3 && !lastDecodeOperationSucceded_); i++) {
-                    Ref<BinaryBitmap> rotatedImage(bbTmp->rotateCounterClockwise());
+                    QSharedPointer<BinaryBitmap> rotatedImage(bbTmp->rotateCounterClockwise());
                     bbTmp = rotatedImage;
 
                     try {
@@ -670,7 +670,7 @@ QImage QZXing::encodeData(const QString &data, const QZXingEncoderConfig &encode
 #ifdef ENABLE_ENCODER_QR_CODE
         case EncoderFormat_QR_CODE:
         {
-            Ref<qrcode::QRCode> barcode = qrcode::Encoder::encode(
+            QSharedPointer<qrcode::QRCode> barcode = qrcode::Encoder::encode(
                         data.toStdWString(),
                         encoderConfig.errorCorrectionLevel == EncodeErrorCorrectionLevel_H ?
                             qrcode::ErrorCorrectionLevel::H :
@@ -680,7 +680,7 @@ QImage QZXing::encodeData(const QString &data, const QZXingEncoderConfig &encode
                                       qrcode::ErrorCorrectionLevel::M :
                                       qrcode::ErrorCorrectionLevel::L)));
 
-            Ref<qrcode::ByteMatrix> bytesRef = barcode->getMatrix();
+            QSharedPointer<qrcode::ByteMatrix> bytesRef = barcode->getMatrix();
             const std::vector< std::vector <zxing::byte> >& bytes = bytesRef->getArray();
             const int width = int(bytesRef->getWidth()) + (encoderConfig.border ? 2 : 0);
             const int height = int(bytesRef->getHeight()) + (encoderConfig.border ? 2 : 0);

diff --git a/src/zxing/zxing/Binarizer.cpp b/src/zxing/zxing/Binarizer.cpp
@@ -24,13 +24,13 @@
 
 namespace zxing {
 
-	Binarizer::Binarizer(Ref<LuminanceSource> source) : source_(source) {
+	Binarizer::Binarizer(QSharedPointer<LuminanceSource> source) : source_(source) {
   }
 
 	Binarizer::~Binarizer() {
 	}
 
-	Ref<LuminanceSource> Binarizer::getLuminanceSource() const {
+	QSharedPointer<LuminanceSource> Binarizer::getLuminanceSource() const {
 		return source_;
 	}
 

diff --git a/src/zxing/zxing/Binarizer.h b/src/zxing/zxing/Binarizer.h
@@ -27,19 +27,19 @@
 
 namespace zxing {
 
-class Binarizer : public Counted {
+class Binarizer  {
  private:
-  Ref<LuminanceSource> source_;
+  QSharedPointer<LuminanceSource> source_;
 
  public:
-  Binarizer(Ref<LuminanceSource> source);
+  Binarizer(QSharedPointer<LuminanceSource> source);
   virtual ~Binarizer();
 
-  virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row) = 0;
-  virtual Ref<BitMatrix> getBlackMatrix() = 0;
+  virtual QSharedPointer<BitArray> getBlackRow(int y, QSharedPointer<BitArray> row) = 0;
+  virtual QSharedPointer<BitMatrix> getBlackMatrix() = 0;
 
-  Ref<LuminanceSource> getLuminanceSource() const ;
-  virtual Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source) = 0;
+  QSharedPointer<LuminanceSource> getLuminanceSource() const ;
+  virtual QSharedPointer<Binarizer> createBinarizer(QSharedPointer<LuminanceSource> source) = 0;
 
   int getWidth() const;
   int getHeight() const;

diff --git a/src/zxing/zxing/BinaryBitmap.cpp b/src/zxing/zxing/BinaryBitmap.cpp
@@ -25,20 +25,20 @@ using zxing::LuminanceSource;
 // VC++
 using zxing::Binarizer;
 
-BinaryBitmap::BinaryBitmap(Ref<Binarizer> binarizer) : binarizer_(binarizer)
+BinaryBitmap::BinaryBitmap(QSharedPointer<Binarizer> binarizer) : binarizer_(binarizer)
 {
 }
 
 BinaryBitmap::~BinaryBitmap()
 {
 }
 
-Ref<BitArray> BinaryBitmap::getBlackRow(int y, Ref<BitArray> row)
+QSharedPointer<BitArray> BinaryBitmap::getBlackRow(int y, QSharedPointer<BitArray> row)
 {
     return binarizer_->getBlackRow(y, row);
 }
 
-Ref<BitMatrix> BinaryBitmap::getBlackMatrix()
+QSharedPointer<BitMatrix> BinaryBitmap::getBlackMatrix()
 {
     return binarizer_->getBlackMatrix();
 }
@@ -53,7 +53,7 @@ int BinaryBitmap::getHeight() const
     return getLuminanceSource()->getHeight();
 }
 
-Ref<LuminanceSource> BinaryBitmap::getLuminanceSource() const
+QSharedPointer<LuminanceSource> BinaryBitmap::getLuminanceSource() const
 {
     return binarizer_->getLuminanceSource();
 }
@@ -63,22 +63,22 @@ bool BinaryBitmap::isCropSupported() const
     return getLuminanceSource()->isCropSupported();
 }
 
-Ref<BinaryBitmap> BinaryBitmap::crop(int left, int top, int width, int height)
+QSharedPointer<BinaryBitmap> BinaryBitmap::crop(int left, int top, int width, int height)
 {
-    return Ref<BinaryBitmap>(new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->crop(left, top, width, height))));
+    return QSharedPointer<BinaryBitmap>(new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->crop(left, top, width, height))));
 }
 
 bool BinaryBitmap::isRotateSupported() const
 {
     return getLuminanceSource()->isRotateSupported();
 }
 
-Ref<BinaryBitmap> BinaryBitmap::rotateCounterClockwise()
+QSharedPointer<BinaryBitmap> BinaryBitmap::rotateCounterClockwise()
 {
-    return Ref<BinaryBitmap>(new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->rotateCounterClockwise())));
+    return QSharedPointer<BinaryBitmap>(new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->rotateCounterClockwise())));
 }
 
-Ref<zxing::BinaryBitmap> BinaryBitmap::rotateCounterClockwise45()
+QSharedPointer<zxing::BinaryBitmap> BinaryBitmap::rotateCounterClockwise45()
 {
-    return Ref<BinaryBitmap>(new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->rotateCounterClockwise45())));
+    return QSharedPointer<BinaryBitmap>(new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->rotateCounterClockwise45())));
 }
diff --git a/src/zxing/zxing/BinaryBitmap.h b/src/zxing/zxing/BinaryBitmap.h
@@ -27,28 +27,28 @@
 
 namespace zxing {
 
-	class BinaryBitmap : public Counted {
+	class BinaryBitmap  {
 	private:
-		Ref<Binarizer> binarizer_;
+		QSharedPointer<Binarizer> binarizer_;
 
 	public:
-		BinaryBitmap(Ref<Binarizer> binarizer);
+		BinaryBitmap(QSharedPointer<Binarizer> binarizer);
 		virtual ~BinaryBitmap();
 
-		Ref<BitArray> getBlackRow(int y, Ref<BitArray> row);
-		Ref<BitMatrix> getBlackMatrix();
+		QSharedPointer<BitArray> getBlackRow(int y, QSharedPointer<BitArray> row);
+		QSharedPointer<BitMatrix> getBlackMatrix();
 
-		Ref<LuminanceSource> getLuminanceSource() const;
+		QSharedPointer<LuminanceSource> getLuminanceSource() const;
 
 		int getWidth() const;
 		int getHeight() const;
 
 		bool isRotateSupported() const;
-		Ref<BinaryBitmap> rotateCounterClockwise();
-        Ref<BinaryBitmap> rotateCounterClockwise45();
+		QSharedPointer<BinaryBitmap> rotateCounterClockwise();
+        QSharedPointer<BinaryBitmap> rotateCounterClockwise45();
 
 		bool isCropSupported() const;
-		Ref<BinaryBitmap> crop(int left, int top, int width, int height);
+		QSharedPointer<BinaryBitmap> crop(int left, int top, int width, int height);
 	};
 
 }

diff --git a/src/zxing/zxing/DecodeHints.cpp b/src/zxing/zxing/DecodeHints.cpp
@@ -245,12 +245,12 @@ std::set<int> DecodeHints::getAllowedEanExtensions() const
   return allowedEanExtensions;
 }
 
-void DecodeHints::setResultPointCallback(Ref<ResultPointCallback> const &_callback)
+void DecodeHints::setResultPointCallback(QSharedPointer<ResultPointCallback> const &_callback)
 {
   callback = _callback;
 }
 
-Ref<ResultPointCallback> DecodeHints::getResultPointCallback() const
+QSharedPointer<ResultPointCallback> DecodeHints::getResultPointCallback() const
 {
   return callback;
 }

diff --git a/src/zxing/zxing/DecodeHints.h b/src/zxing/zxing/DecodeHints.h
@@ -35,7 +35,7 @@ DecodeHints operator & (DecodeHints const&, DecodeHints const&);
 class DecodeHints {
  private:
   DecodeHintType hints;
-  Ref<ResultPointCallback> callback;
+  QSharedPointer<ResultPointCallback> callback;
   std::set<int> allowedEanExtensions;
 
  public:
@@ -82,8 +82,8 @@ class DecodeHints {
   void setAllowedEanExtensions(std::set<int> toset);
   std::set<int> getAllowedEanExtensions() const;
 
-  void setResultPointCallback(Ref<ResultPointCallback> const&);
-  Ref<ResultPointCallback> getResultPointCallback() const;
+  void setResultPointCallback(QSharedPointer<ResultPointCallback> const&);
+  QSharedPointer<ResultPointCallback> getResultPointCallback() const;
 
   DecodeHints& operator =(DecodeHints const &other);
 

diff --git a/src/zxing/zxing/InvertedLuminanceSource.cpp b/src/zxing/zxing/InvertedLuminanceSource.cpp
@@ -24,7 +24,7 @@ using zxing::LuminanceSource;
 namespace zxing
 {
 
-  InvertedLuminanceSource::InvertedLuminanceSource(Ref<LuminanceSource> const &delegate_)
+  InvertedLuminanceSource::InvertedLuminanceSource(QSharedPointer<LuminanceSource> const &delegate_)
       : Super(delegate_->getWidth(), delegate_->getHeight()), delegate(delegate_) {}
 
   QSharedPointer<std::vector<zxing::byte>> InvertedLuminanceSource::getRow(int y, QSharedPointer<std::vector<zxing::byte>> row) const
@@ -55,24 +55,24 @@ namespace zxing
     return delegate->isCropSupported();
   }
 
-  Ref<LuminanceSource> InvertedLuminanceSource::crop(int left, int top, int width, int height) const
+  QSharedPointer<LuminanceSource> InvertedLuminanceSource::crop(int left, int top, int width, int height) const
   {
-    return Ref<LuminanceSource>(new InvertedLuminanceSource(delegate->crop(left, top, width, height)));
+    return QSharedPointer<LuminanceSource>(new InvertedLuminanceSource(delegate->crop(left, top, width, height)));
   }
 
   zxing::boolean InvertedLuminanceSource::isRotateSupported() const
   {
     return delegate->isRotateSupported();
   }
 
-  Ref<LuminanceSource> InvertedLuminanceSource::invert() const
+  QSharedPointer<LuminanceSource> InvertedLuminanceSource::invert() const
   {
     return delegate;
   }
 
-  Ref<LuminanceSource> InvertedLuminanceSource::rotateCounterClockwise() const
+  QSharedPointer<LuminanceSource> InvertedLuminanceSource::rotateCounterClockwise() const
   {
-    return Ref<LuminanceSource>(new InvertedLuminanceSource(delegate->rotateCounterClockwise()));
+    return QSharedPointer<LuminanceSource>(new InvertedLuminanceSource(delegate->rotateCounterClockwise()));
   }
 
 }