1 files changed, 128 insertions, 0 deletions
diff --git a/common/utility/Array.H b/common/utility/Array.H
new file mode 100644
index 0000000..155bad7
--- /dev/null
+++ b/common/utility/Array.H
@@ -0,0 +1,128 @@
+// Copyright 2008, 2009 Brady J. Garvin
+
+// This file is part of Covering Arrays by Simulated Annealing (CASA).
+
+// CASA is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// CASA is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with CASA.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#ifndef ARRAY_H
+#define ARRAY_H
+
+#include <iostream>
+
+template<class T>class Array {
+protected:
+  unsigned				size;
+  T*					array;
+  unsigned*				referenceCount;
+
+  void destroy() {
+    if (referenceCount && !(--*referenceCount)) {
+      delete[] array;
+      delete referenceCount;
+    }
+    array = NULL;
+  }
+
+public:
+  Array() :
+    size(0),
+    array(NULL),
+    referenceCount(NULL) {}
+  Array(unsigned size) :
+    size(size),
+    array(new T[size]),
+    referenceCount(new unsigned(1)) {}
+  Array(const T*raw, unsigned size) :
+    size(size),
+    array(new T[size]),
+    referenceCount(new unsigned(1)) {
+    for (unsigned i = size; i-- > 0;) {
+      array[i] = raw[i];
+    }
+  }
+  Array(const Array&copy) :
+    size(copy.size),
+    array(copy.array),
+    referenceCount(copy.referenceCount) {
+    if (referenceCount) {
+      ++*referenceCount;
+    }
+  }
+
+  Array&operator =(const Array&copy) {
+    destroy();
+    size = copy.size;
+    array = copy.array;
+    referenceCount = copy.referenceCount;
+    ++*referenceCount;
+    return *this;
+  }
+
+  virtual ~Array() {
+    destroy();
+  }
+
+  unsigned getSize() const {
+    return size;
+  }
+
+  operator const T*() const {
+    return array;
+  }
+  operator T*() {
+    return array;
+  }
+
+  void fill(const T&filler) {
+    for (unsigned i = size; i--;) {
+      array[i] = filler;
+    }
+  }
+};
+
+template<class T>std::ostream&operator <<
+  (std::ostream&out, const Array<T>&array) {
+  out << '[';
+  for (unsigned i = 0; i < array.getSize(); ++i) {
+    out << array[i] << ',';
+  }
+  return out << "X]";
+}
+
+template<class T,class COMPARE = std::less<T> >class ArrayComparator {
+public:
+  bool operator()(const Array<T>&left, const Array<T>&right) const {
+    static COMPARE compare;
+    unsigned leftSize = left.getSize();
+    unsigned rightSize = right.getSize();
+    if (leftSize < rightSize) {
+      return true;
+    }
+    if (leftSize > rightSize) {
+      return false;
+    }
+    for (unsigned i = 0; i < leftSize; ++i) {
+      if (compare(left[i], right[i])) {
+	return true;
+      }
+      if (compare(right[i], left[i])) {
+	return false;
+      }
+    }
+    return false;
+  }
+};
+
+#endif