rhodes 5.5.15 → 5.5.17

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/CharacterSetECI.cpp

@@ -0,0 +1,104 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ * Copyright 2008-2011 ZXing authors
+ *
+ * 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/common/CharacterSetECI.h>
+#include <zxing/common/IllegalArgumentException.h>
+#include <zxing/FormatException.h>
+
+using std::string;
+
+using zxing::common::CharacterSetECI;
+using zxing::IllegalArgumentException;
+
+std::map<int, CharacterSetECI*> CharacterSetECI::VALUE_TO_ECI;
+std::map<std::string, CharacterSetECI*> CharacterSetECI::NAME_TO_ECI;
+
+const bool CharacterSetECI::inited = CharacterSetECI::init_tables();
+
+#define ADD_CHARACTER_SET(VALUES, STRINGS) \
+  { static int values[] = {VALUES, -1}; \
+    static char const* strings[] = {STRINGS, 0}; \
+    addCharacterSet(values, strings); }
+
+#define XC ,
+
+bool CharacterSetECI::init_tables() {
+  ADD_CHARACTER_SET(0 XC 2, "Cp437");
+  ADD_CHARACTER_SET(1 XC 3, "ISO8859_1" XC "ISO-8859-1");
+  ADD_CHARACTER_SET(4, "ISO8859_2" XC "ISO-8859-2");
+  ADD_CHARACTER_SET(5, "ISO8859_3" XC "ISO-8859-3");
+  ADD_CHARACTER_SET(6, "ISO8859_4" XC "ISO-8859-4");
+  ADD_CHARACTER_SET(7, "ISO8859_5" XC "ISO-8859-5");
+  ADD_CHARACTER_SET(8, "ISO8859_6" XC "ISO-8859-6");
+  ADD_CHARACTER_SET(9, "ISO8859_7" XC "ISO-8859-7");
+  ADD_CHARACTER_SET(10, "ISO8859_8" XC "ISO-8859-8");
+  ADD_CHARACTER_SET(11, "ISO8859_9" XC "ISO-8859-9");
+  ADD_CHARACTER_SET(12, "ISO8859_10" XC "ISO-8859-10");
+  ADD_CHARACTER_SET(13, "ISO8859_11" XC "ISO-8859-11");
+  ADD_CHARACTER_SET(15, "ISO8859_13" XC "ISO-8859-13");
+  ADD_CHARACTER_SET(16, "ISO8859_14" XC "ISO-8859-14");
+  ADD_CHARACTER_SET(17, "ISO8859_15" XC "ISO-8859-15");
+  ADD_CHARACTER_SET(18, "ISO8859_16" XC "ISO-8859-16");
+  ADD_CHARACTER_SET(20, "SJIS" XC "Shift_JIS");
+  ADD_CHARACTER_SET(21, "Cp1250" XC "windows-1250");
+  ADD_CHARACTER_SET(22, "Cp1251" XC "windows-1251");
+  ADD_CHARACTER_SET(23, "Cp1252" XC "windows-1252");
+  ADD_CHARACTER_SET(24, "Cp1256" XC "windows-1256");
+  ADD_CHARACTER_SET(25, "UnicodeBigUnmarked" XC "UTF-16BE" XC "UnicodeBig");
+  ADD_CHARACTER_SET(26, "UTF8" XC "UTF-8");
+  ADD_CHARACTER_SET(27 XC 170, "ASCII" XC "US-ASCII");
+  ADD_CHARACTER_SET(28, "Big5");
+  ADD_CHARACTER_SET(29, "GB18030" XC "GB2312" XC "EUC_CN" XC "GBK");
+  ADD_CHARACTER_SET(30, "EUC_KR" XC "EUC-KR");
+  return true;
+}
+
+#undef XC
+
+CharacterSetECI::CharacterSetECI(int const* values,
+                                 char const* const* names) 
+  : values_(values), names_(names) {
+  for(int const* values = values_; *values != -1; values++) {
+    VALUE_TO_ECI[*values] = this;
+  }
+  for(char const* const* names = names_; *names; names++) {
+    NAME_TO_ECI[string(*names)] = this;
+  }
+}
+
+char const* CharacterSetECI::name() const {
+  return names_[0];
+}
+
+int CharacterSetECI::getValue() const {
+  return values_[0];
+}
+
+void CharacterSetECI::addCharacterSet(int const* values, char const* const* names) {
+  new CharacterSetECI(values, names);
+}
+
+CharacterSetECI* CharacterSetECI::getCharacterSetECIByValue(int value) {
+  if (value < 0 || value >= 900) {
+    throw FormatException();
+  }
+  return VALUE_TO_ECI[value];
+}
+
+CharacterSetECI* CharacterSetECI::getCharacterSetECIByName(string const& name) {
+  return NAME_TO_ECI[name];
+}

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/CharacterSetECI.h

@@ -0,0 +1,53 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __CHARACTERSET_ECI__
+#define __CHARACTERSET_ECI__
+
+/*
+ * Copyright 2008-2011 ZXing authors
+ *
+ * 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 <map>
+#include <zxing/DecodeHints.h>
+
+namespace zxing {
+namespace common {
+
+class CharacterSetECI {
+private:
+  static std::map<int, CharacterSetECI*> VALUE_TO_ECI;
+  static std::map<std::string, CharacterSetECI*> NAME_TO_ECI;
+  static const bool inited;
+  static bool init_tables();
+
+  int const* const values_;
+  char const* const* const names_;
+
+  CharacterSetECI(int const* values, char const* const* names);
+
+  static void addCharacterSet(int const* value, char const* const* encodingNames);
+
+public:
+  char const* name() const;
+  int getValue() const;
+
+  static CharacterSetECI* getCharacterSetECIByValue(int value);
+  static CharacterSetECI* getCharacterSetECIByName(std::string const& name);
+};
+
+}
+}
+
+#endif

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/Counted.h

@@ -0,0 +1,140 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __COUNTED_H__
+#define __COUNTED_H__
+
+/*
+ *  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 <iostream>
+
+namespace zxing {
+
+/* base class for reference-counted objects */
+class Counted {
+private:
+  unsigned int count_;
+public:
+  Counted() :
+      count_(0) {
+  }
+  virtual ~Counted() {
+  }
+  Counted *retain() {
+    count_++;
+    return this;
+  }
+  void release() {
+    count_--;
+    if (count_ == 0) {
+      count_ = 0xDEADF001;
+      delete this;
+    }
+  }
+
+
+  /* return the current count for denugging purposes or similar */
+  int count() const {
+    return count_;
+  }
+};
+
+/* counting reference to reference-counted objects */
+template<typename T> class Ref {
+private:
+public:
+  T *object_;
+  explicit Ref(T *o = 0) :
+      object_(0) {
+    reset(o);
+  }
+  Ref(const Ref &other) :
+      object_(0) {
+    reset(other.object_);
+  }
+
+  template<class Y>
+  Ref(const Ref<Y> &other) :
+      object_(0) {
+    reset(other.object_);
+  }
+
+  ~Ref() {
+    if (object_) {
+      object_->release();
+    }
+  }
+
+  void reset(T *o) {
+    if (o) {
+      o->retain();
+    }
+    if (object_ != 0) {
+      object_->release();
+    }
+    object_ = o;
+  }
+  Ref& operator=(const Ref &other) {
+    reset(other.object_);
+    return *this;
+  }
+  template<class Y>
+  Ref& operator=(const Ref<Y> &other) {
+    reset(other.object_);
+    return *this;
+  }
+  Ref& operator=(T* o) {
+    reset(o);
+    return *this;
+  }
+  template<class Y>
+  Ref& operator=(Y* o) {
+    reset(o);
+    return *this;
+  }
+
+  T& operator*() {
+    return *object_;
+  }
+  T* operator->() const {
+    return object_;
+  }
+  operator T*() const {
+    return object_;
+  }
+
+  bool operator==(const T* that) {
+    return object_ == that;
+  }
+  bool operator==(const Ref &other) const {
+    return object_ == other.object_ || *object_ == *(other.object_);
+  }
+  template<class Y>
+  bool operator==(const Ref<Y> &other) const {
+    return object_ == other.object_ || *object_ == *(other.object_);
+  }
+
+  bool operator!=(const T* that) {
+    return !(*this == that);
+  }
+
+  bool empty() const {
+    return object_ == 0;
+  }
+};
+
+}
+
+#endif // __COUNTED_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/DecoderResult.cpp

@@ -0,0 +1,51 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  DecoderResult.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 20/05/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/common/DecoderResult.h>
+
+using namespace std;
+using namespace zxing;
+
+DecoderResult::DecoderResult(ArrayRef<char> rawBytes,
+                             Ref<String> text,
+                             ArrayRef< ArrayRef<char> >& byteSegments,
+                             string const& ecLevel, string charSet) :
+  rawBytes_(rawBytes),
+  text_(text),
+  byteSegments_(byteSegments),
+  ecLevel_(ecLevel), charSet_(charSet) {}
+
+DecoderResult::DecoderResult(ArrayRef<char> rawBytes,
+                             Ref<String> text)
+  : rawBytes_(rawBytes), text_(text),charSet_("") {}
+
+ArrayRef<char> DecoderResult::getRawBytes() {
+  return rawBytes_;
+}
+
+Ref<String> DecoderResult::getText() {
+    return text_;
+}
+
+string DecoderResult::charSet()
+{
+    return charSet_;
+}

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/DecoderResult.h

@@ -0,0 +1,54 @@
+#ifndef __DECODER_RESULT_H__
+#define __DECODER_RESULT_H__
+
+/*
+ *  DecoderResult.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/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <string>
+#include <zxing/common/Str.h>
+
+namespace zxing {
+
+class DecoderResult : public Counted {
+private:
+  ArrayRef<char> rawBytes_;
+  Ref<String> text_;
+  ArrayRef< ArrayRef<char> > byteSegments_;
+  std::string ecLevel_;
+  std::string charSet_;
+
+public:
+  DecoderResult(ArrayRef<char> rawBytes,
+                Ref<String> text,
+                ArrayRef< ArrayRef<char> >& byteSegments,
+                std::string const& ecLevel,
+                std::string charSet = "");
+
+  DecoderResult(ArrayRef<char> rawBytes, Ref<String> text);
+
+  ArrayRef<char> getRawBytes();
+  Ref<String> getText();
+  std::string charSet();
+};
+
+}
+
+#endif // __DECODER_RESULT_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/DetectorResult.cpp

@@ -0,0 +1,39 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  DetectorResult.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 14/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/common/DetectorResult.h>
+
+namespace zxing {
+
+DetectorResult::DetectorResult(Ref<BitMatrix> bits,
+                               ArrayRef< Ref<ResultPoint> > points)
+  : bits_(bits), points_(points) {
+}
+
+Ref<BitMatrix> DetectorResult::getBits() {
+  return bits_;
+}
+
+ArrayRef< Ref<ResultPoint> > DetectorResult::getPoints() {
+  return points_;
+}
+
+}

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/DetectorResult.h

@@ -0,0 +1,43 @@
+#ifndef __DETECTOR_RESULT_H__
+#define __DETECTOR_RESULT_H__
+
+/*
+ *  DetectorResult.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/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/ResultPoint.h>
+
+namespace zxing {
+
+class DetectorResult : public Counted {
+private:
+  Ref<BitMatrix> bits_;
+  ArrayRef< Ref<ResultPoint> > points_;
+
+public:
+  DetectorResult(Ref<BitMatrix> bits, ArrayRef< Ref<ResultPoint> > points);
+  Ref<BitMatrix> getBits();
+  ArrayRef< Ref<ResultPoint> > getPoints();
+};
+
+}
+
+#endif // __DETECTOR_RESULT_H__