001    /*
002     * Copyright (C) 2009 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.GwtCompatible;
020    
021    import java.util.Collection;
022    import java.util.Map;
023    import java.util.Set;
024    
025    /**
026     * A table which forwards all its method calls to another table. Subclasses
027     * should override one or more methods to modify the behavior of the backing
028     * map as desired per the <a
029     * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
030     *
031     * @author Gregory Kick
032     * @since 7.0
033     */
034    @GwtCompatible
035    public abstract class ForwardingTable<R, C, V> extends ForwardingObject
036        implements Table<R, C, V> {
037      /** Constructor for use by subclasses. */
038      protected ForwardingTable() {}
039    
040      @Override protected abstract Table<R, C, V> delegate();
041    
042      @Override
043      public Set<Cell<R, C, V>> cellSet() {
044        return delegate().cellSet();
045      }
046    
047      @Override
048      public void clear() {
049        delegate().clear();
050      }
051    
052      @Override
053      public Map<R, V> column(C columnKey) {
054        return delegate().column(columnKey);
055      }
056    
057      @Override
058      public Set<C> columnKeySet() {
059        return delegate().columnKeySet();
060      }
061    
062      @Override
063      public Map<C, Map<R, V>> columnMap() {
064        return delegate().columnMap();
065      }
066    
067      @Override
068      public boolean contains(Object rowKey, Object columnKey) {
069        return delegate().contains(rowKey, columnKey);
070      }
071    
072      @Override
073      public boolean containsColumn(Object columnKey) {
074        return delegate().containsColumn(columnKey);
075      }
076    
077      @Override
078      public boolean containsRow(Object rowKey) {
079        return delegate().containsRow(rowKey);
080      }
081    
082      @Override
083      public boolean containsValue(Object value) {
084        return delegate().containsValue(value);
085      }
086    
087      @Override
088      public V get(Object rowKey, Object columnKey) {
089        return delegate().get(rowKey, columnKey);
090      }
091    
092      @Override
093      public boolean isEmpty() {
094        return delegate().isEmpty();
095      }
096    
097      @Override
098      public V put(R rowKey, C columnKey, V value) {
099        return delegate().put(rowKey, columnKey, value);
100      }
101    
102      @Override
103      public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
104        delegate().putAll(table);
105      }
106    
107      @Override
108      public V remove(Object rowKey, Object columnKey) {
109        return delegate().remove(rowKey, columnKey);
110      }
111    
112      @Override
113      public Map<C, V> row(R rowKey) {
114        return delegate().row(rowKey);
115      }
116    
117      @Override
118      public Set<R> rowKeySet() {
119        return delegate().rowKeySet();
120      }
121    
122      @Override
123      public Map<R, Map<C, V>> rowMap() {
124        return delegate().rowMap();
125      }
126    
127      @Override
128      public int size() {
129        return delegate().size();
130      }
131    
132      @Override
133      public Collection<V> values() {
134        return delegate().values();
135      }
136    
137      @Override public boolean equals(Object obj) {
138        return (obj == this) || delegate().equals(obj);
139      }
140    
141      @Override public int hashCode() {
142        return delegate().hashCode();
143      }
144    }