1 files changed, 110 insertions, 0 deletions
diff --git a/common/utility/Lazy.H b/common/utility/Lazy.H
new file mode 100644
index 0000000..84bf426
--- /dev/null
+++ b/common/utility/Lazy.H
@@ -0,0 +1,110 @@
+// 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 LAZY_H
+#define LAZY_H
+
+#include <cassert>
+#include <iostream>
+
+template<class T>class Lazy {
+protected:
+  T*					implementation;
+  unsigned*				referenceCount;
+
+  void destroy() {
+    if (referenceCount) {
+      assert(implementation);
+      if (!(--*referenceCount)) {
+	delete implementation;
+	delete referenceCount;
+      }
+      implementation = NULL;
+    } else {
+      assert(!implementation);
+    }
+  }
+
+public:
+  Lazy() :
+    implementation(NULL),
+    referenceCount(NULL) {}
+  Lazy(T*implementation) :
+    implementation(implementation),
+    referenceCount(implementation ? new unsigned(1) : NULL) {}
+  Lazy(const Lazy&copy) :
+    implementation(copy.implementation),
+    referenceCount(copy.referenceCount) {
+    if (implementation) {
+      assert(referenceCount);
+      ++*referenceCount;
+    } else {
+      assert(!referenceCount);
+    }
+  }
+
+  Lazy&operator =(T*implementation) {
+    destroy();
+    this->implementation = implementation;
+    this->referenceCount = implementation ? new unsigned(1) : NULL;
+    return *this;
+  }
+  Lazy&operator =(const Lazy&copy) {
+    destroy();
+    implementation = copy.implementation;
+    if (implementation) {
+      referenceCount = copy.referenceCount;
+      assert(referenceCount);
+      ++*referenceCount;
+    } else {
+      assert(!copy.referenceCount);
+      referenceCount = NULL;
+    }
+    return *this;
+  }
+
+  virtual ~Lazy(){
+    destroy();
+  }
+
+  const T*operator ->() const {
+    return implementation;
+  }
+  T*operator ->() {
+    if (referenceCount) {
+      assert(implementation);
+      if (*referenceCount > 1) {
+	T*copy = new T(*implementation);
+	destroy();
+	implementation = copy;
+	referenceCount = new unsigned(1);
+      }
+    } else {
+      assert(!implementation);
+    }
+    return implementation;
+  }
+  operator const T*() const {
+    return operator ->();
+  }
+  operator T*() {
+    return operator ->();
+  }
+};
+
+#endif