## com.google.common.util.concurrent
Class ForwardingService

    java.lang.Object
      com.google.common.collect.ForwardingObject
          com.google.common.util.concurrent.ForwardingService

All Implemented Interfaces:
  Service

    @Beta
    public abstract class ForwardingService

extends ForwardingObject
implements Service

A `Service` that forwards all method calls to another service.

Since:
  1.0
Author:
  Chris Nokleberg

Nested Class Summary

Nested classes/interfaces inherited from interface com.google.common.util.concurrent.Service
`Service.Listener, Service.State`

Constructor Summary
`protected` `ForwardingService()` Constructor for use by subclasses.

Method Summary
`void` `addListener(Service.Listener listener, Executor executor)` Registers a `Service.Listener` to be executed on the given executor.
`protected abstract Service` `delegate()` Returns the backing delegate instance that methods are forwarded to.
`boolean` `isRunning()` Returns `true` if this service is running.
`protected Service.State` `standardStartAndWait()` A sensible default implementation of `startAndWait()`, in terms of `start()`.
`protected Service.State` `standardStopAndWait()` A sensible default implementation of `stopAndWait()`, in terms of `stop()`.
`ListenableFuture<Service.State>` `start()` If the service state is `Service.State.NEW`, this initiates service startup and returns immediately.
`Service.State` `startAndWait()` Initiates service startup (if necessary), returning once the service has finished starting.
`Service.State` `state()` Returns the lifecycle state of the service.
`ListenableFuture<Service.State>` `stop()` If the service is starting or running, this initiates service shutdown and returns immediately.
`Service.State` `stopAndWait()` Initiates service shutdown (if necessary), returning once the service has finished stopping.

Methods inherited from class com.google.common.collect.ForwardingObject
`toString`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### ForwardingService

    protected ForwardingService()

  Constructor for use by subclasses.

Method Detail

### delegate

    protected abstract Service delegate()

  Description copied from class: `ForwardingObject`
  Returns the backing delegate instance that methods are forwarded to. Abstract subclasses generally override this method with an abstract method that has a more specific return type, such as `ForwardingSet.delegate()`. Concrete subclasses override this method to supply the instance being decorated.

  Specified by:
    `delegate` in class `ForwardingObject`

### start

    public ListenableFuture<Service.State> start()

  Description copied from interface: `Service`
  If the service state is `Service.State.NEW`, this initiates service startup and returns immediately. If the service has already been started, this method returns immediately without taking action. A stopped service may not be restarted.

  Specified by:
    `start` in interface `Service`
  Returns:
    a future for the startup result, regardless of whether this call initiated startup. Calling `Future.get()` will block until the service has finished starting, and returns one of `Service.State.RUNNING`, `Service.State.STOPPING` or `Service.State.TERMINATED`. If the service fails to start, `Future.get()` will throw an `ExecutionException`, and the service's state will be `Service.State.FAILED`. If it has already finished starting, `Future.get()` returns immediately. Cancelling this future has no effect on the service.

### state

    public Service.State state()

  Description copied from interface: `Service`
  Returns the lifecycle state of the service.

  Specified by:
    `state` in interface `Service`

### stop

    public ListenableFuture<Service.State> stop()

  Description copied from interface: `Service`
  If the service is starting or running, this initiates service shutdown and returns immediately. If the service is new, it is terminated without having been started nor stopped. If the service has already been stopped, this method returns immediately without taking action.

  Specified by:
    `stop` in interface `Service`
  Returns:
    a future for the shutdown result, regardless of whether this call initiated shutdown. Calling `Future.get()` will block until the service has finished shutting down, and either returns `Service.State.TERMINATED` or throws an `ExecutionException`. If it has already finished stopping, `Future.get()` returns immediately. Cancelling this future has no effect on the service.

### startAndWait

    public Service.State startAndWait()

  Description copied from interface: `Service`
  Initiates service startup (if necessary), returning once the service has finished starting. Unlike calling `start().get()`, this method throws no checked exceptions, and it cannot be interrupted.

  Specified by:
    `startAndWait` in interface `Service`
  Returns:
    the state of the service when startup finished.

### stopAndWait

    public Service.State stopAndWait()

  Description copied from interface: `Service`
  Initiates service shutdown (if necessary), returning once the service has finished stopping. If this is `Service.State.STARTING`, startup will be cancelled. If this is `Service.State.NEW`, it is `terminated` without having been started nor stopped. Unlike calling `stop().get()`, this method throws no checked exceptions.

  Specified by:
    `stopAndWait` in interface `Service`
  Returns:
    the state of the service when shutdown finished.

### isRunning

    public boolean isRunning()

  Description copied from interface: `Service`
  Returns `true` if this service is running.

  Specified by:
    `isRunning` in interface `Service`

### addListener

    public void addListener(Service.Listener listener,
                            Executor executor)

  Description copied from interface: `Service`
  Registers a `Service.Listener` to be executed on the given executor. The listener will have the corresponding transition method called whenever the service changes state. The listener will not have previous state changes replayed, so it is suggested that listeners are added before the service starts.

  There is no guaranteed ordering of execution of listeners, but any listener added through this method is guaranteed to be called whenever there is a state change.

  Exceptions thrown by a listener will be propagated up to the executor. Any exception thrown during `Executor.execute` (e.g., a `RejectedExecutionException` or an exception thrown by inline execution) will be caught and logged.

  Specified by:
    `addListener` in interface `Service`
  Parameters:
    `listener` - the listener to run when the service changes state is complete
    `executor` - the executor in which the the listeners callback methods will be run. For fast, lightweight listeners that would be safe to execute in any thread, consider `MoreExecutors.sameThreadExecutor()`.

### standardStartAndWait

    protected Service.State standardStartAndWait()

  A sensible default implementation of `startAndWait()`, in terms of `start()`. If you override `start()`, you may wish to override `startAndWait()` to forward to this implementation.

  Since:
    9.0

### standardStopAndWait

    protected Service.State standardStopAndWait()

  A sensible default implementation of `stopAndWait()`, in terms of `stop()`. If you override `stop()`, you may wish to override `stopAndWait()` to forward to this implementation.

  Since:
    9.0

Copyright © 2010-2012. All Rights Reserved.