|
|
@@ -0,0 +1,1423 @@
|
|
|
+// Written in the D programming language.
|
|
|
+
|
|
|
+/**
|
|
|
+* Signals and Slots are an implementation of the $(LINK2 http://en.wikipedia.org/wiki/Observer_pattern, Observer pattern)$(BR)
|
|
|
+* Essentially, when a Signal is emitted, a list of connected Observers
|
|
|
+* (called slots) are called.
|
|
|
+*
|
|
|
+* This implementation supersedes the former std.signals.
|
|
|
+*
|
|
|
+* Copyright: Copyright Robert Klotzner 2012 - 2013.
|
|
|
+* License: <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>.
|
|
|
+* Authors: Robert Klotzner
|
|
|
+*/
|
|
|
+/* Copyright Robert Klotzner 2012 - 2013.
|
|
|
+* Distributed under the Boost Software License, Version 1.0.
|
|
|
+* (See accompanying file LICENSE_1_0.txt or copy at
|
|
|
+* http://www.boost.org/LICENSE_1_0.txt)
|
|
|
+*
|
|
|
+* Based on the original implementation written by Walter Bright. (std.signals)
|
|
|
+* I shamelessly stole some ideas of: http://forum.dlang.org/thread/jjote0$1cql$1@digitalmars.com
|
|
|
+* written by Alex Rønne Petersen.
|
|
|
+*
|
|
|
+* Also thanks to Denis Shelomovskij who made me aware of some
|
|
|
+* deficiencies in the concurrent part of WeakRef.
|
|
|
+*/
|
|
|
+module stdx.signals;
|
|
|
+
|
|
|
+import core.atomic;
|
|
|
+import core.memory;
|
|
|
+
|
|
|
+
|
|
|
+// Hook into the GC to get informed about object deletions.
|
|
|
+private alias void delegate(Object) DisposeEvt;
|
|
|
+private extern (C) void rt_attachDisposeEvent( Object obj, DisposeEvt evt );
|
|
|
+private extern (C) void rt_detachDisposeEvent( Object obj, DisposeEvt evt );
|
|
|
+
|
|
|
+/**
|
|
|
+* string mixin for creating a signal.
|
|
|
+*
|
|
|
+* It creates a Signal instance named "_name", where name is given
|
|
|
+* as first parameter with given protection and an accessor method
|
|
|
+* with the current context protection named "name" returning either a
|
|
|
+* ref RestrictedSignal or ref Signal depending on the given
|
|
|
+* protection.
|
|
|
+*
|
|
|
+* Bugs:
|
|
|
+* This mixin generator does not work with templated types right now because of:
|
|
|
+* $(LINK2 http://d.puremagic.com/issues/show_bug.cgi?id=10502, 10502)$(BR)
|
|
|
+* You might want to use the Signal struct directly in this
|
|
|
+* case. Ideally you write the code, the mixin would generate, manually
|
|
|
+* to ensure an easy upgrade path when the above bug gets fixed:
|
|
|
+---
|
|
|
+* ref RestrictedSignal!(SomeTemplate!int) mysig() { return _mysig;}
|
|
|
+* private Signal!(SomeTemplate!int) _mysig;
|
|
|
+---
|
|
|
+*
|
|
|
+* Params:
|
|
|
+* name = How the signal should be named. The ref returning function
|
|
|
+* will be named like this, the actual struct instance will have an
|
|
|
+* underscore prefixed.
|
|
|
+*
|
|
|
+* protection = Specifies how the full functionality (emit) of the
|
|
|
+* signal should be protected. Default is private. If
|
|
|
+* Protection.none is given, private is used for the Signal member
|
|
|
+* variable and the ref returning accessor method will return a
|
|
|
+* Signal instead of a RestrictedSignal. The protection of the
|
|
|
+* accessor method is specified by the surrounding protection scope:
|
|
|
+---
|
|
|
+* public: // Everyone can access mysig now:
|
|
|
+* // Result of mixin(signal!int("mysig", Protection.none))
|
|
|
+* ref Signal!int mysig() { return _mysig;}
|
|
|
+* private Signal!int _mysig;
|
|
|
+---
|
|
|
+*
|
|
|
+* Example:
|
|
|
+---
|
|
|
+import std.stdio;
|
|
|
+class MyObject
|
|
|
+{
|
|
|
+// Mixin signal named valueChanged, with default "private" protection.
|
|
|
+// (Only MyObject is allowed to emit the signal)
|
|
|
+mixin(signal!(string, int)("valueChanged"));
|
|
|
+
|
|
|
+int value() @property { return _value; }
|
|
|
+int value(int v) @property
|
|
|
+{
|
|
|
+if (v != _value)
|
|
|
+{
|
|
|
+_value = v;
|
|
|
+// call all the connected slots with the two parameters
|
|
|
+_valueChanged.emit("setting new value", v);
|
|
|
+}
|
|
|
+return v;
|
|
|
+}
|
|
|
+private:
|
|
|
+int _value;
|
|
|
+}
|
|
|
+
|
|
|
+class Observer
|
|
|
+{ // our slot
|
|
|
+void watch(string msg, int i)
|
|
|
+{
|
|
|
+writefln("Observed msg '%s' and value %s", msg, i);
|
|
|
+}
|
|
|
+}
|
|
|
+void watch(string msg, int i)
|
|
|
+{
|
|
|
+writefln("Globally observed msg '%s' and value %s", msg, i);
|
|
|
+}
|
|
|
+void main()
|
|
|
+{
|
|
|
+auto a = new MyObject;
|
|
|
+Observer o = new Observer;
|
|
|
+
|
|
|
+a.value = 3; // should not call o.watch()
|
|
|
+a.valueChanged.connect!"watch"(o); // o.watch is the slot
|
|
|
+a.value = 4; // should call o.watch()
|
|
|
+a.valueChanged.disconnect!"watch"(o); // o.watch is no longer a slot
|
|
|
+a.value = 5; // so should not call o.watch()
|
|
|
+a.valueChanged.connect!"watch"(o); // connect again
|
|
|
+// Do some fancy stuff:
|
|
|
+a.valueChanged.connect!Observer(o, (obj, msg, i) => obj.watch("Some other text I made up", i+1));
|
|
|
+a.valueChanged.strongConnect(&watch);
|
|
|
+a.value = 6; // should call o.watch()
|
|
|
+destroy(o); // destroying o should automatically disconnect it
|
|
|
+a.value = 7; // should not call o.watch()
|
|
|
+
|
|
|
+}
|
|
|
+---
|
|
|
+* which should print:
|
|
|
+* <pre>
|
|
|
+* Observed msg 'setting new value' and value 4
|
|
|
+* Observed msg 'setting new value' and value 6
|
|
|
+* Observed msg 'Some other text I made up' and value 7
|
|
|
+* Globally observed msg 'setting new value' and value 6
|
|
|
+* Globally observed msg 'setting new value' and value 7
|
|
|
+* </pre>
|
|
|
+*/
|
|
|
+string signal(Args...)(string name, Protection protection=Protection.private_) @trusted // trusted necessary because of to!string
|
|
|
+{
|
|
|
+ import std.conv;
|
|
|
+ string argList="(";
|
|
|
+ import std.traits : fullyQualifiedName;
|
|
|
+ foreach (arg; Args)
|
|
|
+ {
|
|
|
+ argList~=fullyQualifiedName!(arg)~", ";
|
|
|
+ }
|
|
|
+ if (argList.length>"(".length)
|
|
|
+ argList = argList[0 .. $-2];
|
|
|
+ argList ~= ")";
|
|
|
+
|
|
|
+ string output = (protection == Protection.none ? "private" : to!string(protection)[0..$-1]) ~
|
|
|
+ " Signal!" ~ argList ~ " _" ~ name ~ ";\n";
|
|
|
+ string rType = protection == Protection.none ? "Signal!" : "RestrictedSignal!";
|
|
|
+ output ~= "ref " ~ rType ~ argList ~ " " ~ name ~ "() { return _" ~ name ~ ";}\n";
|
|
|
+ return output;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+* Protection to use for the signal string mixin.
|
|
|
+*/
|
|
|
+enum Protection
|
|
|
+{
|
|
|
+ none, /// No protection at all, the wrapping function will return a ref Signal instead of a ref RestrictedSignal
|
|
|
+ private_, /// The Signal member variable will be private.
|
|
|
+ protected_, /// The signal member variable will be protected.
|
|
|
+ package_ /// The signal member variable will have package protection.
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+* Full signal implementation.
|
|
|
+*
|
|
|
+* It implements the emit function for all other functionality it has
|
|
|
+* this aliased to RestrictedSignal.
|
|
|
+*
|
|
|
+* A signal is a way to couple components together in a very loose
|
|
|
+* way. The receiver does not need to know anything about the sender
|
|
|
+* and the sender does not need to know anything about the
|
|
|
+* receivers. The sender will just call emit when something happens,
|
|
|
+* the signal takes care of notifing all interested parties. By using
|
|
|
+* wrapper delegates/functions, not even the function signature of
|
|
|
+* sender/receiver need to match.
|
|
|
+*
|
|
|
+* Another consequence of this very loose coupling is, that a
|
|
|
+* connected object will be freed by the GC if all references to it
|
|
|
+* are dropped, even if it was still connected to a signal, the
|
|
|
+* connection will simply be dropped. This way the developer is freed of
|
|
|
+* manually keeping track of connections.
|
|
|
+*
|
|
|
+* If in your application the connections made by a signal are not
|
|
|
+* that loose you can use strongConnect(), in this case the GC won't
|
|
|
+* free your object until it was disconnected from the signal or the
|
|
|
+* signal got itself destroyed.
|
|
|
+*
|
|
|
+* This struct is not thread-safe in general, it just handles the
|
|
|
+* concurrent parts of the GC.
|
|
|
+*
|
|
|
+* Bugs: The code probably won't compile with -profile because of bug:
|
|
|
+* $(LINK2 http://d.puremagic.com/issues/show_bug.cgi?id=10260, 10260)
|
|
|
+*/
|
|
|
+struct Signal(Args...)
|
|
|
+{
|
|
|
+ alias restricted this;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Emit the signal.
|
|
|
+ *
|
|
|
+ * All connected slots which are still alive will be called. If
|
|
|
+ * any of the slots throws an exception, the other slots will
|
|
|
+ * still be called. You'll receive a chained exception with all
|
|
|
+ * exceptions that were thrown. Thus slots won't influence each
|
|
|
+ * others execution.
|
|
|
+ *
|
|
|
+ * The slots are called in the same sequence as they were registered.
|
|
|
+ *
|
|
|
+ * emit also takes care of actually removing dead connections. For
|
|
|
+ * concurrency reasons they are set just to an invalid state by the GC.
|
|
|
+ *
|
|
|
+ * If you remove a slot during emit() it won't be called in the
|
|
|
+ * current run if it wasn't already.
|
|
|
+ *
|
|
|
+ * If you add a slot during emit() it will be called in the
|
|
|
+ * current emit() run. Note however Signal is not thread-safe, "called
|
|
|
+ * during emit" basically means called from within a slot.
|
|
|
+ */
|
|
|
+ void emit( Args args ) @trusted
|
|
|
+ {
|
|
|
+ _restricted._impl.emit(args);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Get access to the rest of the signals functionality.
|
|
|
+ */
|
|
|
+ ref RestrictedSignal!(Args) restricted() @property @trusted
|
|
|
+ {
|
|
|
+ return _restricted;
|
|
|
+ }
|
|
|
+
|
|
|
+private:
|
|
|
+ RestrictedSignal!(Args) _restricted;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+* The signal implementation, not providing an emit method.
|
|
|
+*
|
|
|
+* The idea is to instantiate a Signal privately and provide a
|
|
|
+* public accessor method for accessing the contained
|
|
|
+* RestrictedSignal. You can use the signal string mixin, which does
|
|
|
+* exactly that.
|
|
|
+*/
|
|
|
+struct RestrictedSignal(Args...)
|
|
|
+{
|
|
|
+ /**
|
|
|
+ * Direct connection to an object.
|
|
|
+ *
|
|
|
+ * Use this method if you want to connect directly to an object's
|
|
|
+ * method matching the signature of this signal. The connection
|
|
|
+ * will have weak reference semantics, meaning if you drop all
|
|
|
+ * references to the object the garbage collector will collect it
|
|
|
+ * and this connection will be removed.
|
|
|
+ *
|
|
|
+ * Preconditions: obj must not be null. mixin("&obj."~method)
|
|
|
+ * must be valid and compatible.
|
|
|
+ * Params:
|
|
|
+ * obj = Some object of a class implementing a method
|
|
|
+ * compatible with this signal.
|
|
|
+ */
|
|
|
+ void connect(string method, ClassType)(ClassType obj) @trusted
|
|
|
+ if (is(ClassType == class) && __traits(compiles, {void delegate(Args) dg = mixin("&obj."~method);}))
|
|
|
+ in
|
|
|
+ {
|
|
|
+ assert(obj);
|
|
|
+ }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ _impl.addSlot(obj, cast(void delegate())mixin("&obj."~method));
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Indirect connection to an object.
|
|
|
+ *
|
|
|
+ * Use this overload if you want to connect to an objects method
|
|
|
+ * which does not match the signal's signature. You can provide
|
|
|
+ * any delegate to do the parameter adaption, but make sure your
|
|
|
+ * delegates' context does not contain a reference to the target
|
|
|
+ * object, instead use the provided obj parameter, where the
|
|
|
+ * object passed to connect will be passed to your delegate.
|
|
|
+ * This is to make weak ref semantics possible, if your delegate
|
|
|
+ * contains a ref to obj, the object won't be freed as long as
|
|
|
+ * the connection remains.
|
|
|
+ *
|
|
|
+ * Preconditions: obj and dg must not be null (dgs context
|
|
|
+ * may). dg's context must not be equal to obj.
|
|
|
+ *
|
|
|
+ * Params:
|
|
|
+ * obj = The object to connect to. It will be passed to the
|
|
|
+ * delegate when the signal is emitted.
|
|
|
+ *
|
|
|
+ * dg = A wrapper delegate which takes care of calling some
|
|
|
+ * method of obj. It can do any kind of parameter adjustments
|
|
|
+ * necessary.
|
|
|
+ */
|
|
|
+ void connect(ClassType)(ClassType obj, void delegate(ClassType obj, Args) dg) @trusted
|
|
|
+ if (is(ClassType == class))
|
|
|
+ in
|
|
|
+ {
|
|
|
+ assert(obj);
|
|
|
+ assert(dg);
|
|
|
+ assert(cast(void*)obj !is dg.ptr);
|
|
|
+ }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ _impl.addSlot(obj, cast(void delegate()) dg);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Connect with strong ref semantics.
|
|
|
+ *
|
|
|
+ * Use this overload if you either really, really want strong ref
|
|
|
+ * semantics for some reason or because you want to connect some
|
|
|
+ * non-class method delegate. Whatever the delegates' context
|
|
|
+ * references, will stay in memory as long as the signals
|
|
|
+ * connection is not removed and the signal gets not destroyed
|
|
|
+ * itself.
|
|
|
+ *
|
|
|
+ * Preconditions: dg must not be null. (Its context may.)
|
|
|
+ *
|
|
|
+ * Params:
|
|
|
+ * dg = The delegate to be connected.
|
|
|
+ */
|
|
|
+ void strongConnect(void delegate(Args) dg) @trusted
|
|
|
+ in
|
|
|
+ {
|
|
|
+ assert(dg);
|
|
|
+ }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ _impl.addSlot(null, cast(void delegate()) dg);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Disconnect a direct connection.
|
|
|
+ *
|
|
|
+ * After issuing this call, methods of obj won't be triggered any
|
|
|
+ * longer when emit is called.
|
|
|
+ * Preconditions: Same as for direct connect.
|
|
|
+ */
|
|
|
+ void disconnect(string method, ClassType)(ClassType obj) @trusted
|
|
|
+ if (is(ClassType == class) && __traits(compiles, {void delegate(Args) dg = mixin("&obj."~method);}))
|
|
|
+ in
|
|
|
+ {
|
|
|
+ assert(obj);
|
|
|
+ }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ void delegate(Args) dg = mixin("&obj."~method);
|
|
|
+ _impl.removeSlot(obj, cast(void delegate()) dg);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Disconnect an indirect connection.
|
|
|
+ *
|
|
|
+ * For this to work properly, dg has to be exactly the same as
|
|
|
+ * the one passed to connect. So if you used a lamda you have to
|
|
|
+ * keep a reference to it somewhere if you want to disconnect
|
|
|
+ * the connection later on. If you want to remove all
|
|
|
+ * connections to a particular object use the overload which only
|
|
|
+ * takes an object paramter.
|
|
|
+ */
|
|
|
+ void disconnect(ClassType)(ClassType obj, void delegate(ClassType, T1) dg) @trusted
|
|
|
+ if (is(ClassType == class))
|
|
|
+ in
|
|
|
+ {
|
|
|
+ assert(obj);
|
|
|
+ assert(dg);
|
|
|
+ }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ _impl.removeSlot(obj, cast(void delegate())dg);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Disconnect all connections to obj.
|
|
|
+ *
|
|
|
+ * All connections to obj made with calls to connect are removed.
|
|
|
+ */
|
|
|
+ void disconnect(ClassType)(ClassType obj) @trusted if (is(ClassType == class))
|
|
|
+ in
|
|
|
+ {
|
|
|
+ assert(obj);
|
|
|
+ }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ _impl.removeSlot(obj);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Disconnect a connection made with strongConnect.
|
|
|
+ *
|
|
|
+ * Disconnects all connections to dg.
|
|
|
+ */
|
|
|
+ void strongDisconnect(void delegate(Args) dg) @trusted
|
|
|
+ in
|
|
|
+ {
|
|
|
+ assert(dg);
|
|
|
+ }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ _impl.removeSlot(null, cast(void delegate()) dg);
|
|
|
+ }
|
|
|
+private:
|
|
|
+ SignalImpl _impl;
|
|
|
+}
|
|
|
+
|
|
|
+private struct SignalImpl
|
|
|
+{
|
|
|
+ /**
|
|
|
+ * Forbid copying.
|
|
|
+ * Unlike the old implementations, it now is theoretically
|
|
|
+ * possible to copy a signal. Even different semantics are
|
|
|
+ * possible. But none of the possible semantics are what the user
|
|
|
+ * intended in all cases, so I believe it is still the safer
|
|
|
+ * choice to simply disallow copying.
|
|
|
+ */
|
|
|
+ @disable this(this);
|
|
|
+ /// Forbid copying
|
|
|
+ @disable void opAssign(SignalImpl other);
|
|
|
+
|
|
|
+ void emit(Args...)( Args args )
|
|
|
+ {
|
|
|
+ int emptyCount = 0;
|
|
|
+ if (!_slots.emitInProgress)
|
|
|
+ {
|
|
|
+ _slots.emitInProgress = true;
|
|
|
+ scope (exit) _slots.emitInProgress = false;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ emptyCount = -1;
|
|
|
+ doEmit(0, emptyCount, args);
|
|
|
+ if (emptyCount > 0)
|
|
|
+ {
|
|
|
+ _slots.slots = _slots.slots[0 .. $-emptyCount];
|
|
|
+ _slots.slots.assumeSafeAppend();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void addSlot(Object obj, void delegate() dg)
|
|
|
+ {
|
|
|
+ auto oldSlots = _slots.slots;
|
|
|
+ if (oldSlots.capacity <= oldSlots.length)
|
|
|
+ {
|
|
|
+ auto buf = new SlotImpl[oldSlots.length+1]; // TODO: This growing strategy might be inefficient.
|
|
|
+ foreach (i, ref slot ; oldSlots)
|
|
|
+ buf[i].moveFrom(slot);
|
|
|
+ oldSlots = buf;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ oldSlots.length = oldSlots.length + 1;
|
|
|
+
|
|
|
+ oldSlots[$-1].construct(obj, dg);
|
|
|
+ _slots.slots = oldSlots;
|
|
|
+ }
|
|
|
+ void removeSlot(Object obj, void delegate() dg)
|
|
|
+ {
|
|
|
+ removeSlot((ref SlotImpl item) => item.wasConstructedFrom(obj, dg));
|
|
|
+ }
|
|
|
+ void removeSlot(Object obj)
|
|
|
+ {
|
|
|
+ removeSlot((ref SlotImpl item) => item.obj is obj);
|
|
|
+ }
|
|
|
+
|
|
|
+ ~this()
|
|
|
+ {
|
|
|
+ foreach (ref slot; _slots.slots)
|
|
|
+ {
|
|
|
+ debug (signal) { import std.stdio; stderr.writefln("Destruction, removing some slot(%s, weakref: %s), signal: ", &slot, &slot._obj, &this); }
|
|
|
+ slot.reset(); // This is needed because ATM the GC won't trigger struct
|
|
|
+ // destructors to be run when within a GC managed array.
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /// Little helper functions:
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Find and make invalid any slot for which isRemoved returns true.
|
|
|
+ */
|
|
|
+ void removeSlot(bool delegate(ref SlotImpl) isRemoved)
|
|
|
+ {
|
|
|
+ if (_slots.emitInProgress)
|
|
|
+ {
|
|
|
+ foreach (ref slot; _slots.slots)
|
|
|
+ if (isRemoved(slot))
|
|
|
+ slot.reset();
|
|
|
+ }
|
|
|
+ else // It is save to do immediate cleanup:
|
|
|
+ {
|
|
|
+ int emptyCount = 0;
|
|
|
+ auto mslots = _slots.slots;
|
|
|
+ foreach (int i, ref slot; mslots)
|
|
|
+ {
|
|
|
+ // We are retrieving obj twice which is quite expensive because of GC lock:
|
|
|
+ if (!slot.isValid || isRemoved(slot))
|
|
|
+ {
|
|
|
+ emptyCount++;
|
|
|
+ slot.reset();
|
|
|
+ }
|
|
|
+ else if (emptyCount)
|
|
|
+ mslots[i-emptyCount].moveFrom(slot);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (emptyCount > 0)
|
|
|
+ {
|
|
|
+ mslots = mslots[0..$-emptyCount];
|
|
|
+ mslots.assumeSafeAppend();
|
|
|
+ _slots.slots = mslots;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Helper method to allow all slots being called even in case of an exception.
|
|
|
+ * All exceptions that occur will be chained.
|
|
|
+ * Any invalid slots (GC collected or removed) will be dropped.
|
|
|
+ */
|
|
|
+ void doEmit(Args...)(int offset, ref int emptyCount, Args args )
|
|
|
+ {
|
|
|
+ int i=offset;
|
|
|
+ auto myslots = _slots.slots;
|
|
|
+ scope (exit) if (i+1<myslots.length) doEmit(i+1, emptyCount, args); // Carry on.
|
|
|
+ if (emptyCount == -1)
|
|
|
+ {
|
|
|
+ for (; i<myslots.length; i++)
|
|
|
+ {
|
|
|
+ myslots[i](args);
|
|
|
+ myslots = _slots.slots; // Refresh because addSlot might have been called.
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ for (; i<myslots.length; i++)
|
|
|
+ {
|
|
|
+ bool result = myslots[i](args);
|
|
|
+ myslots = _slots.slots; // Refresh because addSlot might have been called.
|
|
|
+ if (!result)
|
|
|
+ emptyCount++;
|
|
|
+ else if (emptyCount>0)
|
|
|
+ {
|
|
|
+ myslots[i-emptyCount].reset();
|
|
|
+ myslots[i-emptyCount].moveFrom(myslots[i]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ SlotArray _slots;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+// Simple convenience struct for signal implementation.
|
|
|
+// Its is inherently unsafe. It is not a template so SignalImpl does
|
|
|
+// not need to be one.
|
|
|
+private struct SlotImpl
|
|
|
+{
|
|
|
+ @disable this(this);
|
|
|
+ @disable void opAssign(SlotImpl other);
|
|
|
+
|
|
|
+ /// Pass null for o if you have a strong ref delegate.
|
|
|
+ /// dg.funcptr must not point to heap memory.
|
|
|
+ void construct(Object o, void delegate() dg)
|
|
|
+ in { assert(this is SlotImpl.init); }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ _obj.construct(o);
|
|
|
+ _dataPtr = dg.ptr;
|
|
|
+ _funcPtr = dg.funcptr;
|
|
|
+ assert(GC.addrOf(_funcPtr) is null, "Your function is implemented on the heap? Such dirty tricks are not supported with std.signal!");
|
|
|
+ if (o)
|
|
|
+ {
|
|
|
+ if (_dataPtr is cast(void*) o)
|
|
|
+ _dataPtr = directPtrFlag;
|
|
|
+ hasObject = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Check whether this slot was constructed from object o and delegate dg.
|
|
|
+ */
|
|
|
+ bool wasConstructedFrom(Object o, void delegate() dg)
|
|
|
+ {
|
|
|
+ if ( o && dg.ptr is cast(void*) o)
|
|
|
+ return obj is o && _dataPtr is directPtrFlag && funcPtr is dg.funcptr;
|
|
|
+ else
|
|
|
+ return obj is o && _dataPtr is dg.ptr && funcPtr is dg.funcptr;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Implement proper explict move.
|
|
|
+ */
|
|
|
+ void moveFrom(ref SlotImpl other)
|
|
|
+ in { assert(this is SlotImpl.init); }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ auto o = other.obj;
|
|
|
+ _obj.construct(o);
|
|
|
+ _dataPtr = other._dataPtr;
|
|
|
+ _funcPtr = other._funcPtr;
|
|
|
+ other.reset(); // Destroy original!
|
|
|
+ }
|
|
|
+
|
|
|
+ @property Object obj()
|
|
|
+ {
|
|
|
+ return _obj.obj;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Whether or not _obj should contain a valid object. (We have a weak connection)
|
|
|
+ */
|
|
|
+ bool hasObject() @property const
|
|
|
+ {
|
|
|
+ return cast(ptrdiff_t) _funcPtr & 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Check whether this is a valid slot.
|
|
|
+ *
|
|
|
+ * Meaning opCall will call something and return true;
|
|
|
+ */
|
|
|
+ bool isValid() @property
|
|
|
+ {
|
|
|
+ return funcPtr && (!hasObject || obj !is null);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Call the slot.
|
|
|
+ *
|
|
|
+ * Returns: True if the call was successful (the slot was valid).
|
|
|
+ */
|
|
|
+ bool opCall(Args...)(Args args)
|
|
|
+ {
|
|
|
+ auto o = obj;
|
|
|
+ void* o_addr = cast(void*)(o);
|
|
|
+
|
|
|
+ if (!funcPtr || (hasObject && !o_addr))
|
|
|
+ return false;
|
|
|
+ if (_dataPtr is directPtrFlag || !hasObject)
|
|
|
+ {
|
|
|
+ void delegate(Args) mdg;
|
|
|
+ mdg.funcptr=cast(void function(Args)) funcPtr;
|
|
|
+ debug (signal) { import std.stdio; writefln("hasObject: %s, o_addr: %s, dataPtr: %s", hasObject, o_addr, _dataPtr);}
|
|
|
+ assert((hasObject && _dataPtr is directPtrFlag) || (!hasObject && _dataPtr !is directPtrFlag));
|
|
|
+ if (hasObject)
|
|
|
+ mdg.ptr = o_addr;
|
|
|
+ else
|
|
|
+ mdg.ptr = _dataPtr;
|
|
|
+ mdg(args);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ void delegate(Object, Args) mdg;
|
|
|
+ mdg.ptr = _dataPtr;
|
|
|
+ mdg.funcptr = cast(void function(Object, Args)) funcPtr;
|
|
|
+ mdg(o, args);
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Reset this instance to its intial value.
|
|
|
+ */
|
|
|
+ void reset() {
|
|
|
+ _funcPtr = SlotImpl.init._funcPtr;
|
|
|
+ _dataPtr = SlotImpl.init._dataPtr;
|
|
|
+ _obj.reset();
|
|
|
+ }
|
|
|
+private:
|
|
|
+ void* funcPtr() @property const
|
|
|
+ {
|
|
|
+ return cast(void*)( cast(ptrdiff_t)_funcPtr & ~cast(ptrdiff_t)1);
|
|
|
+ }
|
|
|
+ void hasObject(bool yes) @property
|
|
|
+ {
|
|
|
+ if (yes)
|
|
|
+ _funcPtr = cast(void*)(cast(ptrdiff_t) _funcPtr | 1);
|
|
|
+ else
|
|
|
+ _funcPtr = cast(void*)(cast(ptrdiff_t) _funcPtr & ~cast(ptrdiff_t)1);
|
|
|
+ }
|
|
|
+ void* _funcPtr;
|
|
|
+ void* _dataPtr;
|
|
|
+ WeakRef _obj;
|
|
|
+
|
|
|
+
|
|
|
+ enum directPtrFlag = cast(void*)(~0);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+// Provides a way of holding a reference to an object, without the GC seeing it.
|
|
|
+private struct WeakRef
|
|
|
+{
|
|
|
+ /**
|
|
|
+ * As struct must be relocatable, it is not even possible to
|
|
|
+ * provide proper copy support for WeakRef. rt_attachDisposeEvent
|
|
|
+ * is used for registering unhook. D's move semantics assume
|
|
|
+ * relocatable objects, which results in this(this) being called
|
|
|
+ * for one instance and the destructor for another, thus the wrong
|
|
|
+ * handlers are deregistered. D's assumption of relocatable
|
|
|
+ * objects is not matched, so move() for example will still simply
|
|
|
+ * swap contents of two structs, resulting in the wrong unhook
|
|
|
+ * delegates being unregistered.
|
|
|
+
|
|
|
+ * Unfortunately the runtime still blindly copies WeakRefs if they
|
|
|
+ * are in a dynamic array and reallocation is needed. This case
|
|
|
+ * has to be handled separately.
|
|
|
+ */
|
|
|
+ @disable this(this);
|
|
|
+ @disable void opAssign(WeakRef other);
|
|
|
+ void construct(Object o)
|
|
|
+ in { assert(this is WeakRef.init); }
|
|
|
+ body
|
|
|
+ {
|
|
|
+ debug (signal) createdThis=&this;
|
|
|
+ debug (signal) { import std.stdio; writefln("WeakRef.construct for %s and object: %s", &this, o); }
|
|
|
+ if (!o)
|
|
|
+ return;
|
|
|
+ _obj.construct(cast(void*)o);
|
|
|
+ rt_attachDisposeEvent(o, &unhook);
|
|
|
+ }
|
|
|
+ Object obj() @property
|
|
|
+ {
|
|
|
+ return cast(Object) _obj.address;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Reset this instance to its intial value.
|
|
|
+ */
|
|
|
+ void reset()
|
|
|
+ {
|
|
|
+ auto o = obj;
|
|
|
+ debug (signal) { import std.stdio; writefln("WeakRef.reset for %s and object: %s", &this, o); }
|
|
|
+ if (o)
|
|
|
+ rt_detachDisposeEvent(o, &unhook);
|
|
|
+ unhook(o); // unhook has to be done unconditionally, because in case the GC
|
|
|
+ //kicked in during toggleVisibility(), obj would contain -1
|
|
|
+ //so the assertion of SlotImpl.moveFrom would fail.
|
|
|
+ debug (signal) createdThis = null;
|
|
|
+ }
|
|
|
+
|
|
|
+ ~this()
|
|
|
+ {
|
|
|
+ reset();
|
|
|
+ }
|
|
|
+private:
|
|
|
+ debug (signal)
|
|
|
+ {
|
|
|
+ invariant()
|
|
|
+ {
|
|
|
+ import std.conv : text;
|
|
|
+ assert(createdThis is null || &this is createdThis,
|
|
|
+ text("We changed address! This should really not happen! Orig address: ",
|
|
|
+ cast(void*)createdThis, " new address: ", cast(void*)&this));
|
|
|
+ }
|
|
|
+
|
|
|
+ WeakRef* createdThis;
|
|
|
+ }
|
|
|
+
|
|
|
+ void unhook(Object o)
|
|
|
+ {
|
|
|
+ _obj.reset();
|
|
|
+ }
|
|
|
+
|
|
|
+ shared(InvisibleAddress) _obj;
|
|
|
+}
|
|
|
+
|
|
|
+// Do all the dirty stuff, WeakRef is only a thin wrapper completing
|
|
|
+// the functionality by means of rt_ hooks.
|
|
|
+private shared struct InvisibleAddress
|
|
|
+{
|
|
|
+ /// Initialize with o, state is set to invisible immediately.
|
|
|
+ /// No precautions regarding thread safety are necessary because
|
|
|
+ /// obviously a live reference exists.
|
|
|
+ void construct(void* o)
|
|
|
+ {
|
|
|
+ auto tmp = cast(ptrdiff_t) o;
|
|
|
+ _addr = makeInvisible(cast(ptrdiff_t) o);
|
|
|
+ }
|
|
|
+ void reset()
|
|
|
+ {
|
|
|
+ atomicStore(_addr, 0L);
|
|
|
+ }
|
|
|
+ void* address() @property
|
|
|
+ {
|
|
|
+ makeVisible();
|
|
|
+ scope (exit) makeInvisible();
|
|
|
+ GC.addrOf(cast(void*)atomicLoad(_addr)); // Just a dummy call to the GC
|
|
|
+ // in order to wait for any possible running
|
|
|
+ // collection to complete (have unhook called).
|
|
|
+ auto buf = atomicLoad(_addr);
|
|
|
+ if ( isNull(buf) )
|
|
|
+ return null;
|
|
|
+ assert(isVisible(buf));
|
|
|
+ return cast(void*) buf;
|
|
|
+ }
|
|
|
+ debug(signal) string toString()
|
|
|
+ {
|
|
|
+ import std.conv : text;
|
|
|
+ return text(address);
|
|
|
+ }
|
|
|
+private:
|
|
|
+
|
|
|
+ long _addr;
|
|
|
+
|
|
|
+ void makeVisible()
|
|
|
+ {
|
|
|
+ long buf, wbuf;
|
|
|
+ do
|
|
|
+ {
|
|
|
+ buf = atomicLoad(_addr);
|
|
|
+ wbuf = makeVisible(buf);
|
|
|
+ }
|
|
|
+ while(!cas(&_addr, buf, wbuf));
|
|
|
+ }
|
|
|
+ void makeInvisible()
|
|
|
+ {
|
|
|
+ long buf, wbuf;
|
|
|
+ do
|
|
|
+ {
|
|
|
+ buf = atomicLoad(_addr);
|
|
|
+ wbuf = makeInvisible(buf);
|
|
|
+ }
|
|
|
+ while(!cas(&_addr, buf, wbuf));
|
|
|
+ }
|
|
|
+ version(D_LP64)
|
|
|
+ {
|
|
|
+ static long makeVisible(long addr)
|
|
|
+ {
|
|
|
+ return ~addr;
|
|
|
+ }
|
|
|
+
|
|
|
+ static long makeInvisible(long addr)
|
|
|
+ {
|
|
|
+ return ~addr;
|
|
|
+ }
|
|
|
+ static bool isVisible(long addr)
|
|
|
+ {
|
|
|
+ return !(addr & (1L << (ptrdiff_t.sizeof*8-1)));
|
|
|
+ }
|
|
|
+ static bool isNull(long addr)
|
|
|
+ {
|
|
|
+ return ( addr == 0 || addr == (~0) );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ static long makeVisible(long addr)
|
|
|
+ {
|
|
|
+ auto addrHigh = (addr >> 32) & 0xffff;
|
|
|
+ auto addrLow = addr & 0xffff;
|
|
|
+ return addrHigh << 16 | addrLow;
|
|
|
+ }
|
|
|
+
|
|
|
+ static long makeInvisible(long addr)
|
|
|
+ {
|
|
|
+ auto addrHigh = ((addr >> 16) & 0x0000ffff) | 0xffff0000;
|
|
|
+ auto addrLow = (addr & 0x0000ffff) | 0xffff0000;
|
|
|
+ return (cast(long)addrHigh << 32) | addrLow;
|
|
|
+ }
|
|
|
+ static bool isVisible(long addr)
|
|
|
+ {
|
|
|
+ return !((addr >> 32) & 0xffffffff);
|
|
|
+ }
|
|
|
+ static bool isNull(long addr)
|
|
|
+ {
|
|
|
+ return ( addr == 0 || addr == ((0xffff0000L << 32) | 0xffff0000) );
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+* Provides a way of storing flags in unused parts of a typical D array.
|
|
|
+*
|
|
|
+* By unused I mean the highest bits of the length.
|
|
|
+* (We don't need to support 4 billion slots per signal with int
|
|
|
+* or 10^19 if length gets changed to 64 bits.)
|
|
|
+*/
|
|
|
+private struct SlotArray {
|
|
|
+ // Choose int for now, this saves 4 bytes on 64 bits.
|
|
|
+ alias int lengthType;
|
|
|
+ import std.bitmanip : bitfields;
|
|
|
+ enum reservedBitsCount = 3;
|
|
|
+ enum maxSlotCount = lengthType.max >> reservedBitsCount;
|
|
|
+ SlotImpl[] slots() @property
|
|
|
+ {
|
|
|
+ return _ptr[0 .. length];
|
|
|
+ }
|
|
|
+ void slots(SlotImpl[] newSlots) @property
|
|
|
+ {
|
|
|
+ _ptr = newSlots.ptr;
|
|
|
+ version(assert)
|
|
|
+ {
|
|
|
+ import std.conv : text;
|
|
|
+ assert(newSlots.length <= maxSlotCount, text("Maximum slots per signal exceeded: ", newSlots.length, "/", maxSlotCount));
|
|
|
+ }
|
|
|
+ _blength.length &= ~maxSlotCount;
|
|
|
+ _blength.length |= newSlots.length;
|
|
|
+ }
|
|
|
+ size_t length() @property
|
|
|
+ {
|
|
|
+ return _blength.length & maxSlotCount;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool emitInProgress() @property
|
|
|
+ {
|
|
|
+ return _blength.emitInProgress;
|
|
|
+ }
|
|
|
+ void emitInProgress(bool val) @property
|
|
|
+ {
|
|
|
+ _blength.emitInProgress = val;
|
|
|
+ }
|
|
|
+private:
|
|
|
+ SlotImpl* _ptr;
|
|
|
+ union BitsLength {
|
|
|
+ mixin(bitfields!(
|
|
|
+ bool, "", lengthType.sizeof*8-1,
|
|
|
+ bool, "emitInProgress", 1
|
|
|
+ ));
|
|
|
+ lengthType length;
|
|
|
+ }
|
|
|
+ BitsLength _blength;
|
|
|
+}
|
|
|
+unittest {
|
|
|
+ SlotArray arr;
|
|
|
+ auto tmp = new SlotImpl[10];
|
|
|
+ arr.slots = tmp;
|
|
|
+ assert(arr.length == 10);
|
|
|
+ assert(!arr.emitInProgress);
|
|
|
+ arr.emitInProgress = true;
|
|
|
+ assert(arr.emitInProgress);
|
|
|
+ assert(arr.length == 10);
|
|
|
+ assert(arr.slots is tmp);
|
|
|
+ arr.slots = tmp;
|
|
|
+ assert(arr.emitInProgress);
|
|
|
+ assert(arr.length == 10);
|
|
|
+ assert(arr.slots is tmp);
|
|
|
+ debug (signal){ import std.stdio;
|
|
|
+ writeln("Slot array tests passed!");
|
|
|
+ }
|
|
|
+}
|
|
|
+unittest
|
|
|
+{ // Check that above example really works ...
|
|
|
+ debug (signal) import std.stdio;
|
|
|
+ class MyObject
|
|
|
+ {
|
|
|
+ mixin(signal!(string, int)("valueChanged"));
|
|
|
+
|
|
|
+ int value() @property { return _value; }
|
|
|
+ int value(int v) @property
|
|
|
+ {
|
|
|
+ if (v != _value)
|
|
|
+ {
|
|
|
+ _value = v;
|
|
|
+ // call all the connected slots with the two parameters
|
|
|
+ _valueChanged.emit("setting new value", v);
|
|
|
+ }
|
|
|
+ return v;
|
|
|
+ }
|
|
|
+ private:
|
|
|
+ int _value;
|
|
|
+ }
|
|
|
+
|
|
|
+ class Observer
|
|
|
+ { // our slot
|
|
|
+ void watch(string msg, int i)
|
|
|
+ {
|
|
|
+ debug (signal) writefln("Observed msg '%s' and value %s", msg, i);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void watch(string msg, int i)
|
|
|
+ {
|
|
|
+ debug (signal) writefln("Globally observed msg '%s' and value %s", msg, i);
|
|
|
+ }
|
|
|
+ auto a = new MyObject;
|
|
|
+ Observer o = new Observer;
|
|
|
+
|
|
|
+ a.value = 3; // should not call o.watch()
|
|
|
+ a.valueChanged.connect!"watch"(o); // o.watch is the slot
|
|
|
+ a.value = 4; // should call o.watch()
|
|
|
+ a.valueChanged.disconnect!"watch"(o); // o.watch is no longer a slot
|
|
|
+ a.value = 5; // so should not call o.watch()
|
|
|
+ a.valueChanged.connect!"watch"(o); // connect again
|
|
|
+ // Do some fancy stuff:
|
|
|
+ a.valueChanged.connect!Observer(o, (obj, msg, i) => obj.watch("Some other text I made up", i+1));
|
|
|
+ a.valueChanged.strongConnect(&watch);
|
|
|
+ a.value = 6; // should call o.watch()
|
|
|
+ destroy(o); // destroying o should automatically disconnect it
|
|
|
+ a.value = 7; // should not call o.watch()
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+unittest
|
|
|
+{
|
|
|
+ debug (signal) import std.stdio;
|
|
|
+ class Observer
|
|
|
+ {
|
|
|
+ void watch(string msg, int i)
|
|
|
+ {
|
|
|
+ //writefln("Observed msg '%s' and value %s", msg, i);
|
|
|
+ captured_value = i;
|
|
|
+ captured_msg = msg;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ int captured_value;
|
|
|
+ string captured_msg;
|
|
|
+ }
|
|
|
+
|
|
|
+ class SimpleObserver
|
|
|
+ {
|
|
|
+ void watchOnlyInt(int i) {
|
|
|
+ captured_value = i;
|
|
|
+ }
|
|
|
+ int captured_value;
|
|
|
+ }
|
|
|
+
|
|
|
+ class Foo
|
|
|
+ {
|
|
|
+ @property int value() { return _value; }
|
|
|
+
|
|
|
+ @property int value(int v)
|
|
|
+ {
|
|
|
+ if (v != _value)
|
|
|
+ { _value = v;
|
|
|
+ _extendedSig.emit("setting new value", v);
|
|
|
+ //_simpleSig.emit(v);
|
|
|
+ }
|
|
|
+ return v;
|
|
|
+ }
|
|
|
+
|
|
|
+ mixin(signal!(string, int)("extendedSig"));
|
|
|
+ //Signal!(int) simpleSig;
|
|
|
+
|
|
|
+ private:
|
|
|
+ int _value;
|
|
|
+ }
|
|
|
+
|
|
|
+ Foo a = new Foo;
|
|
|
+ Observer o = new Observer;
|
|
|
+ SimpleObserver so = new SimpleObserver;
|
|
|
+ // check initial condition
|
|
|
+ assert(o.captured_value == 0);
|
|
|
+ assert(o.captured_msg == "");
|
|
|
+
|
|
|
+ // set a value while no observation is in place
|
|
|
+ a.value = 3;
|
|
|
+ assert(o.captured_value == 0);
|
|
|
+ assert(o.captured_msg == "");
|
|
|
+
|
|
|
+ // connect the watcher and trigger it
|
|
|
+ a.extendedSig.connect!"watch"(o);
|
|
|
+ a.value = 4;
|
|
|
+ assert(o.captured_value == 4);
|
|
|
+ assert(o.captured_msg == "setting new value");
|
|
|
+
|
|
|
+ // disconnect the watcher and make sure it doesn't trigger
|
|
|
+ a.extendedSig.disconnect!"watch"(o);
|
|
|
+ a.value = 5;
|
|
|
+ assert(o.captured_value == 4);
|
|
|
+ assert(o.captured_msg == "setting new value");
|
|
|
+ //a.extendedSig.connect!Observer(o, (obj, msg, i) { obj.watch("Hahah", i); });
|
|
|
+ a.extendedSig.connect!Observer(o, (obj, msg, i) => obj.watch("Hahah", i) );
|
|
|
+
|
|
|
+ a.value = 7;
|
|
|
+ debug (signal) stderr.writeln("After asignment!");
|
|
|
+ assert(o.captured_value == 7);
|
|
|
+ assert(o.captured_msg == "Hahah");
|
|
|
+ a.extendedSig.disconnect(o); // Simply disconnect o, otherwise we would have to store the lamda somewhere if we want to disconnect later on.
|
|
|
+ // reconnect the watcher and make sure it triggers
|
|
|
+ a.extendedSig.connect!"watch"(o);
|
|
|
+ a.value = 6;
|
|
|
+ assert(o.captured_value == 6);
|
|
|
+ assert(o.captured_msg == "setting new value");
|
|
|
+
|
|
|
+ // destroy the underlying object and make sure it doesn't cause
|
|
|
+ // a crash or other problems
|
|
|
+ debug (signal) stderr.writefln("Disposing");
|
|
|
+ destroy(o);
|
|
|
+ debug (signal) stderr.writefln("Disposed");
|
|
|
+ a.value = 7;
|
|
|
+}
|
|
|
+
|
|
|
+unittest {
|
|
|
+ class Observer
|
|
|
+ {
|
|
|
+ int i;
|
|
|
+ long l;
|
|
|
+ string str;
|
|
|
+
|
|
|
+ void watchInt(string str, int i)
|
|
|
+ {
|
|
|
+ this.str = str;
|
|
|
+ this.i = i;
|
|
|
+ }
|
|
|
+
|
|
|
+ void watchLong(string str, long l)
|
|
|
+ {
|
|
|
+ this.str = str;
|
|
|
+ this.l = l;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ class Bar
|
|
|
+ {
|
|
|
+ @property void value1(int v) { _s1.emit("str1", v); }
|
|
|
+ @property void value2(int v) { _s2.emit("str2", v); }
|
|
|
+ @property void value3(long v) { _s3.emit("str3", v); }
|
|
|
+
|
|
|
+ mixin(signal!(string, int) ("s1"));
|
|
|
+ mixin(signal!(string, int) ("s2"));
|
|
|
+ mixin(signal!(string, long)("s3"));
|
|
|
+ }
|
|
|
+
|
|
|
+ void test(T)(T a)
|
|
|
+ {
|
|
|
+ auto o1 = new Observer;
|
|
|
+ auto o2 = new Observer;
|
|
|
+ auto o3 = new Observer;
|
|
|
+
|
|
|
+ // connect the watcher and trigger it
|
|
|
+ a.s1.connect!"watchInt"(o1);
|
|
|
+ a.s2.connect!"watchInt"(o2);
|
|
|
+ a.s3.connect!"watchLong"(o3);
|
|
|
+
|
|
|
+ assert(!o1.i && !o1.l && !o1.str);
|
|
|
+ assert(!o2.i && !o2.l && !o2.str);
|
|
|
+ assert(!o3.i && !o3.l && !o3.str);
|
|
|
+
|
|
|
+ a.value1 = 11;
|
|
|
+ assert(o1.i == 11 && !o1.l && o1.str == "str1");
|
|
|
+ assert(!o2.i && !o2.l && !o2.str);
|
|
|
+ assert(!o3.i && !o3.l && !o3.str);
|
|
|
+ o1.i = -11; o1.str = "x1";
|
|
|
+
|
|
|
+ a.value2 = 12;
|
|
|
+ assert(o1.i == -11 && !o1.l && o1.str == "x1");
|
|
|
+ assert(o2.i == 12 && !o2.l && o2.str == "str2");
|
|
|
+ assert(!o3.i && !o3.l && !o3.str);
|
|
|
+ o2.i = -12; o2.str = "x2";
|
|
|
+
|
|
|
+ a.value3 = 13;
|
|
|
+ assert(o1.i == -11 && !o1.l && o1.str == "x1");
|
|
|
+ assert(o2.i == -12 && !o1.l && o2.str == "x2");
|
|
|
+ assert(!o3.i && o3.l == 13 && o3.str == "str3");
|
|
|
+ o3.l = -13; o3.str = "x3";
|
|
|
+
|
|
|
+ // disconnect the watchers and make sure it doesn't trigger
|
|
|
+ a.s1.disconnect!"watchInt"(o1);
|
|
|
+ a.s2.disconnect!"watchInt"(o2);
|
|
|
+ a.s3.disconnect!"watchLong"(o3);
|
|
|
+
|
|
|
+ a.value1 = 21;
|
|
|
+ a.value2 = 22;
|
|
|
+ a.value3 = 23;
|
|
|
+ assert(o1.i == -11 && !o1.l && o1.str == "x1");
|
|
|
+ assert(o2.i == -12 && !o1.l && o2.str == "x2");
|
|
|
+ assert(!o3.i && o3.l == -13 && o3.str == "x3");
|
|
|
+
|
|
|
+ // reconnect the watcher and make sure it triggers
|
|
|
+ a.s1.connect!"watchInt"(o1);
|
|
|
+ a.s2.connect!"watchInt"(o2);
|
|
|
+ a.s3.connect!"watchLong"(o3);
|
|
|
+
|
|
|
+ a.value1 = 31;
|
|
|
+ a.value2 = 32;
|
|
|
+ a.value3 = 33;
|
|
|
+ assert(o1.i == 31 && !o1.l && o1.str == "str1");
|
|
|
+ assert(o2.i == 32 && !o1.l && o2.str == "str2");
|
|
|
+ assert(!o3.i && o3.l == 33 && o3.str == "str3");
|
|
|
+
|
|
|
+ // destroy observers
|
|
|
+ destroy(o1);
|
|
|
+ destroy(o2);
|
|
|
+ destroy(o3);
|
|
|
+ a.value1 = 41;
|
|
|
+ a.value2 = 42;
|
|
|
+ a.value3 = 43;
|
|
|
+ }
|
|
|
+
|
|
|
+ test(new Bar);
|
|
|
+
|
|
|
+ class BarDerived: Bar
|
|
|
+ {
|
|
|
+ @property void value4(int v) { _s4.emit("str4", v); }
|
|
|
+ @property void value5(int v) { _s5.emit("str5", v); }
|
|
|
+ @property void value6(long v) { _s6.emit("str6", v); }
|
|
|
+
|
|
|
+ mixin(signal!(string, int) ("s4"));
|
|
|
+ mixin(signal!(string, int) ("s5"));
|
|
|
+ mixin(signal!(string, long)("s6"));
|
|
|
+ }
|
|
|
+
|
|
|
+ auto a = new BarDerived;
|
|
|
+
|
|
|
+ test!Bar(a);
|
|
|
+ test!BarDerived(a);
|
|
|
+
|
|
|
+ auto o4 = new Observer;
|
|
|
+ auto o5 = new Observer;
|
|
|
+ auto o6 = new Observer;
|
|
|
+
|
|
|
+ // connect the watcher and trigger it
|
|
|
+ a.s4.connect!"watchInt"(o4);
|
|
|
+ a.s5.connect!"watchInt"(o5);
|
|
|
+ a.s6.connect!"watchLong"(o6);
|
|
|
+
|
|
|
+ assert(!o4.i && !o4.l && !o4.str);
|
|
|
+ assert(!o5.i && !o5.l && !o5.str);
|
|
|
+ assert(!o6.i && !o6.l && !o6.str);
|
|
|
+
|
|
|
+ a.value4 = 44;
|
|
|
+ assert(o4.i == 44 && !o4.l && o4.str == "str4");
|
|
|
+ assert(!o5.i && !o5.l && !o5.str);
|
|
|
+ assert(!o6.i && !o6.l && !o6.str);
|
|
|
+ o4.i = -44; o4.str = "x4";
|
|
|
+
|
|
|
+ a.value5 = 45;
|
|
|
+ assert(o4.i == -44 && !o4.l && o4.str == "x4");
|
|
|
+ assert(o5.i == 45 && !o5.l && o5.str == "str5");
|
|
|
+ assert(!o6.i && !o6.l && !o6.str);
|
|
|
+ o5.i = -45; o5.str = "x5";
|
|
|
+
|
|
|
+ a.value6 = 46;
|
|
|
+ assert(o4.i == -44 && !o4.l && o4.str == "x4");
|
|
|
+ assert(o5.i == -45 && !o4.l && o5.str == "x5");
|
|
|
+ assert(!o6.i && o6.l == 46 && o6.str == "str6");
|
|
|
+ o6.l = -46; o6.str = "x6";
|
|
|
+
|
|
|
+ // disconnect the watchers and make sure it doesn't trigger
|
|
|
+ a.s4.disconnect!"watchInt"(o4);
|
|
|
+ a.s5.disconnect!"watchInt"(o5);
|
|
|
+ a.s6.disconnect!"watchLong"(o6);
|
|
|
+
|
|
|
+ a.value4 = 54;
|
|
|
+ a.value5 = 55;
|
|
|
+ a.value6 = 56;
|
|
|
+ assert(o4.i == -44 && !o4.l && o4.str == "x4");
|
|
|
+ assert(o5.i == -45 && !o4.l && o5.str == "x5");
|
|
|
+ assert(!o6.i && o6.l == -46 && o6.str == "x6");
|
|
|
+
|
|
|
+ // reconnect the watcher and make sure it triggers
|
|
|
+ a.s4.connect!"watchInt"(o4);
|
|
|
+ a.s5.connect!"watchInt"(o5);
|
|
|
+ a.s6.connect!"watchLong"(o6);
|
|
|
+
|
|
|
+ a.value4 = 64;
|
|
|
+ a.value5 = 65;
|
|
|
+ a.value6 = 66;
|
|
|
+ assert(o4.i == 64 && !o4.l && o4.str == "str4");
|
|
|
+ assert(o5.i == 65 && !o4.l && o5.str == "str5");
|
|
|
+ assert(!o6.i && o6.l == 66 && o6.str == "str6");
|
|
|
+
|
|
|
+ // destroy observers
|
|
|
+ destroy(o4);
|
|
|
+ destroy(o5);
|
|
|
+ destroy(o6);
|
|
|
+ a.value4 = 44;
|
|
|
+ a.value5 = 45;
|
|
|
+ a.value6 = 46;
|
|
|
+}
|
|
|
+
|
|
|
+unittest
|
|
|
+{
|
|
|
+ import std.stdio;
|
|
|
+
|
|
|
+ struct Property
|
|
|
+ {
|
|
|
+ alias value this;
|
|
|
+ mixin(signal!(int)("signal"));
|
|
|
+ @property int value()
|
|
|
+ {
|
|
|
+ return value_;
|
|
|
+ }
|
|
|
+ ref Property opAssign(int val)
|
|
|
+ {
|
|
|
+ debug (signal) writeln("Assigning int to property with signal: ", &this);
|
|
|
+ value_ = val;
|
|
|
+ _signal.emit(val);
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+ private:
|
|
|
+ int value_;
|
|
|
+ }
|
|
|
+
|
|
|
+ void observe(int val)
|
|
|
+ {
|
|
|
+ debug (signal) writefln("observe: Wow! The value changed: %s", val);
|
|
|
+ }
|
|
|
+
|
|
|
+ class Observer
|
|
|
+ {
|
|
|
+ void observe(int val)
|
|
|
+ {
|
|
|
+ debug (signal) writefln("Observer: Wow! The value changed: %s", val);
|
|
|
+ debug (signal) writefln("Really! I must know I am an observer (old value was: %s)!", observed);
|
|
|
+ observed = val;
|
|
|
+ count++;
|
|
|
+ }
|
|
|
+ int observed;
|
|
|
+ int count;
|
|
|
+ }
|
|
|
+ Property prop;
|
|
|
+ void delegate(int) dg = (val) => observe(val);
|
|
|
+ prop.signal.strongConnect(dg);
|
|
|
+ assert(prop.signal._impl._slots.length==1);
|
|
|
+ Observer o=new Observer;
|
|
|
+ prop.signal.connect!"observe"(o);
|
|
|
+ assert(prop.signal._impl._slots.length==2);
|
|
|
+ debug (signal) writeln("Triggering on original property with value 8 ...");
|
|
|
+ prop=8;
|
|
|
+ assert(o.count==1);
|
|
|
+ assert(o.observed==prop);
|
|
|
+}
|
|
|
+
|
|
|
+unittest
|
|
|
+{
|
|
|
+ debug (signal) import std.stdio;
|
|
|
+ import std.conv;
|
|
|
+ Signal!() s1;
|
|
|
+ void testfunc(int id)
|
|
|
+ {
|
|
|
+ throw new Exception(to!string(id));
|
|
|
+ }
|
|
|
+ s1.strongConnect(() => testfunc(0));
|
|
|
+ s1.strongConnect(() => testfunc(1));
|
|
|
+ s1.strongConnect(() => testfunc(2));
|
|
|
+ try s1.emit();
|
|
|
+ catch(Exception e)
|
|
|
+ {
|
|
|
+ Throwable t=e;
|
|
|
+ int i=0;
|
|
|
+ while (t)
|
|
|
+ {
|
|
|
+ debug (signal) stderr.writefln("Caught exception (this is fine)");
|
|
|
+ assert(to!int(t.msg)==i);
|
|
|
+ t=t.next;
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ assert(i==3);
|
|
|
+ }
|
|
|
+}
|
|
|
+unittest
|
|
|
+{
|
|
|
+ class A
|
|
|
+ {
|
|
|
+ mixin(signal!(string, int)("s1"));
|
|
|
+ }
|
|
|
+
|
|
|
+ class B : A
|
|
|
+ {
|
|
|
+ mixin(signal!(string, int)("s2"));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+unittest
|
|
|
+{
|
|
|
+ struct Test
|
|
|
+ {
|
|
|
+ mixin(signal!int("a", Protection.package_));
|
|
|
+ mixin(signal!int("ap", Protection.private_));
|
|
|
+ mixin(signal!int("app", Protection.protected_));
|
|
|
+ mixin(signal!int("an", Protection.none));
|
|
|
+ }
|
|
|
+
|
|
|
+ static assert(signal!int("a", Protection.package_)=="package Signal!(int) _a;\nref RestrictedSignal!(int) a() { return _a;}\n");
|
|
|
+ static assert(signal!int("a", Protection.protected_)=="protected Signal!(int) _a;\nref RestrictedSignal!(int) a() { return _a;}\n");
|
|
|
+ static assert(signal!int("a", Protection.private_)=="private Signal!(int) _a;\nref RestrictedSignal!(int) a() { return _a;}\n");
|
|
|
+ static assert(signal!int("a", Protection.none)=="private Signal!(int) _a;\nref Signal!(int) a() { return _a;}\n");
|
|
|
+
|
|
|
+ debug (signal)
|
|
|
+ {
|
|
|
+ pragma(msg, signal!int("a", Protection.package_));
|
|
|
+ pragma(msg, signal!(int, string, int[int])("a", Protection.private_));
|
|
|
+ pragma(msg, signal!(int, string, int[int], float, double)("a", Protection.protected_));
|
|
|
+ pragma(msg, signal!(int, string, int[int], float, double, long)("a", Protection.none));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+unittest // Test nested emit/removal/addition ...
|
|
|
+{
|
|
|
+ Signal!() sig;
|
|
|
+ bool doEmit = true;
|
|
|
+ int counter = 0;
|
|
|
+ int slot3called = 0;
|
|
|
+ int slot3shouldcalled = 0;
|
|
|
+ void slot1()
|
|
|
+ {
|
|
|
+ doEmit = !doEmit;
|
|
|
+ if (!doEmit)
|
|
|
+ sig.emit();
|
|
|
+ }
|
|
|
+ void slot3()
|
|
|
+ {
|
|
|
+ slot3called++;
|
|
|
+ }
|
|
|
+ void slot2()
|
|
|
+ {
|
|
|
+ debug (signal) { import std.stdio; writefln("\nCALLED: %s, should called: %s", slot3called, slot3shouldcalled);}
|
|
|
+ assert (slot3called == slot3shouldcalled);
|
|
|
+ if ( ++counter < 100)
|
|
|
+ slot3shouldcalled += counter;
|
|
|
+ if ( counter < 100 )
|
|
|
+ sig.strongConnect(&slot3);
|
|
|
+ }
|
|
|
+ void slot4()
|
|
|
+ {
|
|
|
+ if ( counter == 100 )
|
|
|
+ sig.strongDisconnect(&slot3); // All connections dropped
|
|
|
+ }
|
|
|
+ sig.strongConnect(&slot1);
|
|
|
+ sig.strongConnect(&slot2);
|
|
|
+ sig.strongConnect(&slot4);
|
|
|
+ for (int i=0; i<1000; i++)
|
|
|
+ sig.emit();
|
|
|
+ debug (signal)
|
|
|
+ {
|
|
|
+ import std.stdio;
|
|
|
+ writeln("slot3called: ", slot3called);
|
|
|
+ }
|
|
|
+}
|
|
|
+/* vim: set ts=4 sw=4 expandtab : */
|
