From 6ffe0682ab798155129f53b768cb881eac730a1f Mon Sep 17 00:00:00 2001 From: Ben Longbons 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 +// +// 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 . + +#include "sanity.hpp" + +// unmanaged new/delete-able pointer +// should be replaced by std::unique_ptr +template +class dumb_ptr +{ + T *impl; +public: + explicit + dumb_ptr(T *p=nullptr) + : impl(p) + {} + + void delete_() + { + delete impl; + forget(); + } + template + void new_(A&&... a) + { + impl = new T(std::forward(a)...); + } + template + static + dumb_ptr make(A&&... a) + { + return dumb_ptr(new T(std::forward(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 or std::vector +template +class dumb_ptr +{ + 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 make(size_t z) + { + return dumb_ptr(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 l, dumb_ptr 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, TimerCompare> timer_heap; +std::priority_queue, std::vector>, 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 td) { timer_heap.push(td); } static -TimerData *top_timer_heap(void) +dumb_ptr top_timer_heap(void) { if (timer_heap.empty()) - return nullptr; + return dumb_ptr(); 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::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 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 # include +# include "dumb_ptr.hpp" + struct TimerData; /// An implementation of the C++ "clock" concept, exposing @@ -30,13 +32,13 @@ typedef std::function timer_func; class Timer { friend struct TimerData; - TimerData *td; + dumb_ptr 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-60-g2f50