1 files changed, 64 insertions, 59 deletions

diff --git a/util/scoped.hh b/util/scoped.hh
index ae70b6b53..60c36c36a 100644
--- a/util/scoped.hh
+++ b/util/scoped.hh
@@ -4,6 +4,7 @@
 
 #include "util/exception.hh"
 #include <cstddef>
+#include <cstdlib>
 
 namespace util {
 
@@ -16,87 +17,91 @@ class MallocException : public ErrnoException {
 void *MallocOrThrow(std::size_t requested);
 void *CallocOrThrow(std::size_t requested);
 
-class scoped_malloc {
+/* Unfortunately, defining the operator* for void * makes the compiler complain.
+ * So scoped is specialized to void.  This includes the functionality common to
+ * both, namely everything except reference.
+ */
+template <class T, class Closer> class scoped_base {
   public:
-    scoped_malloc() : p_(NULL) {}
+    explicit scoped_base(T *p = NULL) : p_(p) {}
 
-    scoped_malloc(void *p) : p_(p) {}
+    ~scoped_base() { Closer::Close(p_); }
 
-    ~scoped_malloc();
-
-    void reset(void *p = NULL) {
-      scoped_malloc other(p_);
+    void reset(T *p = NULL) {
+      scoped_base other(p_);
       p_ = p;
     }
 
-    void call_realloc(std::size_t to);
-
-    void *get() { return p_; }
-    const void *get() const { return p_; }
-
-  private:
-    void *p_;
-
-    scoped_malloc(const scoped_malloc &);
-    scoped_malloc &operator=(const scoped_malloc &);
-};
-
-// Hat tip to boost.  
-template <class T> class scoped_array {
-  public:
-    explicit scoped_array(T *content = NULL) : c_(content) {}
-
-    ~scoped_array() { delete [] c_; }
-
-    T *get() { return c_; }
-    const T* get() const { return c_; }
+    T *get() { return p_; }
+    const T *get() const { return p_; }
 
-    T &operator*() { return *c_; }
-    const T&operator*() const { return *c_; }
+    T *operator->() { return p_; }
+    const T *operator->() const { return p_; }
 
-    T &operator[](std::size_t idx) { return c_[idx]; }
-    const T &operator[](std::size_t idx) const { return c_[idx]; }
-
-    void reset(T *to = NULL) {
-      scoped_array<T> other(c_);
-      c_ = to;
+    T *release() {
+      T *ret = p_;
+      p_ = NULL;
+      return ret;
     }
 
-  private:
-    T *c_;
+  protected:
+    T *p_;
 
-    scoped_array(const scoped_array &);
-    void operator=(const scoped_array &);
+  private:
+    scoped_base(const scoped_base &);
+    scoped_base &operator=(const scoped_base &);
 };
 
-template <class T> class scoped_ptr {
+template <class T, class Closer> class scoped : public scoped_base<T, Closer> {
   public:
-    explicit scoped_ptr(T *content = NULL) : c_(content) {}
+    explicit scoped(T *p = NULL) : scoped_base<T, Closer>(p) {}
 
-    ~scoped_ptr() { delete c_; }
+    T &operator*() { return *scoped_base<T, Closer>::p_; }
+    const T&operator*() const { return *scoped_base<T, Closer>::p_; }
+};
 
-    T *get() { return c_; }
-    const T* get() const { return c_; }
+template <class Closer> class scoped<void, Closer> : public scoped_base<void, Closer> {
+  public:
+    explicit scoped(void *p = NULL) : scoped_base<void, Closer>(p) {}
+};
 
-    T &operator*() { return *c_; }
-    const T&operator*() const { return *c_; }
+/* Closer for c functions like std::free and cmph cleanup functions */
+template <class T, void (*clean)(T*)> struct scoped_c_forward {
+  static void Close(T *p) { clean(p); }
+};
+// Call a C function to delete stuff
+template <class T, void (*clean)(T*)> class scoped_c : public scoped<T, scoped_c_forward<T, clean> > {
+  public:
+    explicit scoped_c(T *p = NULL) : scoped<T, scoped_c_forward<T, clean> >(p) {}
+};
 
-    T *operator->() { return c_; }
-    const T*operator->() const { return c_; }
+class scoped_malloc : public scoped_c<void, std::free> {
+  public:
+    explicit scoped_malloc(void *p = NULL) : scoped_c<void, std::free>(p) {}
 
-    T &operator[](std::size_t idx) { return c_[idx]; }
-    const T &operator[](std::size_t idx) const { return c_[idx]; }
+    void call_realloc(std::size_t to);
+};
 
-    void reset(T *to = NULL) {
-      scoped_ptr<T> other(c_);
-      c_ = to;
-    }
+/* scoped_array using delete[] */
+struct scoped_delete_array_forward {
+  template <class T> static void Close(T *p) { delete [] p; }
+};
+// Hat tip to boost.  
+template <class T> class scoped_array : public scoped<T, scoped_delete_array_forward> {
+  public:
+    explicit scoped_array(T *p = NULL) : scoped<T, scoped_delete_array_forward>(p) {}
 
-  private:
-    T *c_;
+    T &operator[](std::size_t idx) { return scoped<T, scoped_delete_array_forward>::p_[idx]; }
+    const T &operator[](std::size_t idx) const { return scoped<T, scoped_delete_array_forward>::p_[idx]; }
+};
 
-    scoped_ptr(const scoped_ptr &);
-    void operator=(const scoped_ptr &);
+/* scoped_ptr using delete.  If only there were a template typedef. */
+struct scoped_delete_forward {
+  template <class T> static void Close(T *p) { delete p; }
+};
+template <class T> class scoped_ptr : public scoped<T, scoped_delete_forward> {
+  public:
+    explicit scoped_ptr(T *p = NULL) : scoped<T, scoped_delete_forward>(p) {}
 };
 
 } // namespace util