001    /*
002     * Copyright (C) 2012 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.collect;
018    
019    import com.google.common.annotations.Beta;
020    
021    import java.util.Deque;
022    import java.util.Iterator;
023    
024    /**
025     * A deque which forwards all its method calls to another deque. Subclasses
026     * should override one or more methods to modify the behavior of the backing
027     * deque as desired per the <a
028     * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
029     *
030     * <p><b>Warning:</b> The methods of {@code ForwardingDeque} forward
031     * <b>indiscriminately</b> to the methods of the delegate. For example,
032     * overriding {@link #add} alone <b>will not</b> change the behavior of {@link
033     * #offer} which can lead to unexpected behavior. In this case, you should
034     * override {@code offer} as well, either providing your own implementation, or
035     * delegating to the provided {@code standardOffer} method.
036     *
037     * <p>The {@code standard} methods are not guaranteed to be thread-safe, even
038     * when all of the methods that they depend on are thread-safe.
039     *
040     * @author Kurt Alfred Kluever
041     * @since 12.0
042     */
043    @Beta
044    public abstract class ForwardingDeque<E> extends ForwardingQueue<E>
045        implements Deque<E> {
046    
047      /** Constructor for use by subclasses. */
048      protected ForwardingDeque() {}
049    
050      @Override protected abstract Deque<E> delegate();
051    
052      @Override
053      public void addFirst(E e) {
054        delegate().addFirst(e);
055      }
056    
057      @Override
058      public void addLast(E e) {
059        delegate().addLast(e);
060      }
061    
062      @Override
063      public Iterator<E> descendingIterator() {
064        return delegate().descendingIterator();
065      }
066    
067      @Override
068      public E getFirst() {
069        return delegate().getFirst();
070      }
071    
072      @Override
073      public E getLast() {
074        return delegate().getLast();
075      }
076    
077      @Override
078      public boolean offerFirst(E e) {
079        return delegate().offerFirst(e);
080      }
081    
082      @Override
083      public boolean offerLast(E e) {
084        return delegate().offerLast(e);
085      }
086    
087      @Override
088      public E peekFirst() {
089        return delegate().peekFirst();
090      }
091    
092      @Override
093      public E peekLast() {
094        return delegate().peekLast();
095      }
096    
097      @Override
098      public E pollFirst() {
099        return delegate().pollFirst();
100      }
101    
102      @Override
103      public E pollLast() {
104        return delegate().pollLast();
105      }
106    
107      @Override
108      public E pop() {
109        return delegate().pop();
110      }
111    
112      @Override
113      public void push(E e) {
114        delegate().push(e);
115      }
116    
117      @Override
118      public E removeFirst() {
119        return delegate().removeFirst();
120      }
121    
122      @Override
123      public E removeLast() {
124        return delegate().removeLast();
125      }
126    
127      @Override
128      public boolean removeFirstOccurrence(Object o) {
129        return delegate().removeFirstOccurrence(o);
130      }
131    
132      @Override
133      public boolean removeLastOccurrence(Object o) {
134        return delegate().removeLastOccurrence(o);
135      }
136    }