/*
* Copyright (c) 2011-2017 Pivotal Software Inc, All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package reactor.core.scheduler;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import reactor.core.Disposable;
import reactor.core.Scannable;
Wraps one of the workers of some other Scheduler and
provides Worker services on top of it.
Use the dispose() to release the wrapped worker.
This scheduler is time-capable if the worker itself is time-capable (can schedule with
a delay and/or periodically).
/**
* Wraps one of the workers of some other Scheduler and
* provides Worker services on top of it.
* <p>
* Use the dispose() to release the wrapped worker.
* This scheduler is time-capable if the worker itself is time-capable (can schedule with
* a delay and/or periodically).
*/
final class SingleWorkerScheduler implements Scheduler, Executor, Scannable {
final Worker main;
SingleWorkerScheduler(Scheduler actual) {
this.main = actual.createWorker();
}
@Override
public void dispose() {
main.dispose();
}
@Override
public Disposable schedule(Runnable task) {
return main.schedule(task);
}
@Override
public Disposable schedule(Runnable task, long delay, TimeUnit unit) {
return main.schedule(task, delay, unit);
}
@Override
public Disposable schedulePeriodically(Runnable task, long initialDelay,
long period, TimeUnit unit) {
return main.schedulePeriodically(task, initialDelay, period, unit);
}
@Override
public void execute(Runnable command) {
main.schedule(command);
}
@Override
public Worker createWorker() {
return new ExecutorScheduler.ExecutorSchedulerWorker(this);
}
@Override
public boolean isDisposed() {
return main.isDisposed();
}
@Override
public String toString() {
Scannable mainScannable = Scannable.from(main);
if (mainScannable.isScanAvailable()) {
return Schedulers.SINGLE + "Worker(" + mainScannable.scanUnsafe(Attr.NAME) + ")";
}
return Schedulers.SINGLE + "Worker(" + main.toString() + ")";
}
@Override
public Object scanUnsafe(Attr key) {
if (key == Attr.TERMINATED || key == Attr.CANCELLED) return isDisposed();
if (key == Attr.PARENT) return main;
if (key == Attr.NAME) return this.toString();
return Scannable.from(main).scanUnsafe(key);
}
}