From 6ffe0682ab798155129f53b768cb881eac730a1f Mon Sep 17 00:00:00 2001
From: Ben Longbons <b.r.longbons@gmail.com>
Date: Mon, 13 May 2013 22:28:41 -0700
Subject: Add a dumb_ptr template for transition purposes
---
src/common/dumb_ptr.hpp | 127 ++++++++++++++++++++++++++++++++++++++++++++++++
src/common/timer.cpp | 26 +++++-----
src/common/timer.t.hpp | 8 +--
3 files changed, 145 insertions(+), 16 deletions(-)
create mode 100644 src/common/dumb_ptr.hpp
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; }
};
--
cgit v1.2.3-70-g09d2