git.m6w6.name Git - m6w6/seekat/blob - lib/API/Future/functions.php

   1 <?php
   2
   3 namespace seekat\API\Future;
   4
   5 use Amp\Deferred as AmpDeferred;
   6 use Amp\Promise as AmpPromise;
   7 use React\Promise\Deferred as ReactDeferred;
   8 use React\Promise\PromiseInterface as ReactPromise;
   9 use seekat\API\Future;
  10
  11 /**
  12  * @param Future $future
  13  * @param mixed $value
  14  * @return mixed promise
  15  */
  16 function resolve(Future $future, $value) {
  17         $promisor = $future->createContext();
  18         $future->resolve($promisor, $value);
  19         return $future->getPromise($promisor);
  20 }
  21
  22 /**
  23  * @param Future $future
  24  * @param mixed $reason
  25  * @return mixed promise
  26  */
  27 function reject(Future $future, $reason) {
  28         $promisor = $future->createContext();
  29         $future->reject($promisor, $reason);
  30         return $future->getPromise($promisor);
  31 }
  32
  33 /**
  34  * @param Future $future
  35  * @param mixed $context Promisor
  36  * @return \Closure
  37  */
  38 function resolver(Future $future, $context) {
  39         return function($value) use($future, $context) {
  40                 return $future->resolve($context, $value);
  41         };
  42 }
  43
  44 /**
  45  * @param Future $future
  46  * @param mixed $context Promisor
  47  * @return \Closure
  48  */
  49 function rejecter(Future $future, $context) {
  50         return function($reason) use($future, $context) {
  51                 return $future->reject($context, $reason);
  52         };
  53 }
  54
  55 /**
  56  * @param Future $future
  57  * @param mixed $context Promisor
  58  * @return \Closure
  59  */
  60 function reducer(Future $future, $context) {
  61         return function(array $promises) use($future, $context) {
  62                 return $future->all($context, $promises);
  63         };
  64 }
  65
  66 /**
  67  * @return Future
  68  */
  69 function react() {
  70         return new class implements Future {
  71                 /**
  72                  * @param callable|null $onCancel
  73                  * @return ReactDeferred
  74                  */
  75                 function createContext(callable $onCancel = null) {
  76                         return new ReactDeferred($onCancel);
  77                 }
  78
  79                 function getPromise($context) {
  80                         /* @var $context ReactDeferred */
  81                         return $context->promise();
  82                 }
  83
  84                 function isPromise($promise) : bool {
  85                         return $promise instanceof ReactPromise;
  86                 }
  87
  88                 function handlePromise($promise, callable $onResult = null, callable $onError = null) {
  89                         return $promise->then($onResult, $onError);
  90                 }
  91
  92                 function cancelPromise($promise) : bool {
  93                         /* @var $promise \React\Promise\Promise */
  94                         $promise->cancel();
  95                         return true;
  96                 }
  97
  98                 function resolve($context, $value) {
  99                         /* @var $context ReactDeferred */
 100                         $context->resolve($value);
 101                 }
 102
 103                 function reject($context, $reason) {
 104                         /* @var $context ReactDeferred */
 105                         $context->reject($reason);
 106                 }
 107
 108                 function all($context, array $promises) {
 109                         return \React\Promise\all($promises);
 110                 }
 111         };
 112 }
 113
 114 /**
 115  * @return Future
 116  */
 117 function amp() {
 118         return new class implements Future {
 119                 /**
 120                  * @return AmpDeferred
 121                  */
 122                 function createContext(callable $onCancel = null) {
 123                         return new AmpDeferred();
 124                 }
 125
 126                 function getPromise($context) {
 127                         /* @var $context AmpDeferred */
 128                         return $context->promise();
 129                 }
 130
 131                 function isPromise($promise) : bool {
 132                         return $promise instanceof AmpPromise;
 133                 }
 134
 135                 function handlePromise($promise, callable $onResult = null, callable $onError = null) {
 136                         $promise->onResolve(function($error = null, $result = null) use($onResult, $onError) {
 137                                 if ($error) {
 138                                         if ($onError) {
 139                                                 $onError($error);
 140                                         }
 141                                 } else {
 142                                         if ($onResult) {
 143                                                 $onResult($result);
 144                                         }
 145                                 }
 146                         });
 147                         return $promise;
 148                 }
 149
 150                 function cancelPromise($promise) : bool {
 151                         return false;
 152                 }
 153
 154                 function resolve($context, $value) {
 155                         /* @var $context AmpDeferred */
 156                         $context->resolve($value);
 157                 }
 158
 159                 function reject($context, $reason) {
 160                         /* @var $context AmpDeferred */
 161                         $context->fail(\seekat\Exception\exception($reason));
 162                 }
 163
 164                 function all($context, array $promises) {
 165                         return \Amp\all($promises);
 166                 }
 167         };
 168 }