Add a dumb_ptr template for transition purposes

3 files changed, 145 insertions, 16 deletions

diff --git a/src/common/dumb_ptr.hpp b/src/common/dumb_ptr.hpp
new file mode 100644
index 0000000..d0b35f2
--- /dev/null
+++ b/src/common/dumb_ptr.hpp
@@ -0,0 +1,127 @@
+#ifndef TMWA_COMMON_DUMB_PTR_HPP
+#define TMWA_COMMON_DUMB_PTR_HPP
+//    ptr.hpp - temporary new/delete wrappers
+//
+//    Copyright © 2013 Ben Longbons <b.r.longbons@gmail.com>
+//
+//    This file is part of The Mana World (Athena server)
+//
+//    This program 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.
+//
+//    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "sanity.hpp"
+
+// unmanaged new/delete-able pointer
+// should be replaced by std::unique_ptr<T>
+template<class T>
+class dumb_ptr
+{
+    T *impl;
+public:
+    explicit
+    dumb_ptr(T *p=nullptr)
+    : impl(p)
+    {}
+
+    void delete_()
+    {
+        delete impl;
+        forget();
+    }
+    template<class... A>
+    void new_(A&&... a)
+    {
+        impl = new T(std::forward<A>(a)...);
+    }
+    template<class... A>
+    static
+    dumb_ptr<T> make(A&&... a)
+    {
+        return dumb_ptr<T>(new T(std::forward<A>(a)...));
+    }
+    void forget()
+    {
+        impl = nullptr;
+    }
+
+    T& operator *() const
+    {
+        return *impl;
+    }
+    T *operator->() const
+    {
+        return impl;
+    }
+
+    explicit
+    operator bool()
+    {
+        return impl;
+    }
+    bool operator !()
+    {
+        return !impl;
+    }
+};
+
+// unmanaged new/delete-able pointer
+// should be replaced by std::unique_ptr<T[]> or std::vector<T>
+template<class T>
+class dumb_ptr<T[]>
+{
+    T *impl;
+    size_t sz;
+public:
+    dumb_ptr() : impl(), sz() {}
+    dumb_ptr(T *p, size_t z)
+    : impl(p)
+    , sz(z)
+    {}
+
+    void delete_()
+    {
+        delete[] impl;
+        forget();
+    }
+    void new_(size_t z)
+    {
+        impl = new T[z];
+    }
+    static
+    dumb_ptr<T[]> make(size_t z)
+    {
+        return dumb_ptr<T[]>(new T[z], z);
+    }
+    void forget()
+    {
+        impl = nullptr;
+        sz = 0;
+    }
+
+    T& operator[](size_t i) const
+    {
+        return impl[i];
+    }
+
+    explicit
+    operator bool()
+    {
+        return impl;
+    }
+    bool operator !()
+    {
+        return !impl;
+    }
+};
+
+#endif // TMWA_COMMON_DUMB_PTR_HPP
diff --git a/src/common/timer.cpp b/src/common/timer.cpp
index 7b115d9..d2d355b 100644
--- a/src/common/timer.cpp
+++ b/src/common/timer.cpp
@@ -36,7 +36,7 @@ struct TimerData
 struct TimerCompare
 {
     /// implement "less than"
-    bool operator() (TimerData *l, TimerData *r)
+    bool operator() (dumb_ptr<TimerData> l, dumb_ptr<TimerData> r)
     {
         // C++ provides a max-heap, but we want
         // the smallest tick to be the head (a min-heap).
@@ -45,7 +45,7 @@ struct TimerCompare
 };
 
 static
-std::priority_queue<TimerData *, std::vector<TimerData *>, TimerCompare> timer_heap;
+std::priority_queue<dumb_ptr<TimerData>, std::vector<dumb_ptr<TimerData>>, TimerCompare> timer_heap;
 
 
 tick_t gettick_cache;
@@ -75,27 +75,27 @@ void Timer::cancel()
     td->owner = nullptr;
     td->func = do_nothing;
     td->interval = interval_t::zero();
-    td = nullptr;
+    td.forget();
 }
 
 void Timer::detach()
 {
     assert (this == td->owner);
     td->owner = nullptr;
-    td = nullptr;
+    td.forget();
 }
 
 static
-void push_timer_heap(TimerData *td)
+void push_timer_heap(dumb_ptr<TimerData> td)
 {
     timer_heap.push(td);
 }
 
 static
-TimerData *top_timer_heap(void)
+dumb_ptr<TimerData> top_timer_heap(void)
 {
     if (timer_heap.empty())
-        return nullptr;
+        return dumb_ptr<TimerData>();
     return timer_heap.top();
 }
 
@@ -106,7 +106,7 @@ void pop_timer_heap(void)
 }
 
 Timer::Timer(tick_t tick, timer_func func, interval_t interval)
-: td(new TimerData(this, tick, std::move(func), interval))
+: td(dumb_ptr<TimerData>::make(this, tick, std::move(func), interval))
 {
     assert (interval >= interval_t::zero());
 
@@ -116,7 +116,7 @@ Timer::Timer(tick_t tick, timer_func func, interval_t interval)
 Timer::Timer(Timer&& t)
 : td(t.td)
 {
-    t.td = nullptr;
+    t.td.forget();
     if (td)
     {
         assert (td->owner == &t);
@@ -146,7 +146,7 @@ interval_t do_timer(tick_t tick)
     // this says to wait 1 sec if all timers get popped
     interval_t nextmin = std::chrono::seconds(1);
 
-    while (TimerData *td = top_timer_heap())
+    while (dumb_ptr<TimerData> td = top_timer_heap())
     {
         // while the heap is not empty and
         if (td->tick > tick)
@@ -165,13 +165,13 @@ interval_t do_timer(tick_t tick)
         // If we are too far past the requested tick, call with
         // the current tick instead to fix reregistration problems
         if (td->tick + std::chrono::seconds(1) < tick)
-            td->func(td, tick);
+            td->func(td.operator->(), tick);
         else
-            td->func(td, td->tick);
+            td->func(td.operator->(), td->tick);
 
         if (td->interval == interval_t::zero())
         {
-            delete td;
+            td.delete_();
             continue;
         }
         if (td->tick + std::chrono::seconds(1) < tick)
diff --git a/src/common/timer.t.hpp b/src/common/timer.t.hpp
index ee9b5d2..1e3a87a 100644
--- a/src/common/timer.t.hpp
+++ b/src/common/timer.t.hpp
@@ -4,6 +4,8 @@
 # include <chrono>
 # include <functional>
 
+# include "dumb_ptr.hpp"
+
 struct TimerData;
 
 /// An implementation of the C++ "clock" concept, exposing
@@ -30,13 +32,13 @@ typedef std::function<void (TimerData *, tick_t)> timer_func;
 class Timer
 {
     friend struct TimerData;
-    TimerData *td;
+    dumb_ptr<TimerData> td;
 
     Timer(const Timer&) = delete;
     Timer& operator = (const Timer&) = delete;
 public:
     /// Don't own anything yet.
-    Timer() : td(nullptr) {}
+    Timer() = default;
     /// Schedule a timer for the given tick.
     /// If you do not wish to keep track of it, call disconnect().
     /// Otherwise, you may cancel() or replace (operator =) it later.
@@ -58,7 +60,7 @@ public:
     void detach();
 
     /// Check if there is a timer connected.
-    explicit operator bool() { return td; }
+    explicit operator bool() { return bool(td); }
     /// Check if there is no connected timer.
     bool operator !() { return !td; }
 };