-#ifndef __ARRAY_H__
-#define __ARRAY_H__
-
-/*
- * Array.h
- * zxing
- *
- * Created by Christian Brunschen on 07/05/2008.
- * Copyright 2008 Google UK. 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 <valarray>
-#include <cstdarg>
-
-#ifdef DEBUG_COUNTING
-#include <iostream>
-#include <typeinfo>
-#endif
-
-#include "Counted.h"
-
-
-namespace zxing {
-
-template<typename T> class Array : public Counted {
-protected:
-public:
- std::valarray<T> values_;
- Array(size_t n) :
- Counted(), values_(T(), n) {
- }
- Array(T *ts, size_t n) :
- Counted(), values_(ts, n) {
- }
- Array(T v, size_t n) :
- Counted(), values_(v, n) {
- }
- Array(std::valarray<T> &v) :
- Counted(), values_(v) {
- }
- Array(Array<T> &other) :
- Counted(), values_(other.values_) {
- }
- Array(Array<T> *other) :
- Counted(), values_(other->values_) {
- }
- virtual ~Array() {
- }
- Array<T>& operator=(const Array<T> &other) {
-#ifdef DEBUG_COUNTING
- cout << "assigning values from Array " << &other << " to this Array " << this << ", ";
-#endif
- values_ = other.values_;
-#ifdef DEBUG_COUNTING
- cout << "new size = " << values_.size() << "\n";
-#endif
- return *this;
- }
- Array<T>& operator=(const std::valarray<T> &array) {
-#ifdef DEBUG_COUNTING
- cout << "assigning values from Array " << &array << " to this Array " << this << ", ";
-#endif
- values_ = array;
-#ifdef DEBUG_COUNTING
- cout << "new size = " << values_.size() << "\n";
-#endif
- return *this;
- }
- T operator[](size_t i) const {
- return values_[i];
- }
- T& operator[](size_t i) {
- return values_[i];
- }
- size_t size() const {
- return values_.size();
- }
- std::valarray<T> values() const {
- return values_;
- }
- std::valarray<T>& values() {
- return values_;
- }
-};
-
-template<typename T> class ArrayRef {
-private:
-public:
- Array<T> *array_;
- ArrayRef() :
- array_(0) {
-#ifdef DEBUG_COUNTING
- cout << "instantiating empty ArrayRef " << this << "\n";
-#endif
- }
- ArrayRef(size_t n) :
- array_(0) {
-#ifdef DEBUG_COUNTING
- cout << "instantiating ArrayRef " << this << "with size " << n << "\n";
-#endif
- reset(new Array<T> (n));
- }
- ArrayRef(T *ts, size_t n) :
- array_(0) {
-#ifdef DEBUG_COUNTING
- cout << "instantiating ArrayRef " << this << "with " << n << " elements at " << (void *)ts << "\n";
-#endif
- reset(new Array<T> (ts, n));
- }
- ArrayRef(Array<T> *a) :
- array_(0) {
-#ifdef DEBUG_COUNTING
- cout << "instantiating ArrayRef " << this << " from pointer:\n";
-#endif
- reset(a);
- }
- ArrayRef(const Array<T> &a) :
- array_(0) {
-#ifdef DEBUG_COUNTING
- cout << "instantiating ArrayRef " << this << " from reference to Array " << (void *)&a << ":\n";
-#endif
- reset(const_cast<Array<T> *>(&a));
- }
- ArrayRef(const ArrayRef &other) :
- array_(0) {
-#ifdef DEBUG_COUNTING
- cout << "instantiating ArrayRef " << this << " from ArrayRef " << &other << ":\n";
-#endif
- reset(other.array_);
- }
-
- template<class Y>
- ArrayRef(const ArrayRef<Y> &other) :
- array_(0) {
-#ifdef DEBUG_COUNTING
- cout << "instantiating ArrayRef " << this << " from ArrayRef " << &other << ":\n";
-#endif
- reset(static_cast<const Array<T> *>(other.array_));
- }
-
- ~ArrayRef() {
-#ifdef DEBUG_COUNTING
- cout << "destroying ArrayRef " << this << " with " << (array_ ? typeid(*array_).name() : "NULL") << " "
- << array_ << "\n";
-#endif
- if (array_) {
- array_->release();
- }
- array_ = 0;
- }
-
- T operator[](size_t i) const {
- return (*array_)[i];
- }
- T& operator[](size_t i) {
- return (*array_)[i];
- }
- size_t size() const {
- return array_->size();
- }
-
- void reset(Array<T> *a) {
-#ifdef DEBUG_COUNTING
- cout << "resetting ArrayRef " << this << " from " << (array_ ? typeid(*array_).name() : "NULL") << " "
- << array_ << " to " << (a ? typeid(*a).name() : "NULL") << " " << a << "\n";
-#endif
- if (a) {
- a->retain();
- }
- if (array_) {
- array_->release();
- }
- array_ = a;
- }
- void reset(const ArrayRef<T> &other) {
- reset(other.array_);
- }
- ArrayRef<T>& operator=(const ArrayRef<T> &other) {
- reset(other);
- return *this;
- }
- ArrayRef<T>& operator=(Array<T> *a) {
- reset(a);
- return *this;
- }
-
- Array<T>& operator*() {
- return *array_;
- }
- Array<T>* operator->() {
- return array_;
- }
-};
-
-} // namespace zxing
-
-#endif // __ARRAY_H__
+#ifndef __ARRAY_H__\r
+#define __ARRAY_H__\r
+\r
+/*\r
+ * Array.h\r
+ * zxing\r
+ *\r
+ * Created by Christian Brunschen on 07/05/2008.\r
+ * Copyright 2008 Google UK. All rights reserved.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+#include <valarray>\r
+#include <cstdarg>\r
+\r
+#ifdef DEBUG_COUNTING\r
+#include <iostream>\r
+#include <typeinfo>\r
+#endif\r
+\r
+#include <zxing/common/Counted.h>\r
+\r
+\r
+namespace zxing {\r
+\r
+template<typename T> class Array : public Counted {\r
+protected:\r
+public:\r
+ std::valarray<T> values_;\r
+ Array(size_t n) :\r
+ Counted(), values_(T(), n) {\r
+ }\r
+ Array(T *ts, size_t n) :\r
+ Counted(), values_(ts, n) {\r
+ }\r
+ Array(T v, size_t n) :\r
+ Counted(), values_(v, n) {\r
+ }\r
+ Array(std::valarray<T> &v) :\r
+ Counted(), values_(v) {\r
+ }\r
+ Array(Array<T> &other) :\r
+ Counted(), values_(other.values_) {\r
+ }\r
+ Array(Array<T> *other) :\r
+ Counted(), values_(other->values_) {\r
+ }\r
+ virtual ~Array() {\r
+ }\r
+ Array<T>& operator=(const Array<T> &other) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "assigning values from Array " << &other << " to this Array " << this << ", ";\r
+#endif\r
+ values_ = other.values_;\r
+#ifdef DEBUG_COUNTING\r
+ cout << "new size = " << values_.size() << "\n";\r
+#endif\r
+ return *this;\r
+ }\r
+ Array<T>& operator=(const std::valarray<T> &array) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "assigning values from Array " << &array << " to this Array " << this << ", ";\r
+#endif\r
+ values_ = array;\r
+#ifdef DEBUG_COUNTING\r
+ cout << "new size = " << values_.size() << "\n";\r
+#endif\r
+ return *this;\r
+ }\r
+ T operator[](size_t i) const {\r
+ return values_[i];\r
+ }\r
+ T& operator[](size_t i) {\r
+ return values_[i];\r
+ }\r
+ size_t size() const {\r
+ return values_.size();\r
+ }\r
+ std::valarray<T> values() const {\r
+ return values_;\r
+ }\r
+ std::valarray<T>& values() {\r
+ return values_;\r
+ }\r
+};\r
+\r
+template<typename T> class ArrayRef {\r
+private:\r
+public:\r
+ Array<T> *array_;\r
+ ArrayRef() :\r
+ array_(0) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "instantiating empty ArrayRef " << this << "\n";\r
+#endif\r
+ }\r
+ ArrayRef(size_t n) :\r
+ array_(0) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "instantiating ArrayRef " << this << "with size " << n << "\n";\r
+#endif\r
+ reset(new Array<T> (n));\r
+ }\r
+ ArrayRef(T *ts, size_t n) :\r
+ array_(0) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "instantiating ArrayRef " << this << "with " << n << " elements at " << (void *)ts << "\n";\r
+#endif\r
+ reset(new Array<T> (ts, n));\r
+ }\r
+ ArrayRef(Array<T> *a) :\r
+ array_(0) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "instantiating ArrayRef " << this << " from pointer:\n";\r
+#endif\r
+ reset(a);\r
+ }\r
+ ArrayRef(const Array<T> &a) :\r
+ array_(0) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "instantiating ArrayRef " << this << " from reference to Array " << (void *)&a << ":\n";\r
+#endif\r
+ reset(const_cast<Array<T> *>(&a));\r
+ }\r
+ ArrayRef(const ArrayRef &other) :\r
+ array_(0) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "instantiating ArrayRef " << this << " from ArrayRef " << &other << ":\n";\r
+#endif\r
+ reset(other.array_);\r
+ }\r
+\r
+ template<class Y>\r
+ ArrayRef(const ArrayRef<Y> &other) :\r
+ array_(0) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "instantiating ArrayRef " << this << " from ArrayRef " << &other << ":\n";\r
+#endif\r
+ reset(static_cast<const Array<T> *>(other.array_));\r
+ }\r
+\r
+ ~ArrayRef() {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "destroying ArrayRef " << this << " with " << (array_ ? typeid(*array_).name() : "NULL") << " "\r
+ << array_ << "\n";\r
+#endif\r
+ if (array_) {\r
+ array_->release();\r
+ }\r
+ array_ = 0;\r
+ }\r
+\r
+ T operator[](size_t i) const {\r
+ return (*array_)[i];\r
+ }\r
+ T& operator[](size_t i) {\r
+ return (*array_)[i];\r
+ }\r
+ size_t size() const {\r
+ return array_->size();\r
+ }\r
+\r
+ void reset(Array<T> *a) {\r
+#ifdef DEBUG_COUNTING\r
+ cout << "resetting ArrayRef " << this << " from " << (array_ ? typeid(*array_).name() : "NULL") << " "\r
+ << array_ << " to " << (a ? typeid(*a).name() : "NULL") << " " << a << "\n";\r
+#endif\r
+ if (a) {\r
+ a->retain();\r
+ }\r
+ if (array_) {\r
+ array_->release();\r
+ }\r
+ array_ = a;\r
+ }\r
+ void reset(const ArrayRef<T> &other) {\r
+ reset(other.array_);\r
+ }\r
+ ArrayRef<T>& operator=(const ArrayRef<T> &other) {\r
+ reset(other);\r
+ return *this;\r
+ }\r
+ ArrayRef<T>& operator=(Array<T> *a) {\r
+ reset(a);\r
+ return *this;\r
+ }\r
+\r
+ Array<T>& operator*() {\r
+ return *array_;\r
+ }\r
+ Array<T>* operator->() {\r
+ return array_;\r
+ }\r
+};\r
+\r
+} // namespace zxing\r
+\r
+#endif // __ARRAY_H__\r
projects / zxing.git / blobdiff