Added nextTick() support to LibEvLoop.

jmalloc · jmalloc · commit 61d85969574a · 2013-11-18T21:01:13.000+10:00
diff --git a/LibEvLoop.php b/LibEvLoop.php
@@ -2,9 +2,13 @@
 
 namespace React\EventLoop;
 
-use SplObjectStorage;
+use libev\EventLoop;
+use libev\IOEvent;
+use libev\TimerEvent;
+use React\EventLoop\Tick\NextTickQueue;
 use React\EventLoop\Timer\Timer;
 use React\EventLoop\Timer\TimerInterface;
+use SplObjectStorage;
 
 /**
  * @see https://github.com/m4rw3r/php-libev
@@ -13,48 +17,141 @@
 class LibEvLoop implements LoopInterface
 {
     private $loop;
+    private $nextTickQueue;
     private $timers;
     private $readEvents = array();
     private $writeEvents = array();
+    private $running;
 
     public function __construct()
     {
-        $this->loop = new \libev\EventLoop();
-        $this->timers = new SplObjectStorage();
+        $this->loop = new EventLoop;
+        $this->nextTickQueue = new NextTickQueue($this);
+        $this->timers = new SplObjectStorage;
     }
 
+    /**
+     * Register a listener to be notified when a stream is ready to read.
+     *
+     * @param stream   $stream   The PHP stream resource to check.
+     * @param callable $listener Invoked when the stream is ready.
+     */
     public function addReadStream($stream, $listener)
     {
-        $this->addStream($stream, $listener, \libev\IOEvent::READ);
+        $this->addStream($stream, $listener, IOEvent::READ);
     }
 
+    /**
+     * Register a listener to be notified when a stream is ready to write.
+     *
+     * @param stream   $stream   The PHP stream resource to check.
+     * @param callable $listener Invoked when the stream is ready.
+     */
     public function addWriteStream($stream, $listener)
     {
-        $this->addStream($stream, $listener, \libev\IOEvent::WRITE);
+        $this->addStream($stream, $listener, IOEvent::WRITE);
     }
 
+    /**
+     * Remove the read event listener for the given stream.
+     *
+     * @param stream $stream The PHP stream resource.
+     */
     public function removeReadStream($stream)
     {
-        if (isset($this->readEvents[(int)$stream])) {
-            $this->readEvents[(int)$stream]->stop();
-            unset($this->readEvents[(int)$stream]);
+        if (isset($this->readEvents[(int) $stream])) {
+            $this->readEvents[(int) $stream]->stop();
+            unset($this->readEvents[(int) $stream]);
         }
     }
 
+    /**
+     * Remove the write event listener for the given stream.
+     *
+     * @param stream $stream The PHP stream resource.
+     */
     public function removeWriteStream($stream)
     {
-        if (isset($this->writeEvents[(int)$stream])) {
-            $this->writeEvents[(int)$stream]->stop();
-            unset($this->writeEvents[(int)$stream]);
+        if (isset($this->writeEvents[(int) $stream])) {
+            $this->writeEvents[(int) $stream]->stop();
+            unset($this->writeEvents[(int) $stream]);
         }
     }
 
+    /**
+     * Remove all listeners for the given stream.
+     *
+     * @param stream $stream The PHP stream resource.
+     */
     public function removeStream($stream)
     {
         $this->removeReadStream($stream);
         $this->removeWriteStream($stream);
     }
 
+    /**
+     * Enqueue a callback to be invoked once after the given interval.
+     *
+     * The execution order of timers scheduled to execute at the same time is
+     * not guaranteed.
+     *
+     * @param numeric  $interval The number of seconds to wait before execution.
+     * @param callable $callback The callback to invoke.
+     *
+     * @return TimerInterface
+     */
+    public function addTimer($interval, $callback)
+    {
+        $timer = new Timer($this, $interval, $callback, false);
+        $this->setupTimer($timer);
+
+        return $timer;
+    }
+
+    /**
+     * Enqueue a callback to be invoked repeatedly after the given interval.
+     *
+     * The execution order of timers scheduled to execute at the same time is
+     * not guaranteed.
+     *
+     * @param numeric  $interval The number of seconds to wait before execution.
+     * @param callable $callback The callback to invoke.
+     *
+     * @return TimerInterface
+     */
+    public function addPeriodicTimer($interval, $callback)
+    {
+        $timer = new Timer($this, $interval, $callback, true);
+        $this->setupTimer($timer);
+
+        return $timer;
+    }
+
+    /**
+     * Cancel a pending timer.
+     *
+     * @param TimerInterface $timer The timer to cancel.
+     */
+    public function cancelTimer(TimerInterface $timer)
+    {
+        if (isset($this->timers[$timer])) {
+            $this->loop->remove($this->timers[$timer]);
+            $this->timers->detach($timer);
+        }
+    }
+
+    /**
+     * Check if a given timer is active.
+     *
+     * @param TimerInterface $timer The timer to check.
+     *
+     * @return boolean True if the timer is still enqueued for execution.
+     */
+    public function isTimerActive(TimerInterface $timer)
+    {
+        return $this->timers->contains($timer);
+    }
+
     /**
      * Schedule a callback to be invoked on the next tick of the event loop.
      *
@@ -65,57 +162,74 @@ public function removeStream($stream)
      */
     public function nextTick(callable $listener)
     {
-        throw new \Exception('Not yet implemented.');
+        $this->nextTickQueue->add($listener);
     }
 
-    private function addStream($stream, $listener, $flags)
+    /**
+     * Perform a single iteration of the event loop.
+     */
+    public function tick()
     {
-        $listener = $this->wrapStreamListener($stream, $listener, $flags);
-        $event = new \libev\IOEvent($listener, $stream, $flags);
-        $this->loop->add($event);
+        $this->nextTickQueue->tick();
 
-        if (($flags & \libev\IOEvent::READ) === $flags) {
-            $this->readEvents[(int)$stream] = $event;
-        } elseif (($flags & \libev\IOEvent::WRITE) === $flags) {
-            $this->writeEvents[(int)$stream] = $event;
-        }
+        $this->loop->run(EventLoop::RUN_ONCE | EventLoop::RUN_NOWAIT);
     }
 
-    private function wrapStreamListener($stream, $listener, $flags)
+    /**
+     * Run the event loop until there are no more tasks to perform.
+     */
+    public function run()
     {
-        if (($flags & \libev\IOEvent::READ) === $flags) {
-            $removeCallback = array($this, 'removeReadStream');
-        } elseif (($flags & \libev\IOEvent::WRITE) === $flags) {
-            $removeCallback = array($this, 'removeWriteStream');
-        }
+        $this->running = true;
 
-        return function ($event) use ($stream, $listener, $removeCallback) {
-            call_user_func($listener, $stream);
-        };
+        while ($this->running) {
+
+            $this->nextTickQueue->tick();
+
+            if (
+                !$this->readEvents
+                && !$this->writeEvents
+                && !$this->timers->count()
+            ) {
+                break;
+            }
+
+            $this->loop->run(EventLoop::RUN_ONCE);
+        }
     }
 
-    public function addTimer($interval, $callback)
+    /**
+     * Instruct a running event loop to stop.
+     */
+    public function stop()
     {
-        $timer = new Timer($this, $interval, $callback, false);
-        $this->setupTimer($timer);
-
-        return $timer;
+        $this->running = false;
     }
 
-    public function addPeriodicTimer($interval, $callback)
+    private function addStream($stream, $listener, $flags)
     {
-        $timer = new Timer($this, $interval, $callback, true);
-        $this->setupTimer($timer);
+        $listener = $this->wrapStreamListener($stream, $listener, $flags);
+        $event = new IOEvent($listener, $stream, $flags);
+        $this->loop->add($event);
 
-        return $timer;
+        if (($flags & IOEvent::READ) === $flags) {
+            $this->readEvents[(int) $stream] = $event;
+        } elseif (($flags & IOEvent::WRITE) === $flags) {
+            $this->writeEvents[(int) $stream] = $event;
+        }
     }
 
-    public function cancelTimer(TimerInterface $timer)
+    private function wrapStreamListener($stream, $listener, $flags)
     {
-        if (isset($this->timers[$timer])) {
-            $this->loop->remove($this->timers[$timer]);
-            $this->timers->detach($timer);
+        if (($flags & IOEvent::READ) === $flags) {
+            $removeCallback = array($this, 'removeReadStream');
+        } elseif (($flags & IOEvent::WRITE) === $flags) {
+            $removeCallback = array($this, 'removeWriteStream');
         }
+
+        return function ($event) use ($stream, $listener, $removeCallback) {
+            call_user_func($listener, $stream);
+        };
     }
 
     private function setupTimer(TimerInterface $timer)
@@ -124,9 +238,9 @@ private function setupTimer(TimerInterface $timer)
         $interval = $timer->getInterval();
 
         if ($timer->isPeriodic()) {
-            $libevTimer = new \libev\TimerEvent($dummyCallback, $interval, $interval);
+            $libevTimer = new TimerEvent($dummyCallback, $interval, $interval);
         } else {
-            $libevTimer = new \libev\TimerEvent($dummyCallback, $interval);
+            $libevTimer = new TimerEvent($dummyCallback, $interval);
         }
 
         $libevTimer->setCallback(function () use ($timer) {
@@ -142,24 +256,4 @@ private function setupTimer(TimerInterface $timer)
 
         return $timer;
     }
-
-    public function isTimerActive(TimerInterface $timer)
-    {
-        return $this->timers->contains($timer);
-    }
-
-    public function tick()
-    {
-        $this->loop->run(\libev\EventLoop::RUN_ONCE);
-    }
-
-    public function run()
-    {
-        $this->loop->run();
-    }
-
-    public function stop()
-    {
-        $this->loop->breakLoop();
-    }
 }
