PHP Generator::throw方法代码示例

 /**
  * @param \Generator $generator
  */
 public function __construct(Generator $generator)
 {
     parent::__construct();
     $this->generator = $generator;
     /**
      * @param mixed $value The value to send to the generator.
      */
     $this->send = function ($value = null) {
         if ($this->paused) {
             // If paused, save callable and value for resuming.
             $this->next = [$this->send, $value];
             return;
         }
         try {
             // Send the new value and execute to next yield statement.
             $this->next($this->generator->send($value));
         } catch (Throwable $exception) {
             $this->reject($exception);
             $this->close();
         }
     };
     /**
      * @param \Exception $exception Exception to be thrown into the generator.
      */
     $this->capture = function (Throwable $exception) {
         if ($this->paused) {
             // If paused, save callable and exception for resuming.
             $this->next = [$this->capture, $exception];
             return;
         }
         try {
             // Throw exception at current execution point.
             $this->next($this->generator->throw($exception));
         } catch (Throwable $exception) {
             $this->reject($exception);
             $this->close();
         }
     };
     try {
         $this->next($this->generator->current());
     } catch (Throwable $exception) {
         $this->reject($exception);
         $this->close();
     }
 }

 /**
  * [run 协程调度]
  * @param \Generator $gen
  * @throws \Exception
  */
 public function run(\Generator $gen)
 {
     while (true) {
         try {
             /* 异常处理 */
             if ($this->exception) {
                 $gen->throw($this->exception);
                 $this->exception = null;
                 continue;
             }
             $value = $gen->current();
             //                Logger::write(__METHOD__ . " value === " . var_export($value, true), Logger::INFO);
             /* 中断内嵌 继续入栈 */
             if ($value instanceof \Generator) {
                 $this->corStack->push($gen);
                 //                    Logger::write(__METHOD__ . " corStack push ", Logger::INFO);
                 $gen = $value;
                 continue;
             }
             /* if value is null and stack is not empty pop and send continue */
             if (is_null($value) && !$this->corStack->isEmpty()) {
                 //                    Logger::write(__METHOD__ . " values is null stack pop and send ", Logger::INFO);
                 $gen = $this->corStack->pop();
                 $gen->send($this->callbackData);
                 continue;
             }
             if ($value instanceof ReturnValue) {
                 $gen = $this->corStack->pop();
                 $gen->send($value->getValue());
                 // end yeild
                 //                    Logger::write(__METHOD__ . " yield end words == " . var_export($value, true), Logger::INFO);
                 continue;
             }
             /* 中断内容为异步IO 发包 返回 */
             if ($value instanceof \Swoole\Client\IBase) {
                 //async send push gen to stack
                 $this->corStack->push($gen);
                 $value->send(array($this, 'callback'));
                 return;
             }
             /* 出栈，回射数据 */
             if ($this->corStack->isEmpty()) {
                 return;
             }
             //                Logger::write(__METHOD__ . " corStack pop ", Logger::INFO);
             $gen = $this->corStack->pop();
             $gen->send($value);
         } catch (EasyWorkException $e) {
             if ($this->corStack->isEmpty()) {
                 throw $e;
             }
             $gen = $this->corStack->pop();
             $this->exception = $e;
         }
     }
 }

 /**
  * @param \Generator $generator
  */
 public function __construct(Generator $generator)
 {
     parent::__construct();
     $this->generator = $generator;
     /**
      * @param mixed $value The value to send to the generator.
      */
     $this->send = function ($value = null) {
         if ($this->busy) {
             Loop\queue($this->send, $value);
             // Queue continuation to avoid blowing up call stack.
             return;
         }
         try {
             // Send the new value and execute to next yield statement.
             $this->next($this->generator->send($value));
         } catch (Throwable $exception) {
             $this->reject($exception);
         }
     };
     /**
      * @param \Throwable $exception Exception to be thrown into the generator.
      */
     $this->capture = function (Throwable $exception) {
         if ($this->busy) {
             Loop\queue($this->capture, $exception);
             // Queue continuation to avoid blowing up call stack.
             return;
         }
         try {
             // Throw exception at current execution point.
             $this->next($this->generator->throw($exception));
         } catch (Throwable $exception) {
             $this->reject($exception);
         }
     };
     try {
         $this->next($this->generator->current());
     } catch (Throwable $exception) {
         $this->reject($exception);
     }
 }

 /**
  * Throw exception into generator.
  * @param \Throwable|\Exception $e
  * @NOTE: This method returns nothing,
  *        while original generator returns something.
  */
 public function throw_($e)
 {
     $this->validateValidity();
     try {
         $this->g->throw($e);
         return;
     } catch (\Throwable $e) {
     } catch (\Exception $e) {
     }
     $this->e = $e;
 }

 /**
  * @param \Generator $generator
  */
 public function __construct(Generator $generator)
 {
     parent::__construct();
     $this->generator = $generator;
     /**
      * @param mixed $value The value to send to the generator.
      */
     $this->send = function ($value = null) {
         if (null === $this->generator) {
             // Coroutine may have been cancelled.
             return;
         }
         try {
             // Send the new value and execute to next yield statement.
             $this->next($this->generator->send($value));
         } catch (Throwable $exception) {
             $this->reject($exception);
         }
     };
     /**
      * @param \Throwable $exception Exception to be thrown into the generator.
      */
     $this->capture = function (Throwable $exception) {
         if (null === $this->generator) {
             // Coroutine may have been cancelled.
             return;
         }
         try {
             // Throw exception at current execution point.
             $this->next($this->generator->throw($exception));
         } catch (Throwable $exception) {
             $this->reject($exception);
         }
     };
     try {
         $this->next($this->generator->current());
     } catch (Throwable $exception) {
         $this->reject($exception);
     }
 }

 /**
  * run coroutine
  * @return mixed
  */
 public function run()
 {
     if ($this->first_run) {
         $this->first_run = false;
         return $this->coroutine->current();
     }
     if ($this->exception instanceof \Exception) {
         $retval = $this->coroutine->throw($this->exception);
         $this->exception = null;
         return $retval;
     }
     $retval = $this->coroutine->send($this->send_value);
     $this->send_value = null;
     return $retval;
 }

function stackedCoroutine(Generator $gen)
{
    $stack = new SplStack();
    $exception = null;
    for (;;) {
        try {
            if ($exception) {
                $gen->throw($exception);
                $exception = null;
                continue;
            }
            $value = $gen->current();
            if ($value instanceof Generator) {
                $stack->push($gen);
                $gen = $value;
                continue;
            }
            $isReturnValue = $value instanceof CoroutineReturnValue;
            if (!$gen->valid() || $isReturnValue) {
                if ($stack->isEmpty()) {
                    return;
                }
                $gen = $stack->pop();
                $gen->send($isReturnValue ? $value->getValue() : NULL);
                continue;
            }
            if ($value instanceof CoroutinePlainValue) {
                $value = $value->getValue();
            }
            try {
                $sendValue = (yield $gen->key() => $value);
            } catch (Exception $e) {
                $gen->throw($e);
                continue;
            }
            $gen->send($sendValue);
        } catch (Exception $e) {
            if ($stack->isEmpty()) {
                throw $e;
            }
            $gen = $stack->pop();
            $exception = $e;
        }
    }
}

 /**
  * Runs the generator to completion then fails the coroutine with the given exception.
  *
  * @param \Throwable $exception
  */
 private function dispose(\Throwable $exception)
 {
     if ($this->generator->valid()) {
         try {
             try {
                 // Ensure generator has run to completion to avoid throws from finally blocks on destruction.
                 do {
                     $this->generator->throw($exception);
                 } while ($this->generator->valid());
             } finally {
                 // Throw from finally to attach any exception thrown from generator as previous exception.
                 throw $exception;
             }
         } catch (\Throwable $exception) {
             // $exception will be used to fail the coroutine.
         }
     }
     $this->fail($exception);
 }

 /**
  * {@inheritdoc}
  */
 public function cancel(Throwable $reason = null)
 {
     if (null === $reason) {
         $reason = new TerminatedException();
     }
     if (null !== $this->generator) {
         try {
             do {
                 if ($this->current instanceof Awaitable) {
                     $this->current->cancel($reason);
                 }
                 $this->current = $this->generator->throw($reason);
             } while ($this->generator->valid());
         } catch (Throwable $exception) {
             $reason = $exception;
         }
     }
     parent::cancel($reason);
 }

 /**
  * @brief 协程堆栈调度
  * @return type
  */
 public function run(\Generator $generator)
 {
     for (;;) {
         try {
             //异常处理
             if (null !== $this->_exception) {
                 $generator->throw($this->_exception);
                 $this->_exception = null;
                 continue;
             }
             //协程堆栈链的下一个元素
             $current = $generator->current();
             //协程堆栈链表的中断内嵌
             if ($current instanceof \Generator) {
                 $this->_coroutineStack->push($generator);
                 $generator = $current;
                 continue;
             }
             //syscall中断
             if ($current instanceof \Aha\Coroutine\SystemCall) {
                 return $current;
             }
             //retval中断
             $isReturnValue = $current instanceof \Aha\Coroutine\RetVal;
             if (!$generator->valid() || $isReturnValue) {
                 if ($this->_coroutineStack->isEmpty()) {
                     return;
                 }
                 $generator = $this->_coroutineStack->pop();
                 $generator->send($isReturnValue ? $current->getvalue() : $this->_sendValue);
                 $this->_sendValue = null;
             }
             //异步网络IO中断
             if ($this->_ahaInterrupt($current)) {
                 $this->_coroutineStack->push($generator);
                 return;
             }
             //当前协程堆栈元素可能有多次yeild 但是与父协程只有一次通信的机会 在通信前运行完
             $generator->send(is_null($current) ? $this->_sendValue : $current);
             $this->_sendValue = null;
             while ($generator->valid()) {
                 $current = $generator->current();
                 $generator->send(is_null($current) ? $this->_sendValue : $current);
                 $this->_sendValue = null;
             }
             //协程栈是空的 已经调度完毕
             if ($this->_coroutineStack->isEmpty()) {
                 return;
             }
             //把当前结果传给父协程栈
             $generator = $this->_coroutineStack->pop();
             $data = is_null($current) ? $this->_sendValue : $current;
             $this->_sendValue = null;
             $generator->send($data);
         } catch (\Exception $ex) {
             echo "[Coroutine_Task_Run_Exception]" . $ex->getMessage() . PHP_EOL;
             if ($this->_coroutineStack->isEmpty()) {
                 return;
             }
         }
     }
 }

 /**
  * @param \Generator $generator
  */
 public function __construct(Generator $generator)
 {
     $this->generator = $generator;
     parent::__construct(function (callable $resolve, callable $reject) {
         /**
          * @param mixed $value The value to send to the generator.
          * @param \Throwable|null $exception Exception object to be thrown into the generator if not null.
          */
         $this->worker = function ($value = null, Throwable $exception = null) use($resolve, $reject) {
             if ($this->paused) {
                 // If paused, mark coroutine as ready to resume.
                 $this->ready = true;
                 return;
             }
             try {
                 if ($this->initial) {
                     // Get result of first yield statement.
                     $this->initial = false;
                     $this->current = $this->generator->current();
                 } elseif (null !== $exception) {
                     // Throw exception at current execution point.
                     $this->current = $this->generator->throw($exception);
                 } else {
                     // Send the new value and execute to next yield statement.
                     $this->current = $this->generator->send($value);
                 }
                 if (!$this->generator->valid()) {
                     $resolve($this->generator->getReturn());
                     $this->close();
                     return;
                 }
                 if ($this->current instanceof Generator) {
                     $this->current = new self($this->current);
                 }
                 if ($this->current instanceof PromiseInterface) {
                     $this->current->done($this->worker, $this->capture);
                 } else {
                     Loop\queue($this->worker, $this->current);
                 }
             } catch (Throwable $exception) {
                 $reject($exception);
                 $this->close();
             }
         };
         /**
          * @param \Throwable $exception Exception to be thrown into the generator.
          */
         $this->capture = function (Throwable $exception) {
             if (null !== $this->worker) {
                 // Coroutine may have been closed.
                 ($this->worker)(null, $exception);
             }
         };
         Loop\queue($this->worker);
         return function (Throwable $exception) {
             try {
                 $current = $this->generator->current();
                 // Get last yielded value.
                 while ($this->generator->valid()) {
                     if ($current instanceof PromiseInterface) {
                         $current->cancel($exception);
                     }
                     $current = $this->generator->throw($exception);
                 }
             } finally {
                 $this->close();
             }
         };
     });
 }

 public function __call($method, $args)
 {
     if ($method === 'throw') {
         if (!$this->generator) {
             $this->rewind();
         }
         return $this->generator->throw(...$args);
     } else {
         // trigger normal undefined method error
         return $this->{$method}(...$args);
     }
 }

 /**
  * [run 协程调度]
  * @param  Generator $gen [description]
  * @return [type]         [description]
  */
 public function run(\Generator $gen)
 {
     while (true) {
         try {
             /*
                异常处理
             */
             if ($this->exception) {
                 $gen->throw($this->exception);
                 $this->exception = null;
                 continue;
             }
             $value = $gen->current();
             \SysLog::info(__METHOD__ . " value === " . print_r($value, true), __CLASS__);
             /*
                中断内嵌 继续入栈
             */
             if ($value instanceof \Generator) {
                 $this->corStack->push($gen);
                 \SysLog::info(__METHOD__ . " corStack push ", __CLASS__);
                 $gen = $value;
                 continue;
             }
             /*
                if value is null and stack is not empty pop and send continue
             */
             if (is_null($value) && !$this->corStack->isEmpty()) {
                 \SysLog::info(__METHOD__ . " values is null stack pop and send", __CLASS__);
                 $gen = $this->corStack->pop();
                 $gen->send($this->callbackData);
                 continue;
             }
             if ($value instanceof Swoole\Coroutine\RetVal) {
                 // end yeild
                 \SysLog::info(__METHOD__ . " yield end words == " . print_r($value, true), __CLASS__);
                 return false;
             }
             /*
                中断内容为异步IO 发包 返回
             */
             if (is_subclass_of($value, 'Swoole\\Client\\Base')) {
                 //async send push gen to stack
                 $this->corStack->push($gen);
                 $value->send(array($this, 'callback'));
                 return;
             }
             /*
                出栈，回射数据
             */
             if ($this->corStack->isEmpty()) {
                 return;
             }
             \SysLog::info(__METHOD__ . " corStack pop ", __CLASS__);
             $gen = $this->corStack->pop();
             $gen->send($value);
         } catch (\Exception $e) {
             if ($this->corStack->isEmpty()) {
                 /*
                     throw the exception 
                 */
                 \SysLog::error(__METHOD__ . " exception ===" . $e->getMessage(), __CLASS__);
                 return;
             }
         }
     }
 }

function stackedCoroutine(Generator $gen)
{
    $stack = new SplStack();
    echo "stack------\n";
    $i = 0;
    $exception = null;
    for (;;) {
        try {
            $i++;
            echo "i:::{$i}\n";
            if ($exception) {
                echo "stack exception \n ";
                var_dump($exception);
                $gen->throw($exception);
                $exception = null;
                continue;
            }
            $value = $gen->current();
            echo "stacked current  value:\n";
            var_dump($value);
            if ($value instanceof Generator) {
                echo "stacked is generator\n";
                $stack->push($gen);
                $gen = $value;
                continue;
            }
            $isReturnValue = $value instanceof CoroutineReturnValue;
            if (!$gen->valid() || $isReturnValue) {
                echo "stack empty\n";
                if ($stack->isEmpty()) {
                    return;
                }
                echo "stacked pop\n";
                var_dump($isReturnValue);
                $gen = $stack->pop();
                var_dump($gen);
                $gen->send($isReturnValue ? $value->getValue() : NULL);
                continue;
            }
            echo "stacked before end\n";
            //$gen->send("stack send 1");
            //  yield ;
            try {
                $s = (yield $gen->key() => $value);
                echo "stacked before end -----{$s}\n";
            } catch (Exception $e) {
                echo "stack sendvalue exception\n";
                var_dump($e);
                $gen->throw($e);
                continue;
            }
            $re = $gen->send($s);
            var_dump("stack:");
            var_dump($re);
            echo "stacked  end\n";
        } catch (Exception $e) {
            echo "stack exception last\n";
            var_dump($e);
            if ($stack->isEmpty()) {
                throw $e;
            }
            $gen = $stask->pop();
            $exception = $e;
        }
    }
}

 /**
  * @param \Generator $generator
  */
 public function __construct(Generator $generator)
 {
     $this->generator = $generator;
     parent::__construct(function (callable $resolve, callable $reject) {
         $yielded = $this->generator->current();
         if (!$this->generator->valid()) {
             $resolve($this->generator->getReturn());
             $this->close();
             return;
         }
         /**
          * @param mixed $value The value to send to the generator.
          */
         $this->send = function ($value = null) use($resolve, $reject) {
             if ($this->paused) {
                 // If paused, save callable and value for resuming.
                 $this->next = [$this->send, $value];
                 return;
             }
             try {
                 // Send the new value and execute to next yield statement.
                 $yielded = $this->generator->send($value);
                 if (!$this->generator->valid()) {
                     $resolve($this->generator->getReturn());
                     $this->close();
                     return;
                 }
                 $this->next($yielded);
             } catch (Throwable $exception) {
                 $reject($exception);
                 $this->close();
             }
         };
         /**
          * @param \Throwable $exception Exception to be thrown into the generator.
          */
         $this->capture = function (Throwable $exception) use($resolve, $reject) {
             if ($this->paused) {
                 // If paused, save callable and exception for resuming.
                 $this->next = [$this->capture, $exception];
                 return;
             }
             try {
                 // Throw exception at current execution point.
                 $yielded = $this->generator->throw($exception);
                 if (!$this->generator->valid()) {
                     $resolve($this->generator->getReturn());
                     $this->close();
                     return;
                 }
                 $this->next($yielded);
             } catch (Throwable $exception) {
                 $reject($exception);
                 $this->close();
             }
         };
         $this->next($yielded);
         return function (Throwable $exception) {
             try {
                 $current = $this->generator->current();
                 // Get last yielded value.
                 if ($current instanceof PromiseInterface) {
                     $current->cancel($exception);
                 }
             } finally {
                 $this->close();
             }
         };
     });
 }