1 /*
2  * Copyright (C) 2009 The Guava Authors
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS-IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.common.collect;
18 
19 import com.google.common.annotations.GwtCompatible;
20 
21 import java.io.Serializable;
22 import java.util.Comparator;
23 import java.util.HashMap;
24 import java.util.TreeMap;
25 
26 /**
27  * Contains dummy collection implementations to convince GWT that part of
28  * serializing a collection is serializing its elements.
29  *
30  * <p>Because of our use of final fields in our collections, GWT's normal
31  * heuristic for determining which classes might be serialized fails. That
32  * heuristic is, roughly speaking, to look at each parameter and return type of
33  * each RPC interface and to assume that implementations of those types might be
34  * serialized. Those types have their own dependencies -- their fields -- which
35  * are analyzed recursively and analogously.
36  *
37  * <p>For classes with final fields, GWT assumes that the class itself might be
38  * serialized but doesn't assume the same about its final fields. To work around
39  * this, we provide dummy implementations of our collections with their
40  * dependencies as non-final fields. Even though these implementations are never
41  * instantiated, they are visible to GWT when it performs its serialization
42  * analysis, and it assumes that their fields may be serialized.
43  *
44  * <p>Currently we provide dummy implementations of all the immutable
45  * collection classes necessary to support declarations like
46  * {@code ImmutableMultiset<String>} in RPC interfaces. Support for
47  * {@code ImmutableMultiset} in the interface is support for {@code Multiset},
48  * so there is nothing further to be done to support the new collection
49  * interfaces. It is not support, however, for an RPC interface in terms of
50  * {@code HashMultiset}. It is still possible to send a {@code HashMultiset}
51  * over GWT RPC; it is only the declaration of an interface in terms of
52  * {@code HashMultiset} that we haven't tried to support. (We may wish to
53  * revisit this decision in the future.)
54  *
55  * @author Chris Povirk
56  */
57 @GwtCompatible
58 // None of these classes are instantiated, let alone serialized:
59 @SuppressWarnings("serial")
60 final class GwtSerializationDependencies {
GwtSerializationDependencies()61   private GwtSerializationDependencies() {}
62 
63   static final class ImmutableListMultimapDependencies<K, V>
64       extends ImmutableListMultimap<K, V> {
65     K key;
66     V value;
67 
ImmutableListMultimapDependencies()68     ImmutableListMultimapDependencies() {
69       super(null, 0);
70     }
71   }
72 
73   // ImmutableMap is covered by ImmutableSortedMap/ImmutableBiMap.
74 
75   // ImmutableMultimap is covered by ImmutableSetMultimap/ImmutableListMultimap.
76 
77   static final class ImmutableSetMultimapDependencies<K, V>
78       extends ImmutableSetMultimap<K, V> {
79     K key;
80     V value;
81 
ImmutableSetMultimapDependencies()82     ImmutableSetMultimapDependencies() {
83       super(null, 0, null);
84     }
85   }
86 
87   /*
88    * We support an interface declared in terms of LinkedListMultimap because it
89    * supports entry ordering not supported by other implementations.
90    */
91   static final class LinkedListMultimapDependencies<K, V>
92       extends LinkedListMultimap<K, V> {
93     K key;
94     V value;
95 
LinkedListMultimapDependencies()96     LinkedListMultimapDependencies() {}
97   }
98 
99   static final class HashBasedTableDependencies<R, C, V>
100       extends HashBasedTable<R, C, V> {
101     HashMap<R, HashMap<C, V>> data;
102 
HashBasedTableDependencies()103     HashBasedTableDependencies() {
104       super(null, null);
105     }
106   }
107 
108   static final class TreeBasedTableDependencies<R, C, V>
109       extends TreeBasedTable<R, C, V> {
110     TreeMap<R, TreeMap<C, V>> data;
111 
TreeBasedTableDependencies()112     TreeBasedTableDependencies() {
113       super(null, null);
114     }
115   }
116 
117   /*
118    * We don't normally need "implements Serializable," but we do here. That's
119    * because ImmutableTable itself is not Serializable as of this writing. We
120    * need for GWT to believe that this dummy class is serializable, or else it
121    * won't generate serialization code for R, C, and V.
122    */
123   static final class ImmutableTableDependencies<R, C, V>
124       extends SingletonImmutableTable<R, C, V> implements Serializable {
125     R rowKey;
126     C columnKey;
127     V value;
128 
ImmutableTableDependencies()129     ImmutableTableDependencies() {
130       super(null, null, null);
131     }
132   }
133 
134   static final class TreeMultimapDependencies<K, V>
135       extends TreeMultimap<K, V> {
136     Comparator<? super K> keyComparator;
137     Comparator<? super V> valueComparator;
138     K key;
139     V value;
140 
TreeMultimapDependencies()141     TreeMultimapDependencies() {
142       super(null, null);
143     }
144   }
145 }
146