/**
* @inheritDoc
*/
public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
{
$hasValue = false;
$hasAccumulation = false;
$accumulation = $this->seed;
$hasSeed = $this->seed !== null;
$cbObserver = 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);
}, [$observer, 'onError'], function () use($observer, &$hasValue, &$hasSeed) {
if (!$hasValue && $hasSeed) {
$observer->onNext($this->seed);
}
$observer->onCompleted();
});
return $observable->subscribe($cbObserver, $scheduler);
}
public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
{
$singleDisposable = new SingleAssignmentDisposable();
$disposable = new CompositeDisposable();
$disposable->add($singleDisposable);
$callbackObserver = new CallbackObserver(function (Observable $x) use($disposable, $scheduler, $observer) {
if ($this->hasCurrent) {
return;
}
$this->hasCurrent = true;
$inner = new SingleAssignmentDisposable();
$disposable->add($inner);
$innerSub = $x->subscribe(new CallbackObserver([$observer, "onNext"], [$observer, "onError"], function () use($disposable, $inner, $observer) {
$disposable->remove($inner);
$this->hasCurrent = false;
if ($this->isStopped && $disposable->count() === 1) {
$observer->onCompleted();
}
}), $scheduler);
$inner->setDisposable($innerSub);
}, [$observer, 'onError'], function () use($disposable, $observer) {
$this->isStopped = true;
if (!$this->hasCurrent && $disposable->count() === 1) {
$observer->onCompleted();
}
});
$singleDisposable->setDisposable($observable->subscribe($callbackObserver, $scheduler));
return $disposable;
}
/**
* @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]);
}
/**
* @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);
}
/**
* @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]);
}
/**
* @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);
}
/**
* @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;
}
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();
}));
}
/**
* @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);
}
/**
* @inheritDoc
*/
public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
{
return $observable->subscribe(new CallbackObserver([$observer, 'onNext'], [$observer, 'onError'], function () use($observer) {
$o = new AutoDetachObserver($observer);
$o->setDisposable($this->subsequentObservable->subscribe($o));
}));
}
/**
* @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']));
}
/**
* @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;
}
/**
* @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)
{
$cbObserver = new CallbackObserver(function ($x) {
$this->arr[] = $x;
}, [$observer, 'onError'], function () use($observer) {
$observer->onNext($this->arr);
$observer->onCompleted();
});
return $observable->subscribe($cbObserver, $scheduler);
}
/**
* ConnectionSubject constructor.
* @param ObservableInterface $rawDataIn
* @param ObserverInterface $rawDataOut
* @param bool $mask
* @param bool $useMessageObject
* @param string $subProtocol
* @param RequestInterface $request
* @param ResponseInterface $response
*/
public function __construct(ObservableInterface $rawDataIn, ObserverInterface $rawDataOut, $mask = false, $useMessageObject = false, $subProtocol = "", RequestInterface $request, ResponseInterface $response)
{
$this->request = $request;
$this->response = $response;
$this->rawDataIn = new AnonymousObservable(function ($observer) use($rawDataIn) {
return $rawDataIn->subscribe($observer);
});
$this->rawDataOut = $rawDataOut;
$this->mask = $mask;
$this->subProtocol = $subProtocol;
// This can be used instead of the subjecg when this issue is addressed:
// https://github.com/asm89/Rx.PHP/issues/20
// Actually - using the subject is better so that the framing doesn't get done for every
// subscriber.
//$frames = $this->rawDataIn
// ->lift(new WebsocketFrameOperator());
$frames = new Subject();
$this->rawDataIn->lift(function () {
return new WebsocketFrameOperator();
})->subscribe(new CallbackObserver([$frames, "onNext"], function ($error) use($frames) {
$close = $this->createCloseFrame();
if ($error instanceof WebsocketErrorException) {
$close = $this->createCloseFrame($error->getCloseCode());
}
$this->sendFrame($close);
$this->rawDataOut->onCompleted();
// TODO: Should this error through to frame observers?
$frames->onCompleted();
}, function () use($frames) {
$this->rawDataOut->onCompleted();
$frames->onCompleted();
}));
$this->controlFrames = $frames->filter(function (Frame $frame) {
return $frame->getOpcode() > 2;
});
// default ping handler (ping received from far end
$this->controlFrames->filter(function (Frame $frame) {
return $frame->getOpcode() === $frame::OP_PING;
})->subscribe(new CallbackObserver(function (Frame $frame) {
$pong = new Frame($frame->getPayload(), true, Frame::OP_PONG);
$this->sendFrame($pong);
}));
$frames->filter(function (Frame $frame) {
return $frame->getOpcode() < 3;
})->lift(function () use($mask, $useMessageObject) {
return new WebsocketMessageOperator($mask, $useMessageObject);
})->subscribe(new CallbackObserver(function ($x) {
parent::onNext($x);
}, function ($x) {
parent::onError($x);
}, function () {
parent::onCompleted();
}));
$this->subProtocol = $subProtocol;
}
/**
* @inheritDoc
*/
public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
{
$this->q = [];
$cbObserver = new CallbackObserver(function ($x) use($observer) {
$this->q[] = $x;
if (count($this->q) > $this->count) {
$observer->onNext(array_shift($this->q));
}
}, [$observer, 'onError'], [$observer, 'onCompleted']);
return $observable->subscribe($cbObserver, $scheduler);
}
/**
* @inheritDoc
*/
public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
{
$disposable = new SerialDisposable();
$singleDisposable = new SingleAssignmentDisposable();
$disposable->setDisposable($singleDisposable);
$singleDisposable->setDisposable($this->scheduler->schedule(function () use($disposable, $observer, $observable, $scheduler) {
$subscription = $observable->subscribe($observer, $scheduler);
$disposable->setDisposable(new ScheduledDisposable($this->scheduler, $subscription));
}));
return $disposable;
}
/**
* @inheritDoc
*/
public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
{
return $observable->subscribe(new CallbackObserver(function ($x) use($observer) {
$observer->onNext(new OnNextNotification($x));
}, function ($error) use($observer) {
$observer->onNext(new OnErrorNotification($error));
$observer->onCompleted();
}, function () use($observer) {
$observer->onNext(new OnCompletedNotification());
$observer->onCompleted();
}), $scheduler);
}
/**
* @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 with timestamp.");
}
return $observable->subscribe(new CallbackObserver(function ($x) use($observer, $scheduler) {
$observer->onNext(new Timestamped($scheduler->now(), $x));
}, [$observer, "onError"], [$observer, "onCompleted"]), $scheduler);
}
public function __construct($key, ObservableInterface $underlyingObservable, DisposableInterface $mergedDisposable = null)
{
$this->key = $key;
if (null === $mergedDisposable) {
$this->underlyingObservable = $underlyingObservable;
} else {
$this->underlyingObservable = new AnonymousObservable(function ($observer, $scheduler) use($mergedDisposable, $underlyingObservable) {
// todo, typehint $mergedDisposable?
return new CompositeDisposable(array($mergedDisposable->getDisposable(), $underlyingObservable->subscribe($observer, $scheduler)));
});
}
}
/**
* @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)
{
$remaining = $this->count;
$cbObserver = new CallbackObserver(function ($nextValue) use($observer, &$remaining) {
if ($remaining <= 0) {
$observer->onNext($nextValue);
} else {
$remaining--;
}
}, [$observer, 'onError'], [$observer, 'onCompleted']);
return $observable->subscribe($cbObserver, $scheduler);
}
/**
* @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);
}, [$observer, 'onError'], [$observer, 'onCompleted']);
return $observable->subscribe($selectObserver, $scheduler);
}
/**
* Converts an existing observable sequence to React Promise
*
* @param PromisorInterface|null $deferred
* @return \React\Promise\Promise
*/
public static function fromObservable(ObservableInterface $observable, Deferred $deferred = null)
{
$d = $deferred ?: new Deferred();
$value = null;
$observable->subscribe(new CallbackObserver(function ($v) use(&$value) {
$value = $v;
}, function ($error) use($d) {
$d->reject($error);
}, function () use($d, &$value) {
$d->resolve($value);
}));
return $d->promise();
}
/**
* @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)
{
$buffer = "";
return $observable->defaultIfEmpty(Observable::just(null))->concat(Observable::just($this->delimiter))->concatMap(function ($x) use(&$buffer) {
if ($x === null || $buffer === null) {
$buffer = null;
return Observable::emptyObservable();
}
$items = explode($this->delimiter, $buffer . $x);
$buffer = array_pop($items);
return Observable::fromArray($items);
})->subscribe($observer, $scheduler);
}
/**
* @inheritDoc
*/
public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null)
{
return $observable->subscribe(new CallbackObserver(function ($frame) use($observer) {
$this->message->addFrame($frame);
if ($this->message->isCoalesced()) {
if ($this->useMessageObject) {
$observer->onNext(new \Rx\Websocket\Message($this->message->getPayload(), $this->message->isBinary()));
} else {
$observer->onNext($this->message->getPayload());
}
$this->message = new Message();
}
}, [$observer, 'onError'], [$observer, 'onCompleted']));
}
/**
* @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 ($nextValue) use($observer) {
$this->items[] = $nextValue;
if (count($this->items) > $this->count) {
array_shift($this->items);
}
}, [$observer, 'onError'], function () use($observer) {
while (count($this->items) > 0) {
$observer->onNext(array_shift($this->items));
}
$observer->onCompleted();
});
return $observable->subscribe($callbackObserver, $scheduler);
}
/**
* @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);
}
private function subscribeToResult(ObservableInterface $observable, SchedulerInterface $scheduler, ObserverInterface $observer, $outerIndex)
{
return $observable->subscribe(new CallbackObserver(function ($value) use($observer, $outerIndex) {
if (!$this->hasFirst) {
$this->hasFirst = true;
foreach ($this->subscriptions as $i => $subscription) {
if ($i !== $outerIndex) {
$subscription->dispose();
unset($this->subscriptions[$i]);
$this->innerSubscription->remove($subscription);
}
}
}
$observer->onNext($value);
}, [$observer, 'onError'], [$observer, 'onCompleted']), $scheduler);
}
/**
* @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);
}
/**
* @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)
{
$disposable = new SerialDisposable();
$cbObserver = new CallbackObserver(function ($x) use($observer) {
$this->passThrough = true;
$observer->onNext($x);
}, [$observer, 'onError'], function () use($observer, $disposable, $scheduler) {
if (!$this->passThrough) {
$disposable->setDisposable($this->observable->subscribe($observer, $scheduler));
return;
}
$observer->onCompleted();
});
$subscription = $observable->subscribe($cbObserver, $scheduler);
$disposable->setDisposable($subscription);
return $disposable;
}