public function add(DisposableInterface $disposable)
{
if ($this->isDisposed) {
$disposable->dispose();
} else {
$this->disposables[] = $disposable;
}
}
public function handleRouterStop(RouterStopEvent $event)
{
foreach ($this->sessions as $k) {
$this->sessions[$k]->shutdown();
}
if ($this->serverDisposable) {
$this->serverDisposable->dispose();
}
}
public function dispose()
{
if ($this->isDisposed) {
return;
}
$this->isDisposed = true;
$this->scheduler->schedule(function () {
$this->disposable->dispose();
});
}
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)));
});
}
}
public function setDisposable(DisposableInterface $disposable = null)
{
if ($this->current) {
throw new RuntimeException('Disposable has already been assigned.');
}
if (!$this->isDisposed) {
$this->current = $disposable;
}
if ($this->isDisposed && $disposable) {
$disposable->dispose();
}
}
/**
* @param DisposableInterface $disposable
*/
public function setDisposable(DisposableInterface $disposable)
{
$shouldDispose = $this->isDisposed;
if (!$shouldDispose) {
$old = $this->disposable;
$this->disposable = $disposable;
if ($old) {
$old->dispose();
}
}
if ($shouldDispose) {
$disposable->dispose();
}
}
/**
* @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.");
}
/** @var AnonymousObservable $observable */
$disp = $observable->materialize()->timestamp()->map(function (Timestamped $x) {
return new Timestamped($x->getTimestampMillis() + $this->delayTime, $x->getValue());
})->subscribe(new CallbackObserver(function (Timestamped $x) use($scheduler, $observer) {
if ($x->getValue() instanceof Notification\OnErrorNotification) {
$x->getValue()->accept($observer);
return;
}
$this->queue->enqueue($x);
if ($this->schedulerDisposable === null) {
$doScheduledStuff = function () use($observer, $scheduler, &$doScheduledStuff) {
while (!$this->queue->isEmpty() && $scheduler->now() >= $this->queue->bottom()->getTimestampMillis()) {
/** @var Timestamped $item */
$item = $this->queue->dequeue();
/** @var Notification $materializedValue */
$materializedValue = $item->getValue();
$materializedValue->accept($observer);
}
if ($this->queue->isEmpty()) {
$this->schedulerDisposable = null;
return;
}
$this->schedulerDisposable = $scheduler->schedule($doScheduledStuff, $this->queue->bottom()->getTimestampMillis() - $scheduler->now());
};
$doScheduledStuff();
}
}, [$observer, 'onError']), $scheduler);
return new CallbackDisposable(function () use($disp) {
if ($this->schedulerDisposable) {
$this->schedulerDisposable->dispose();
}
$disp->dispose();
});
}
