001    /*
002     * Copyright (C) 2011 The Guava Authors
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     * http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    
017    package com.google.common.util.concurrent;
018    
019    import com.google.common.collect.ForwardingObject;
020    
021    import java.util.Collection;
022    import java.util.List;
023    import java.util.concurrent.Callable;
024    import java.util.concurrent.ExecutionException;
025    import java.util.concurrent.ExecutorService;
026    import java.util.concurrent.Future;
027    import java.util.concurrent.TimeUnit;
028    import java.util.concurrent.TimeoutException;
029    
030    /**
031     * An executor service which forwards all its method calls to another executor
032     * service. Subclasses should override one or more methods to modify the
033     * behavior of the backing executor service as desired per the <a
034     * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
035     *
036     * @author Kurt Alfred Kluever
037     * @since 10.0
038     */
039    public abstract class ForwardingExecutorService extends ForwardingObject
040        implements ExecutorService {
041      /** Constructor for use by subclasses. */
042      protected ForwardingExecutorService() {}
043      
044      @Override
045      protected abstract ExecutorService delegate();
046    
047      @Override
048      public boolean awaitTermination(long timeout, TimeUnit unit)
049          throws InterruptedException {
050        return delegate().awaitTermination(timeout, unit);
051      }
052    
053      @Override
054      public <T> List<Future<T>> invokeAll(
055          Collection<? extends Callable<T>> tasks) throws InterruptedException {
056        return delegate().invokeAll(tasks);
057      }
058    
059      @Override
060      public <T> List<Future<T>> invokeAll(
061          Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
062          throws InterruptedException {
063        return delegate().invokeAll(tasks, timeout, unit);
064      }
065    
066      @Override
067      public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
068          throws InterruptedException, ExecutionException {
069        return delegate().invokeAny(tasks);
070      }
071    
072      @Override
073      public <T> T invokeAny(
074          Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
075          throws InterruptedException, ExecutionException, TimeoutException {
076        return delegate().invokeAny(tasks, timeout, unit);
077      }
078    
079      @Override
080      public boolean isShutdown() {
081        return delegate().isShutdown();
082      }
083    
084      @Override
085      public boolean isTerminated() {
086        return delegate().isTerminated();
087      }
088    
089      @Override
090      public void shutdown() {
091        delegate().shutdown();
092      }
093    
094      @Override
095      public List<Runnable> shutdownNow() {
096        return delegate().shutdownNow();
097      }
098    
099      @Override
100      public void execute(Runnable command) {
101        delegate().execute(command);
102      }
103    
104      public <T> Future<T> submit(Callable<T> task) {
105        return delegate().submit(task);
106      }
107    
108      @Override
109      public Future<?> submit(Runnable task) {
110        return delegate().submit(task);
111      }
112    
113      @Override
114      public <T> Future<T> submit(Runnable task, T result) {
115        return delegate().submit(task, result);
116      }
117    }