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 AsyncInterop\Promise;
   7 use Icicle\Awaitable\Deferred as IcicleDeferred;
   8 use React\Promise\Deferred as ReactDeferred;
   9 use seekat\API\Future;
  10
  11 /**
  12  * @param Future $future
  13  * @param mixed $value
  14  * @return Promise
  15  */
  16 function resolve(Future $future, $value) {
  17         $promisor = $future->createContext();
  18         $future->onSuccess($promisor, $value);
  19         return $future->getPromise($promisor);
  20 }
  21
  22 /**
  23  * @param Future $future
  24  * @param mixed $reason
  25  * @return Promise
  26  */
  27 function reject(Future $future, $reason) {
  28         $promisor = $future->createContext();
  29         $future->onFailure($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->onSuccess($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->onFailure($context, $reason);
  52         };
  53 }
  54
  55 /**
  56  * @param Future $future
  57  * @param mixed $context Promisor
  58  * @return \Closure
  59  */
  60 function updater(Future $future, $context) {
  61         return function($update) use($future, $context) {
  62                 return $future->onUpdate($context, $update);
  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) : Promise {
  80                         /* @var $context ReactDeferred */
  81                         return $context->promise();
  82                 }
  83
  84                 function onSuccess($context, $value) {
  85                         /* @var $context ReactDeferred */
  86                         $context->resolve($value);
  87                 }
  88
  89                 function onFailure($context, $reason) {
  90                         /* @var $context ReactDeferred */
  91                         $context->reject($reason);
  92                 }
  93
  94                 function onUpdate($context, $update) {
  95                         /* @var $context ReactDeferred */
  96                         $context->notify($update);
  97                 }
  98         };
  99 }
 100
 101 /**
 102  * @return Future
 103  */
 104 function amp() {
 105         return new class implements Future {
 106                 /**
 107                  * @return AmpDeferred
 108                  */
 109                 function createContext(callable $onCancel = null) {
 110                         return new AmpDeferred();
 111                 }
 112
 113                 function getPromise($context) : Promise {
 114                         /* @var $context AmpDeferred */
 115                         return $context->promise();
 116                 }
 117
 118                 function onSuccess($context, $value) {
 119                         /* @var $context AmpDeferred */
 120                         $context->resolve($value);
 121                 }
 122
 123                 function onFailure($context, $reason) {
 124                         /* @var $context AmpDeferred */
 125                         $context->fail($reason);
 126                 }
 127
 128                 function onUpdate($context, $update) {
 129                         /* @var $context AmpDeferred */
 130                         /* noop */
 131                 }
 132         };
 133 }
 134
 135 /**
 136  * @return Future
 137  */
 138 function icicle() {
 139         return new class implements Future {
 140                 /**
 141                  * @param callable|null $onCancel
 142                  * @return IcicleDeferred
 143                  */
 144                 function createContext(callable $onCancel = null) {
 145                         return new IcicleDeferred($onCancel);
 146                 }
 147
 148                 function getPromise($context): Promise {
 149                         /* @var $context IcicleDeferred */
 150                         return $context->getPromise();
 151                 }
 152
 153                 function onSuccess($context, $value) {
 154                         /* @var $context IcicleDeferred */
 155                         $context->resolve($value);
 156                 }
 157
 158                 function onFailure($context, $reason) {
 159                         /* @var $context IcicleDeferred */
 160                         $context->reject($reason);
 161                 }
 162
 163                 function onUpdate($context, $update) {
 164                         /* @var $context IcicleDeferred */
 165                         /* noop */
 166                 }
 167         };
 168 }