PHP LoopInterface::addWriteStream方法代码示例

 /**
  * 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, callable $listener)
 {
     $this->emit('addWriteStream', [$stream, $listener]);
     $this->loop->addWriteStream($stream, function ($stream) use($listener) {
         $this->emit('writeStreamTick', [$stream, $listener]);
         $listener($stream, $this);
     });
 }

 /**
  * @param string $message
  */
 public function send($message)
 {
     if ($this->closed) {
         return;
     }
     $this->messages[] = $message;
     if (!$this->listening) {
         $this->listening = true;
         $this->loop->addWriteStream($this->fileDescriptor, $this->writeListener);
     }
 }

 /**
  * Add event listener to event loop.
  *
  * @param $fd
  * @param $flag
  * @param $func
  * @param array $args
  * @return bool
  */
 public function add($fd, $flag, $func, $args = array())
 {
     switch ($flag) {
         case EventInterface::EV_READ:
             return $this->_loop->addReadStream($fd, $func);
         case EventInterface::EV_WRITE:
             return $this->_loop->addWriteStream($fd, $func);
         case EventInterface::EV_SIGNAL:
             return $this->_loop->addSignal($fd, $func);
         case EventInterface::EV_TIMER:
             return $this->_loop->addPeriodicTimer($fd, $func);
         case EventInterface::EV_TIMER_ONCE:
             return $this->_loop->addTimer($fd, $func);
     }
     return false;
 }

 public function testRunWaitsForFutureTickEvents()
 {
     $stream = $this->createStream();
     $this->loop->addWriteStream($stream, function () use($stream) {
         $this->loop->removeStream($stream);
         $this->loop->futureTick(function () {
             echo 'future-tick' . PHP_EOL;
         });
     });
     $this->expectOutputString('future-tick' . PHP_EOL);
     $this->loop->run();
 }

 /**
  * Watch a stream resource to become writable and trigger the callback when actionable
  *
  * @param resource $stream A stream resource to watch for writability
  * @param callable $callback Any valid PHP callable
  * @param bool $enableNow Should the watcher be enabled now or held for later use?
  * @return int
  */
 public function onWritable($stream, callable $callback, $enableNow = true)
 {
     $watcherId = null;
     $this->reactor->addWriteStream($stream, function () use($callback, &$watcherId, $stream) {
         if (isset($this->disabledWatchers[$watcherId])) {
             return null;
         }
         return call_user_func($callback, $watcherId, $stream, $this);
     });
     $watcherId = $this->registerWatcher(self::WATCHER_TYPE_WRITE, $stream);
     if (!$enableNow) {
         $this->disable($watcherId);
     }
     return $watcherId;
 }

 /**
  * Asynchronously sends buffered data over the wire.
  *
  * - Calls {@link eventLoops}'s addWriteStream() with client's stream.
  * - Consecutive calls will return the same instance of promise.
  *
  * @return Promise\PromiseInterface
  */
 protected function flushWriteBuffer()
 {
     if ($this->flushWriteBufferPromise) {
         return $this->flushWriteBufferPromise;
     } else {
         $deferred = new Promise\Deferred();
         $this->eventLoop->addWriteStream($this->getStream(), function ($stream) use($deferred) {
             try {
                 $this->write();
                 if ($this->writeBuffer->isEmpty()) {
                     $this->eventLoop->removeWriteStream($stream);
                     $this->flushWriteBufferPromise = null;
                     $deferred->resolve(true);
                 }
             } catch (\Exception $e) {
                 $this->eventLoop->removeWriteStream($stream);
                 $this->flushWriteBufferPromise = null;
                 $deferred->reject($e);
             }
         });
         return $this->flushWriteBufferPromise = $deferred->promise();
     }
 }