From 3ba5b6536e730baf01efb3203be280c3e61319bd Mon Sep 17 00:00:00 2001
From: Determinant <ted.sybil@gmail.com>
Date: Sun, 16 Jun 2019 23:27:05 -0400
Subject: eliminate the use of Free()

---
 event.go | 113 +++++++++++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 89 insertions(+), 24 deletions(-)

(limited to 'event.go')

diff --git a/event.go b/event.go
index 1c8a94e..7ebc643 100644
--- a/event.go
+++ b/event.go
@@ -3,50 +3,115 @@ package salticidae
 // #include "salticidae/event.h"
 // #include <signal.h>
 import "C"
+import "runtime"
 
-type EventContext = *C.struct_eventcontext_t
+type CEventContext = *C.eventcontext_t
+type eventContext struct {
+    inner CEventContext
+    attached map[uintptr]interface{}
+}
+type EventContext = *eventContext
+
+func NewEventContext() EventContext {
+    res := &eventContext{
+        inner: C.eventcontext_new(),
+        attached: make(map[uintptr]interface{}),
+    }
+    runtime.SetFinalizer(res, func(self EventContext) { self.free() })
+    return res
+}
+
+func (self EventContext) attach(ptr rawptr_t, x interface{}) { self.attached[uintptr(ptr)] = x }
+func (self EventContext) detach(ptr rawptr_t) { delete(self.attached, uintptr(ptr)) }
+func (self EventContext) free() { C.eventcontext_free(self.inner) }
+func (self EventContext) Dispatch() { C.eventcontext_dispatch(self.inner) }
+func (self EventContext) Stop() { C.eventcontext_stop(self.inner) }
 
-func NewEventContext() EventContext { return C.eventcontext_new() }
-func (self EventContext) Free() { C.eventcontext_free(self) }
-func (self EventContext) Dispatch() { C.eventcontext_dispatch(self) }
-func (self EventContext) Stop() { C.eventcontext_stop(self) }
+type CThreadCall = *C.threadcall_t
+type threadCall struct { inner CThreadCall }
+type ThreadCall = *threadCall
 
-type ThreadCall = *C.struct_threadcall_t
 type ThreadCallCallback = C.threadcall_callback_t
 
-func NewThreadCall(ec EventContext) ThreadCall { return C.threadcall_new(ec) }
+func NewThreadCall(ec EventContext) ThreadCall {
+    res := &threadCall{ inner: C.threadcall_new(ec.inner) }
+    runtime.SetFinalizer(res, func(self ThreadCall) { self.free() })
+    return res
+}
 
-func (self ThreadCall) Free() { C.threadcall_free(self) }
+func (self ThreadCall) free() { C.threadcall_free(self.inner) }
 
 func (self ThreadCall) AsyncCall(callback ThreadCallCallback, userdata rawptr_t) {
-    C.threadcall_async_call(self, callback, userdata)
+    C.threadcall_async_call(self.inner, callback, userdata)
 }
 
-func (self ThreadCall) GetEC() EventContext { return C.threadcall_get_ec(self) }
+type CTimerEvent = *C.timerev_t
+type timerEvent struct {
+    inner CTimerEvent
+    ec EventContext
+}
+type TimerEvent = *timerEvent
 
-type TimerEvent = *C.timerev_t
 type TimerEventCallback = C.timerev_callback_t
 
-func NewTimerEvent(ec EventContext, cb TimerEventCallback, userdata rawptr_t) TimerEvent {
-    return C.timerev_new(ec, cb, userdata)
+func NewTimerEvent(_ec EventContext, cb TimerEventCallback, userdata rawptr_t) TimerEvent {
+    res := &timerEvent{
+        inner: C.timerev_new(_ec.inner, cb, userdata),
+        ec: _ec,
+    }
+    _ec.attach(rawptr_t(res.inner), res)
+    runtime.SetFinalizer(res, func(self TimerEvent) { self.free() })
+    return res
 }
 
-func (self TimerEvent) Free() { C.timerev_free(self) }
+func (self TimerEvent) free() { C.timerev_free(self.inner) }
 func (self TimerEvent) SetCallback(callback TimerEventCallback, userdata rawptr_t) {
-    C.timerev_set_callback(self, callback, userdata)
+    C.timerev_set_callback(self.inner, callback, userdata)
 }
 
-func (self TimerEvent) Add(t_sec float64) { C.timerev_add(self, C.double(t_sec)) }
-func (self TimerEvent) Clear() { C.timerev_clear(self) }
+func (self TimerEvent) Add(t_sec float64) { C.timerev_add(self.inner, C.double(t_sec)) }
+func (self TimerEvent) Del() {
+    self.ec.detach(rawptr_t(self.inner))
+    C.timerev_del(self.inner)
+}
+
+func (self TimerEvent) Clear() {
+    self.ec.detach(rawptr_t(self.inner))
+    C.timerev_clear(self.inner)
+}
+
+type CSigEvent = *C.sigev_t
+type sigEvent struct {
+    inner CSigEvent
+    ec EventContext
+}
+type SigEvent = *sigEvent
 
-type SigEvent = *C.sigev_t
 type SigEventCallback = C.sigev_callback_t
-var SIGTERM = C.SIGTERM
-var SIGINT = C.SIGINT
 
-func NewSigEvent(ec EventContext, cb SigEventCallback, userdata rawptr_t) SigEvent {
-    return C.sigev_new(ec, cb, userdata)
+var (
+    SIGTERM = C.SIGTERM
+    SIGINT = C.SIGINT
+)
+
+func NewSigEvent(_ec EventContext, cb SigEventCallback, userdata rawptr_t) SigEvent {
+    res := &sigEvent{
+        inner: C.sigev_new(_ec.inner, cb, userdata),
+        ec: _ec,
+    }
+    _ec.attach(rawptr_t(res.inner), res)
+    runtime.SetFinalizer(res, func(self SigEvent) { self.free() })
+    return res
 }
 
-func (self SigEvent) Add(sig int) { C.sigev_add(self, C.int(sig)) }
-func (self SigEvent) Free() { C.sigev_free(self) }
+func (self SigEvent) free() { C.sigev_free(self.inner) }
+func (self SigEvent) Add(sig int) { C.sigev_add(self.inner, C.int(sig)) }
+func (self SigEvent) Del() {
+    self.ec.detach(rawptr_t(self.inner))
+    C.sigev_del(self.inner)
+}
+
+func (self SigEvent) Clear() {
+    self.ec.detach(rawptr_t(self.inner))
+    C.sigev_clear(self.inner)
+}
-- 
cgit v1.2.3