zxing_cpp 0.1.0

data/ext/zxing/zxing-cpp/core/src/zxing/DecodeHints.h

@@ -0,0 +1,85 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __DECODEHINTS_H_
+#define __DECODEHINTS_H_
+/*
+ *  DecodeHintType.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/BarcodeFormat.h>
+#include <zxing/ResultPointCallback.h>
+
+namespace zxing {
+
+typedef unsigned int DecodeHintType;
+class DecodeHints;
+DecodeHints operator | (DecodeHints const&, DecodeHints const&);
+
+class DecodeHints {
+ private:
+  DecodeHintType hints;
+  Ref<ResultPointCallback> callback;
+
+ public:
+  static const DecodeHintType AZTEC_HINT = 1 << BarcodeFormat::AZTEC;
+  static const DecodeHintType CODABAR_HINT = 1 << BarcodeFormat::CODABAR;
+  static const DecodeHintType CODE_39_HINT = 1 << BarcodeFormat::CODE_39;
+  static const DecodeHintType CODE_93_HINT = 1 << BarcodeFormat::CODE_93;
+  static const DecodeHintType CODE_128_HINT = 1 << BarcodeFormat::CODE_128;
+  static const DecodeHintType DATA_MATRIX_HINT = 1 << BarcodeFormat::DATA_MATRIX;
+  static const DecodeHintType EAN_8_HINT = 1 << BarcodeFormat::EAN_8;
+  static const DecodeHintType EAN_13_HINT = 1 << BarcodeFormat::EAN_13;
+  static const DecodeHintType ITF_HINT = 1 << BarcodeFormat::ITF;
+  static const DecodeHintType MAXICODE_HINT = 1 << BarcodeFormat::MAXICODE;
+  static const DecodeHintType PDF_417_HINT = 1 << BarcodeFormat::PDF_417;
+  static const DecodeHintType QR_CODE_HINT = 1 << BarcodeFormat::QR_CODE;
+  static const DecodeHintType RSS_14_HINT = 1 << BarcodeFormat::RSS_14;
+  static const DecodeHintType RSS_EXPANDED_HINT = 1 << BarcodeFormat::RSS_EXPANDED;
+  static const DecodeHintType UPC_A_HINT = 1 << BarcodeFormat::UPC_A;
+  static const DecodeHintType UPC_E_HINT = 1 << BarcodeFormat::UPC_E;
+  static const DecodeHintType UPC_EAN_EXTENSION_HINT = 1 << BarcodeFormat::UPC_EAN_EXTENSION;
+
+  static const DecodeHintType TRYHARDER_HINT = 1 << 31;
+  static const DecodeHintType CHARACTER_SET = 1 << 30;
+  // static const DecodeHintType ALLOWED_LENGTHS = 1 << 29;
+  // static const DecodeHintType ASSUME_CODE_39_CHECK_DIGIT = 1 << 28;
+  static const DecodeHintType  ASSUME_GS1 = 1 << 27;
+  // static const DecodeHintType NEED_RESULT_POINT_CALLBACK = 1 << 26;
+  
+  static const DecodeHints PRODUCT_HINT;
+  static const DecodeHints ONED_HINT;
+  static const DecodeHints DEFAULT_HINT;
+
+  DecodeHints();
+  DecodeHints(DecodeHintType init);
+
+  void addFormat(BarcodeFormat toadd);
+  bool containsFormat(BarcodeFormat tocheck) const;
+  bool isEmpty() const {return (hints==0);}
+  void clear() {hints=0;}
+  void setTryHarder(bool toset);
+  bool getTryHarder() const;
+
+  void setResultPointCallback(Ref<ResultPointCallback> const&);
+  Ref<ResultPointCallback> getResultPointCallback() const;
+
+  friend DecodeHints operator | (DecodeHints const&, DecodeHints const&);
+};
+
+}
+
+#endif

data/ext/zxing/zxing-cpp/core/src/zxing/Exception.cpp

@@ -0,0 +1,43 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Exception.cpp
+ *  ZXing
+ *
+ *  Created by Christian Brunschen on 03/06/2008.
+ *  Copyright 2008-2011 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+
+ */
+
+#include <zxing/ZXing.h>
+#include <zxing/Exception.h>
+#include <string.h>
+
+using zxing::Exception;
+
+void Exception::deleteMessage() {
+  delete [] message;
+}
+
+char const* Exception::copy(char const* msg) {
+  char* message = 0;
+  if (msg) {
+    int l = strlen(msg)+1;
+    if (l) {
+      message = new char[l];
+      strcpy(message, msg);
+    }
+  }
+  return message;
+}

data/ext/zxing/zxing-cpp/core/src/zxing/Exception.h

@@ -0,0 +1,51 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __EXCEPTION_H__
+#define __EXCEPTION_H__
+
+/*
+ *  Exception.h
+ *  ZXing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+#include <exception>
+
+namespace zxing {
+
+class Exception : public std::exception {
+private:
+  char const* const message;
+
+public:
+  Exception() throw() : message(0) {}
+  Exception(const char* msg) throw() : message(copy(msg)) {}
+  Exception(Exception const& that) throw() : std::exception(that), message(copy(that.message)) {}
+  ~Exception() throw() {
+    if(message) {
+      deleteMessage();
+    }
+  }
+  char const* what() const throw() {return message ? message : "";}
+
+private:
+  static char const* copy(char const*);
+  void deleteMessage();
+};
+
+}
+
+#endif // __EXCEPTION_H__

data/ext/zxing/zxing-cpp/core/src/zxing/FormatException.cpp

@@ -0,0 +1,41 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  FormatException.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 13/05/2008.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/FormatException.h>
+
+namespace zxing {
+
+FormatException::FormatException() {}
+
+FormatException::FormatException(const char *msg) :
+    ReaderException(msg) {
+}
+
+FormatException::~FormatException() throw() {
+}
+
+FormatException const&
+FormatException::getFormatInstance() {
+  static FormatException instance;
+  return instance;
+}
+
+}

data/ext/zxing/zxing-cpp/core/src/zxing/FormatException.h

@@ -0,0 +1,37 @@
+#ifndef __FORMAT_EXCEPTION_H__
+#define __FORMAT_EXCEPTION_H__
+
+/*
+ *  FormatException.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/ReaderException.h>
+
+namespace zxing {
+
+class FormatException : public ReaderException {
+public:
+  FormatException();
+  FormatException(const char *msg);
+  ~FormatException() throw();
+
+  static FormatException const& getFormatInstance();
+};
+
+}
+#endif // __FORMAT_EXCEPTION_H__

data/ext/zxing/zxing-cpp/core/src/zxing/IllegalStateException.h

@@ -0,0 +1,35 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __ILLEGAL_STATE_EXCEPTION_H__
+#define __ILLEGAL_STATE_EXCEPTION_H__
+
+/*
+ * Copyright 20011 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may illegal use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/ReaderException.h>
+
+namespace zxing {
+
+class IllegalStateException : public ReaderException {
+public:
+  IllegalStateException() throw() {}
+  IllegalStateException(const char *msg) throw() : ReaderException(msg) {}
+  ~IllegalStateException() throw() {}
+};
+
+}
+
+#endif // __ILLEGAL_STATE_EXCEPTION_H__

data/ext/zxing/zxing-cpp/core/src/zxing/InvertedLuminanceSource.cpp

@@ -0,0 +1,68 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Copyright 2013 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/ZXing.h>
+#include <zxing/InvertedLuminanceSource.h>
+
+using zxing::boolean;
+using zxing::Ref;
+using zxing::ArrayRef;
+using zxing::LuminanceSource;
+using zxing::InvertedLuminanceSource;
+
+InvertedLuminanceSource::InvertedLuminanceSource(Ref<LuminanceSource> const& delegate_)
+    : Super(delegate_->getWidth(), delegate_->getHeight()), delegate(delegate_) {}  
+
+ArrayRef<char> InvertedLuminanceSource::getRow(int y, ArrayRef<char> row) const {
+  row = delegate->getRow(y, row);
+  int width = getWidth();
+  for (int i = 0; i < width; i++) {
+    row[i] = (byte) (255 - (row[i] & 0xFF));
+  }
+  return row;
+}
+
+ArrayRef<char> InvertedLuminanceSource::getMatrix() const {
+  ArrayRef<char> matrix = delegate->getMatrix();
+  int length = getWidth() * getHeight();
+  ArrayRef<char> invertedMatrix(length);
+  for (int i = 0; i < length; i++) {
+    invertedMatrix[i] = (byte) (255 - (matrix[i] & 0xFF));
+  }
+  return invertedMatrix;
+}
+
+zxing::boolean InvertedLuminanceSource::isCropSupported() const {
+  return delegate->isCropSupported();
+}
+
+Ref<LuminanceSource> InvertedLuminanceSource::crop(int left, int top, int width, int height) const {
+  return Ref<LuminanceSource>(new InvertedLuminanceSource(delegate->crop(left, top, width, height)));
+}
+
+boolean InvertedLuminanceSource::isRotateSupported() const {
+  return delegate->isRotateSupported();
+}
+
+Ref<LuminanceSource> InvertedLuminanceSource::invert() const {
+  return delegate;
+}
+
+Ref<LuminanceSource> InvertedLuminanceSource::rotateCounterClockwise() const {
+  return Ref<LuminanceSource>(new InvertedLuminanceSource(delegate->rotateCounterClockwise()));
+}
+

data/ext/zxing/zxing-cpp/core/src/zxing/InvertedLuminanceSource.h

@@ -0,0 +1,48 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __INVERTEDLUMINANCESOURCE_H__
+#define __INVERTEDLUMINANCESOURCE_H__
+/*
+ *  Copyright 2013 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/ZXing.h>
+#include <zxing/LuminanceSource.h>
+
+namespace zxing {
+
+class InvertedLuminanceSource : public LuminanceSource {
+private:
+  typedef LuminanceSource Super;
+  const Ref<LuminanceSource> delegate;
+
+public:
+  InvertedLuminanceSource(Ref<LuminanceSource> const&);
+
+  ArrayRef<char> getRow(int y, ArrayRef<char> row) const;
+  ArrayRef<char> getMatrix() const;
+
+  boolean isCropSupported() const;
+  Ref<LuminanceSource> crop(int left, int top, int width, int height) const;
+
+  boolean isRotateSupported() const;
+
+  virtual Ref<LuminanceSource> invert() const;
+
+  Ref<LuminanceSource> rotateCounterClockwise() const;
+};
+
+}
+
+#endif /* INVERTEDLUMINANCESOURCE_H_ */

data/ext/zxing/zxing-cpp/core/src/zxing/LuminanceSource.cpp

@@ -0,0 +1,86 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  LuminanceSource.cpp
+ *  zxing
+ *
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <sstream>
+#include <zxing/LuminanceSource.h>
+#include <zxing/InvertedLuminanceSource.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+using zxing::Ref;
+using zxing::LuminanceSource;
+
+LuminanceSource::LuminanceSource(int width_, int height_) :width(width_), height(height_) {}
+
+LuminanceSource::~LuminanceSource() {}
+
+bool LuminanceSource::isCropSupported() const {
+  return false;
+}
+
+Ref<LuminanceSource> LuminanceSource::crop(int, int, int, int) const {
+  throw IllegalArgumentException("This luminance source does not support cropping.");
+}
+
+bool LuminanceSource::isRotateSupported() const {
+  return false;
+}
+
+Ref<LuminanceSource> LuminanceSource::rotateCounterClockwise() const {
+  throw IllegalArgumentException("This luminance source does not support rotation.");
+}
+
+LuminanceSource::operator std::string() const {
+  ArrayRef<char> row;
+  std::ostringstream oss;
+  for (int y = 0; y < getHeight(); y++) {
+    row = getRow(y, row);
+    for (int x = 0; x < getWidth(); x++) {
+      int luminance = row[x] & 0xFF;
+      char c;
+      if (luminance < 0x40) {
+        c = '#';
+      } else if (luminance < 0x80) {
+        c = '+';
+      } else if (luminance < 0xC0) {
+        c = '.';
+      } else {
+        c = ' ';
+      }
+      oss << c;
+    }
+    oss << '\n';
+  }
+  return oss.str();
+}
+
+Ref<LuminanceSource> LuminanceSource::invert() const {
+
+  // N.B.: this only works because we use counted objects with the
+  // count in the object. This is _not_ how things like shared_ptr
+  // work. They do not allow you to make a smart pointer from a native
+  // pointer more than once. If we ever switch to (something like)
+  // shared_ptr's, the luminace source is going to have keep a weak
+  // pointer to itself from which it can create a strong pointer as
+  // needed. And, FWIW, that has nasty semantics in the face of
+  // exceptions during construction.
+
+  return Ref<LuminanceSource>
+      (new InvertedLuminanceSource(Ref<LuminanceSource>(const_cast<LuminanceSource*>(this))));
+}