Example #1
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $hasValue = false;
     $hasAccumulation = false;
     $accumulation = $this->seed;
     $hasSeed = $this->seed !== null;
     return $observable->subscribe(new CallbackObserver(function ($x) use($observer, &$hasAccumulation, &$accumulation, &$hasSeed, &$hasValue) {
         $hasValue = true;
         if ($hasAccumulation) {
             $accumulation = call_user_func($this->tryCatch($this->accumulator), $accumulation, $x);
         } else {
             $accumulation = $hasSeed ? call_user_func($this->tryCatch($this->accumulator), $this->seed, $x) : $x;
             $hasAccumulation = true;
         }
         if ($accumulation instanceof \Exception) {
             $observer->onError($accumulation);
             return;
         }
         $observer->onNext($accumulation);
     }, function ($e) use($observer) {
         $observer->onError($e);
     }, function () use($observer, &$hasValue, &$hasSeed) {
         if (!$hasValue && $hasSeed) {
             $observer->onNext($this->seed);
         }
         $observer->onCompleted();
     }));
 }
Example #2
0
 /**
  * @param \Rx\ObservableInterface $observable
  * @param \Rx\ObserverInterface $observer
  * @param \Rx\SchedulerInterface $scheduler
  * @return \Rx\DisposableInterface
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $hasAccumulation = false;
     $accumulation = null;
     $hasValue = false;
     $cbObserver = new CallbackObserver(function ($x) use($observer, &$hasAccumulation, &$accumulation, &$hasValue) {
         $hasValue = true;
         try {
             if ($hasAccumulation) {
                 $accumulation = call_user_func($this->accumulator, $accumulation, $x);
             } else {
                 $accumulation = $this->hasSeed ? call_user_func($this->accumulator, $this->seed, $x) : $x;
                 $hasAccumulation = true;
             }
         } catch (\Exception $e) {
             $observer->onError($e);
         }
     }, function ($e) use($observer) {
         $observer->onError($e);
     }, function () use($observer, &$hasAccumulation, &$accumulation, &$hasValue) {
         if ($hasValue) {
             $observer->onNext($accumulation);
         } else {
             $this->hasSeed && $observer->onNext($this->seed);
         }
         if (!$hasValue && !$this->hasSeed) {
             $observer->onError(new \Exception("Missing Seed and or Value"));
         }
         $observer->onCompleted();
     });
     return $observable->subscribe($cbObserver, $scheduler);
 }
Example #3
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $previousMax = null;
     $comparing = false;
     return $observable->subscribe(new CallbackObserver(function ($x) use(&$comparing, &$previousMax, $observer) {
         if (!$comparing) {
             $comparing = true;
             $previousMax = $x;
             return;
         }
         try {
             $result = call_user_func($this->comparer, $x, $previousMax);
             if ($result > 0) {
                 $previousMax = $x;
             }
         } catch (\Exception $e) {
             $observer->onError($e);
         }
     }, [$observer, 'onError'], function () use(&$comparing, &$previousMax, $observer) {
         if ($comparing) {
             $observer->onNext($previousMax);
             $observer->onCompleted();
             return;
         }
         $observer->onError(new \Exception("Empty"));
     }), $scheduler);
 }
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $hasCurrentKey = false;
     $currentKey = null;
     return $observable->subscribe(new CallbackObserver(function ($value) use($observer, &$hasCurrentKey, &$currentKey) {
         $key = $value;
         if ($this->keySelector) {
             try {
                 $key = call_user_func($this->keySelector, $value);
             } catch (\Exception $e) {
                 return $observer->onError($e);
             }
         }
         $comparerEquals = null;
         if ($hasCurrentKey) {
             try {
                 $comparerEquals = call_user_func($this->comparer, $currentKey, $key);
             } catch (\Exception $e) {
                 return $observer->onError($e);
             }
         }
         if (!$hasCurrentKey || !$comparerEquals) {
             $hasCurrentKey = true;
             $currentKey = $key;
             $observer->onNext($value);
         }
     }, function ($e) use($observer) {
         $observer->onError($e);
     }, function () use($observer) {
         $observer->onCompleted();
     }));
 }
Example #5
0
 /**
  * @param \Rx\ObservableInterface $observable
  * @param \Rx\ObserverInterface $observer
  * @param \Rx\SchedulerInterface $scheduler
  * @return \Rx\DisposableInterface
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $cbObserver = new CallbackObserver(function ($x) use($observer) {
         try {
             $this->onEachObserver->onNext($x);
         } catch (\Exception $e) {
             return $observer->onError($e);
         }
         $observer->onNext($x);
     }, function ($err) use($observer) {
         try {
             $this->onEachObserver->onError($err);
         } catch (\Exception $e) {
             return $observer->onError($e);
         }
         $observer->onError($err);
     }, function () use($observer) {
         try {
             $this->onEachObserver->onCompleted();
         } catch (\Exception $e) {
             return $observer->onError($e);
         }
         $observer->onCompleted();
     });
     return $observable->subscribe($cbObserver, $scheduler);
 }
Example #6
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $isOpen = false;
     /** @var DisposableInterface $otherDisposable */
     $otherDisposable = $this->other->subscribe(new CallbackObserver(function ($x) use(&$isOpen, &$otherDisposable) {
         $isOpen = true;
         $otherDisposable->dispose();
     }, function ($e) use($observer) {
         $observer->onError($e);
     }, function () use(&$otherDisposable) {
         $otherDisposable->dispose();
     }));
     $sourceDisposable = $observable->subscribe(new CallbackObserver(function ($x) use($observer, &$isOpen) {
         if ($isOpen) {
             $observer->onNext($x);
         }
     }, function ($e) use($observer) {
         $observer->onError($e);
     }, function () use($observer, &$isOpen) {
         if ($isOpen) {
             $observer->onCompleted();
         }
     }));
     return new CompositeDisposable([$otherDisposable, $sourceDisposable]);
 }
Example #7
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     array_unshift($this->sources, $observable);
     $this->numberOfSources = count($this->sources);
     $disposable = new CompositeDisposable();
     $this->completesRemaining = $this->numberOfSources;
     for ($i = 0; $i < $this->numberOfSources; $i++) {
         $this->queues[$i] = new \SplQueue();
         $this->completed[$i] = false;
     }
     for ($i = 0; $i < $this->numberOfSources; $i++) {
         $source = $this->sources[$i];
         $cbObserver = new CallbackObserver(function ($x) use($i, $observer, $scheduler) {
             // if there is another item in the sequence after one of the other source
             // observables completes, we need to complete at this time to match the
             // behavior of RxJS
             if ($this->completesRemaining < $this->numberOfSources) {
                 // check for completed and empty queues
                 for ($j = 0; $j < $this->numberOfSources; $j++) {
                     if ($this->completed[$j] && count($this->queues[$j]) === 0) {
                         $observer->onCompleted();
                         return;
                     }
                 }
             }
             $this->queues[$i]->enqueue($x);
             for ($j = 0; $j < $this->numberOfSources; $j++) {
                 if ($this->queues[$j]->isEmpty()) {
                     return;
                 }
             }
             $params = [];
             for ($j = 0; $j < $this->numberOfSources; $j++) {
                 $params[] = $this->queues[$j]->dequeue();
             }
             try {
                 $observer->onNext(call_user_func_array($this->resultSelector, $params));
             } catch (\Exception $e) {
                 $observer->onError($e);
             }
         }, function ($e) use($observer) {
             $observer->onError($e);
         }, function () use($i, $observer) {
             $this->completesRemaining--;
             $this->completed[$i] = true;
             if ($this->completesRemaining === 0) {
                 $observer->onCompleted();
             }
         });
         $subscription = $source->subscribe($cbObserver, $scheduler);
         $disposable->add($subscription);
     }
     return $disposable;
 }
Example #8
0
 /**
  * @param ObserverInterface $observer
  * @param SchedulerInterface|null $scheduler
  * @return \Rx\Disposable\CompositeDisposable|\Rx\DisposableInterface
  */
 public function subscribe(ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $scheduler = $scheduler ?: new ImmediateScheduler();
     $buffer = '';
     $request = $this->client->request($this->method, $this->url, $this->headers, $this->protocolVersion);
     $request->on('response', function (Response $response) use(&$buffer, $observer, $request, $scheduler) {
         $response->on('data', function ($data, Response $response) use(&$buffer, $observer, $request, $scheduler) {
             try {
                 //Http Errors
                 if ($response->getCode() < 200 || $response->getCode() >= 400) {
                     $error = new HttpResponseException($request, $response, $response->getReasonPhrase(), $response->getCode());
                     $observer->onError($error);
                     return;
                 }
                 if ($this->bufferResults) {
                     $buffer .= $data;
                 } else {
                     $data = $this->includeResponse ? [$data, $response, $request] : $data;
                     $scheduler->schedule(function () use($observer, $data) {
                         $observer->onNext($data);
                     });
                 }
             } catch (\Exception $e) {
                 $observer->onError($e);
             }
         });
         $response->on('error', function ($e) use($observer) {
             $error = new \Exception($e);
             $observer->onError($error);
         });
         $response->on('end', function ($end = null) use(&$buffer, $observer, $request, $response, $scheduler) {
             if ($this->bufferResults) {
                 $data = $this->includeResponse ? [$buffer, $response, $request] : $buffer;
                 $scheduler->schedule(function () use($observer, $data, $scheduler) {
                     $observer->onNext($data);
                     $scheduler->schedule(function () use($observer) {
                         $observer->onCompleted();
                     });
                 });
                 return;
             }
             $scheduler->schedule(function () use($observer) {
                 $observer->onCompleted();
             });
         });
     });
     $request->end($this->body);
     return new CallbackDisposable(function () use($request) {
         $request->close();
     });
 }
Example #9
0
 /**
  * @param ObserverInterface $observer
  * @param SchedulerInterface|null $scheduler
  * @return \Rx\Disposable\CompositeDisposable|\Rx\DisposableInterface
  */
 public function subscribe(ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $scheduler = $scheduler ?: new ImmediateScheduler();
     $key = 0;
     return $scheduler->scheduleRecursive(function ($reschedule) use(&$observer, &$key) {
         try {
             //HHVM requires you to call next() before current()
             if (defined('HHVM_VERSION')) {
                 $this->items->next();
                 $key = $this->items->key();
             }
             if (null === $key) {
                 $observer->onCompleted();
                 return;
             }
             $current = $this->items->current();
             $observer->onNext($current);
             if (!defined('HHVM_VERSION')) {
                 $this->items->next();
                 $key = $this->items->key();
             }
             $reschedule();
         } catch (\Exception $e) {
             $observer->onError($e);
         }
     });
 }
Example #10
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     if ($this->scheduler !== null) {
         $scheduler = $this->scheduler;
     }
     if ($scheduler === null) {
         throw new \Exception("You must use a scheduler that support non-zero delay.");
     }
     $lastScheduledTime = 0;
     $disposable = new CompositeDisposable();
     $sourceDisposable = new EmptyDisposable();
     $sourceDisposable = $observable->subscribe(new CallbackObserver(function ($x) use($scheduler, $observer, &$lastScheduledTime, $disposable) {
         $schedDisp = $scheduler->schedule(function () use($x, $observer, &$schedDisp, $disposable) {
             $observer->onNext($x);
             $disposable->remove($schedDisp);
         }, $this->delay);
         $disposable->add($schedDisp);
     }, function ($err) use($scheduler, $observer, &$lastScheduledTime, $disposable, &$sourceDisposable) {
         $disposable->remove($sourceDisposable);
         $sourceDisposable->dispose();
         $observer->onError($err);
     }, function () use($scheduler, $observer, $disposable, &$sourceDisposable) {
         $disposable->remove($sourceDisposable);
         $sourceDisposable->dispose();
         $schedDisp = $scheduler->schedule(function () use($observer, &$schedDisp, $disposable) {
             $observer->onCompleted();
             $disposable->remove($schedDisp);
         }, $this->delay);
         $disposable->add($schedDisp);
     }), $scheduler);
     $disposable->add($sourceDisposable);
     return $disposable;
 }
Example #11
0
 /**
  * @param \Rx\ObservableInterface $observable
  * @param \Rx\ObserverInterface $observer
  * @param \Rx\SchedulerInterface $scheduler
  * @return \Rx\DisposableInterface
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $group = new CompositeDisposable();
     $isStopped = false;
     $sourceSubscription = new SingleAssignmentDisposable();
     $group->add($sourceSubscription);
     $callbackObserver = new CallbackObserver(function (ObservableInterface $innerSource) use(&$group, &$isStopped, $observer, &$scheduler) {
         $innerSubscription = new SingleAssignmentDisposable();
         $group->add($innerSubscription);
         $innerSubscription->setDisposable($innerSource->subscribe(new CallbackObserver(function ($nextValue) use($observer) {
             $observer->onNext($nextValue);
         }, function ($error) use($observer) {
             $observer->onError($error);
         }, function () use(&$group, &$innerSubscription, &$isStopped, $observer) {
             $group->remove($innerSubscription);
             if ($isStopped && $group->count() === 1) {
                 $observer->onCompleted();
             }
         }), $scheduler));
     }, [$observer, 'onError'], function () use(&$group, &$isStopped, $observer) {
         $isStopped = true;
         if ($group->count() === 1) {
             $observer->onCompleted();
         }
     });
     $subscription = $this->sources->subscribe($callbackObserver, $scheduler);
     $sourceSubscription->setDisposable($subscription);
     return $group;
 }
Example #12
0
 public function subscribe(ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $scheduler = $scheduler ?: new ImmediateScheduler();
     return $scheduler->schedule(function () use($observer) {
         $observer->onError($this->error);
     });
 }
Example #13
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $onNext = function ($innerSource) use($observer, $scheduler) {
         $innerDisposable = new SingleAssignmentDisposable();
         $id = ++$this->latest;
         $this->hasLatest = true;
         $this->innerSubscription->setDisposable($innerDisposable);
         $innerCallbackObserver = new CallbackObserver(function ($x) use($id, $observer) {
             if ($this->latest === $id) {
                 $observer->onNext($x);
             }
         }, function ($e) use($id, $observer) {
             if ($this->latest === $id) {
                 $observer->onError($e);
             }
         }, function () use($id, $observer) {
             if ($this->latest === $id) {
                 $this->hasLatest = false;
                 if ($this->isStopped) {
                     $observer->onCompleted();
                 }
             }
         });
         $innerSubscription = $innerSource->subscribe($innerCallbackObserver, $scheduler);
         $innerDisposable->setDisposable($innerSubscription);
     };
     $callbackObserver = new CallbackObserver($onNext, [$observer, 'onError'], function () use($observer) {
         $this->isStopped = true;
         if (!$this->hasLatest) {
             $observer->onCompleted();
         }
     });
     $subscription = $observable->subscribe($callbackObserver, $scheduler);
     return new BinaryDisposable($subscription, $this->innerSubscription);
 }
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     return $observable->subscribe(new CallbackObserver(function ($data) use($observer) {
         while (strlen($data) > 0) {
             $frame = $this->frame;
             $frame->addBuffer($data);
             $data = "";
             if ($frame->isCoalesced()) {
                 $result = $this->validator->validateFrame($frame, $this->previousFrame);
                 if (0 !== $result) {
                     $observer->onError(new WebsocketErrorException($result));
                 }
                 $data = $frame->extractOverflow();
                 $frame->unMaskPayload();
                 $observer->onNext($frame);
                 if ($frame->getOpcode() < 3) {
                     $this->previousFrame = $this->frame;
                     if ($frame->isFinal()) {
                         $this->previousFrame = null;
                     }
                 }
                 $this->frame = new Frame();
             }
         }
     }, [$observer, 'onError'], [$observer, 'onCompleted']));
 }
Example #15
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     if ($this->scheduler !== null) {
         $scheduler = $this->scheduler;
     }
     $innerDisp = new SerialDisposable();
     $disp = $observable->subscribe(new CallbackObserver(function ($x) use($innerDisp, $observer, $scheduler) {
         $now = $scheduler->now();
         if ($this->nextSend <= $now) {
             $innerDisp->setDisposable(new EmptyDisposable());
             $observer->onNext($x);
             $this->nextSend = $now + $this->throttleTime - 1;
             return;
         }
         $newDisp = Observable::just($x)->delay($this->nextSend - $now)->subscribe(new CallbackObserver(function ($x) use($observer, $scheduler) {
             $observer->onNext($x);
             $this->nextSend = $scheduler->now() + $this->throttleTime - 1;
             if ($this->completed) {
                 $observer->onCompleted();
             }
         }, [$observer, 'onError']), $scheduler);
         $innerDisp->setDisposable($newDisp);
     }, function (\Exception $e) use($observer, $innerDisp) {
         $innerDisp->dispose();
         $observer->onError($e);
     }, function () use($observer) {
         $this->completed = true;
         if ($this->nextSend === 0) {
             $observer->onCompleted();
         }
     }), $scheduler);
     return new CompositeDisposable([$disp, $innerDisp]);
 }
Example #16
0
 /**
  * @param \Rx\ObservableInterface $observable
  * @param \Rx\ObserverInterface $observer
  * @param \Rx\SchedulerInterface $scheduler
  * @return \Rx\DisposableInterface
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $selectObserver = new CallbackObserver(function ($nextValue) use($observer) {
         $value = null;
         try {
             $value = call_user_func($this->selector, $nextValue);
         } catch (\Exception $e) {
             $observer->onError($e);
         }
         $observer->onNext($value);
     }, function ($error) use($observer) {
         $observer->onError($error);
     }, function () use($observer) {
         $observer->onCompleted();
     });
     return $observable->subscribe($selectObserver, $scheduler);
 }
Example #17
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     return $observable->subscribe(new CallbackObserver(function ($x) {
         $this->arr[] = $x;
     }, function ($e) use($observer) {
         $observer->onError($e);
     }, function () use($observer) {
         $observer->onNext($this->arr);
         $observer->onCompleted();
     }));
 }
Example #18
0
 /**
  * @param $socket
  * @param ObserverInterface $observer
  */
 public function onConnected($socket, $observer)
 {
     $this->loop->removeWriteStream($socket);
     if (false === stream_socket_get_name($socket, true)) {
         $observer->onError(new ConnectionException('Connection refused'));
         $observer->onCompleted();
         return;
     }
     $observer->onNext(new ConnectorEvent("/connector/connected", new Stream($socket, $this->loop), $this->labels));
     //$observer->onCompleted();
 }
Example #19
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $outerDisposable = new SerialDisposable();
     $this->disposable->add($outerDisposable);
     $subscribe = function () use($outerDisposable, $observable, $observer, $scheduler, &$subscribe) {
         $this->sourceComplete = false;
         $outerSubscription = $observable->subscribe(new CallbackObserver([$observer, "onNext"], [$observer, "onError"], function () use($observer, &$subscribe, $outerDisposable) {
             $this->sourceComplete = true;
             if (!$this->repeat) {
                 $observer->onCompleted();
                 return;
             }
             $outerDisposable->setDisposable(new EmptyDisposable());
             $this->completions->onNext(++$this->count);
         }), $scheduler);
         $outerDisposable->setDisposable($outerSubscription);
     };
     $notifierDisposable = $this->notifier->subscribe(new CallbackObserver(function () use(&$subscribe, $scheduler) {
         $subscribe();
     }, function ($ex) use($observer) {
         $this->repeat = false;
         $observer->onError($ex);
     }, function () use($observer) {
         $this->repeat = false;
         if ($this->sourceComplete) {
             $observer->onCompleted();
         }
     }), $scheduler);
     $this->disposable->add($notifierDisposable);
     try {
         $handled = call_user_func($this->notificationHandler, $this->completions->asObservable());
         $handledDisposable = $handled->subscribe($this->notifier, $scheduler);
         $this->disposable->add($handledDisposable);
     } catch (\Exception $e) {
         $observer->onError($e);
         return new EmptyDisposable();
     }
     $subscribe();
     return $this->disposable;
 }
Example #20
0
 public function subscribe(ObserverInterface $observer, $scheduler = null)
 {
     $this->assertNotDisposed();
     if (!$this->isStopped) {
         $this->observers[] = $observer;
         return new InnerSubscriptionDisposable($this, $observer);
     }
     if ($this->exception) {
         $observer->onError($this->exception);
         return new EmptyDisposable();
     }
     $observer->onCompleted();
     return new EmptyDisposable();
 }
Example #21
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $this->q = [];
     return $observable->subscribe(new CallbackObserver(function ($x) use($observer) {
         $this->q[] = $x;
         if (count($this->q) > $this->count) {
             $observer->onNext(array_shift($this->q));
         }
     }, function ($e) use($observer) {
         $observer->onError($e);
     }, function () use($observer) {
         $observer->onCompleted();
     }));
 }
Example #22
0
 /**
  * @param ObserverInterface $observer
  * @param SchedulerInterface|null $scheduler
  * @return \Rx\Disposable\CompositeDisposable|\Rx\DisposableInterface
  */
 public function subscribe(ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $scheduler = $scheduler ?: new ImmediateScheduler();
     $key = 0;
     $defaultFn = function ($reschedule) use(&$observer, &$key) {
         try {
             if (null === $key) {
                 $observer->onCompleted();
                 return;
             }
             $current = $this->items->current();
             $observer->onNext($current);
             $this->items->next();
             $key = $this->items->key();
             $reschedule();
         } catch (\Exception $e) {
             $observer->onError($e);
         }
     };
     $hhvmFn = function ($reschedule) use(&$observer, &$key) {
         try {
             //HHVM requires you to call next() before current()
             $this->items->next();
             $key = $this->items->key();
             if (null === $key) {
                 $observer->onCompleted();
                 return;
             }
             $current = $this->items->current();
             $observer->onNext($current);
             $reschedule();
         } catch (\Exception $e) {
             $observer->onError($e);
         }
     };
     return $scheduler->scheduleRecursive(defined('HHVM_VERSION') && version_compare(HHVM_VERSION, '3.11.0', 'lt') ? $hhvmFn : $defaultFn);
 }
Example #23
0
 protected function pollForOutput(ObserverInterface $observer, $previous)
 {
     $poll = new \ZMQPoll();
     $read = $write = [];
     $poll->add($this->socket->getSocket(), \ZMQ::POLL_OUT);
     for ($i = 0; $i < 1000; $i += 1) {
         $events = $poll->poll($read, $write, 1);
         if ($events) {
             $observer->onNext($previous);
             return $observer->onCompleted();
         }
         $this->loop->tick();
     }
     return $observer->onError(new ConnectException("Socket is not answering"));
 }
Example #24
0
 /**
  * @param \Rx\ObservableInterface $observable
  * @param \Rx\ObserverInterface $observer
  * @param \Rx\SchedulerInterface $scheduler
  * @return \Rx\DisposableInterface
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $selectObserver = new CallbackObserver(function ($nextValue) use($observer) {
         $shouldFire = false;
         try {
             $shouldFire = call_user_func($this->predicate, $nextValue);
         } catch (\Exception $e) {
             $observer->onError($e);
         }
         if ($shouldFire) {
             $observer->onNext($nextValue);
         }
     }, [$observer, 'onError'], [$observer, 'onCompleted']);
     return $observable->subscribe($selectObserver, $scheduler);
 }
Example #25
0
 /**
  * @param ObservableInterface $observable
  * @param ObserverInterface $observer
  * @param SchedulerInterface|null $scheduler
  * @return \Rx\DisposableInterface
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $onNext = function ($value) use($observer) {
         try {
             if (call_user_func($this->predicate, $value)) {
                 $observer->onNext($value);
             } else {
                 $observer->onCompleted();
             }
         } catch (\Exception $e) {
             $observer->onError($e);
         }
     };
     $callbackObserver = new CallbackObserver($onNext, [$observer, 'onError'], [$observer, 'onCompleted']);
     return $observable->subscribe($callbackObserver, $scheduler);
 }
Example #26
0
 /**
  * @param \Rx\ObservableInterface $observable
  * @param \Rx\ObserverInterface $observer
  * @param \Rx\SchedulerInterface $scheduler
  * @return \Rx\DisposableInterface
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $callbackObserver = new CallbackObserver(function ($value) use($observer, $observable) {
         try {
             if ($this->isSkipping) {
                 $this->isSkipping = call_user_func_array($this->predicate, [$value, $observable]);
             }
             if (!$this->isSkipping) {
                 $observer->onNext($value);
             }
         } catch (\Exception $e) {
             $observer->onError($e);
         }
     }, [$observer, 'onError'], [$observer, 'onCompleted']);
     return $observable->subscribe($callbackObserver, $scheduler);
 }
Example #27
0
 public function subscribe(ObserverInterface $observer, $scheduler = null)
 {
     $this->stream->on('data', function ($data) use($observer) {
         $observer->onNext($data);
     });
     $this->stream->on('error', function ($error) use($observer) {
         $ex = $error instanceof \Exception ? $error : new \Exception($error);
         $observer->onError($ex);
     });
     $this->stream->on('close', function () use($observer) {
         $observer->onCompleted();
     });
     $disposable = parent::subscribe($observer, $scheduler);
     return new BinaryDisposable($disposable, new CallbackDisposable(function () use($observer) {
         $this->removeObserver($observer);
         $this->dispose();
     }));
 }
 /**
  * @param ObserverInterface $observer
  * @param \Rx\SchedulerInterface|null $scheduler
  * @return DisposableInterface
  */
 public function subscribe(ObserverInterface $observer, \Rx\SchedulerInterface $scheduler = null)
 {
     $this->object->on($this->nextAction, function () use($observer) {
         $observer->onNext(func_get_args());
     });
     if ($this->errorAction) {
         $this->object->on($this->errorAction, function ($error = null) use($observer) {
             $ex = $error instanceof \Exception ? $error : new \Exception($error);
             $observer->onError($ex);
         });
     }
     if ($this->completeAction) {
         $this->object->on($this->completeAction, function () use($observer) {
             $observer->onCompleted();
         });
     }
     return new EmptyDisposable();
 }
Example #29
0
 /**
  * @param \Rx\ObservableInterface $observable
  * @param \Rx\ObserverInterface $observer
  * @param \Rx\SchedulerInterface $scheduler
  * @return \Rx\DisposableInterface
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     array_unshift($this->observables, $observable);
     $observables =& $this->observables;
     $compositeDisposable = new CompositeDisposable();
     $hasValue = [];
     $values = array_keys($observables);
     $count = count($observables);
     $waitingToComplete = $count;
     $waitingForValues = $count;
     foreach ($observables as $key => $o) {
         $hasValue[$key] = false;
         $cbObserver = new CallbackObserver(function ($value) use($count, &$hasValue, $key, &$values, $observer, &$waitingForValues, &$waitingToComplete) {
             // If an observable has completed before it has emitted, we need to complete right away
             if ($waitingForValues > $waitingToComplete) {
                 $observer->onCompleted();
                 return;
             }
             if ($waitingForValues > 0 && !$hasValue[$key]) {
                 $hasValue[$key] = true;
                 $waitingForValues--;
             }
             $values[$key] = $value;
             if ($waitingForValues === 0) {
                 try {
                     $result = call_user_func_array($this->resultSelector, $values);
                     $observer->onNext($result);
                 } catch (\Exception $e) {
                     $observer->onError($e);
                 }
             }
         }, [$observer, 'onError'], function () use(&$waitingToComplete, $observer) {
             $waitingToComplete--;
             if ($waitingToComplete === 0) {
                 $observer->onCompleted();
             }
         });
         $subscription = $o->subscribe($cbObserver, $scheduler);
         $compositeDisposable->add($subscription);
     }
     return $compositeDisposable;
 }
Example #30
0
 /**
  * @inheritDoc
  */
 public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $errors = new Subject();
     $disposable = new CompositeDisposable();
     $sourceDisposable = new EmptyDisposable();
     $innerCompleted = false;
     $sourceError = false;
     try {
         $when = call_user_func($this->notificationHandler, $errors->asObservable());
     } catch (\Exception $e) {
         $observer->onError($e);
         return;
     }
     $subscribeToSource = function () use($observer, $disposable, $observable, &$sourceError, $errors, &$sourceDisposable, $scheduler, &$innerCompleted) {
         $sourceError = false;
         $sourceDisposable = $observable->subscribe(new CallbackObserver([$observer, 'onNext'], function ($err) use(&$sourceError, $errors, $disposable, &$sourceDisposable, &$innerCompleted, $observer) {
             $sourceError = true;
             $disposable->remove($sourceDisposable);
             $sourceDisposable->dispose();
             if ($innerCompleted) {
                 $observer->onCompleted();
                 return;
             }
             $errors->onNext($err);
         }, [$observer, 'onCompleted']), $scheduler);
         $disposable->add($sourceDisposable);
     };
     $whenDisposable = $when->subscribe(new CallbackObserver(function ($x) use($subscribeToSource, &$sourceError) {
         if ($sourceError) {
             $sourceError = false;
             $subscribeToSource();
         }
     }, [$observer, 'onError'], function () use(&$innerCompleted, &$sourceError, $observer) {
         $innerCompleted = true;
         if ($sourceError) {
             $observer->onCompleted();
         }
     }), $scheduler);
     $disposable->add($whenDisposable);
     $subscribeToSource();
     return $disposable;
 }