com.google.common.collect.GwtSerializationDependencies Maven / Gradle / Ivy
Show all versions of guava-gwt Show documentation
/*
* Copyright (C) 2009 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS-IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import java.io.Serializable;
import java.util.Comparator;
import java.util.HashMap;
import java.util.TreeMap;
/**
* Contains dummy collection implementations to convince GWT that part of serializing a collection
* is serializing its elements.
*
* Because of our use of final fields in our collections, GWT's normal heuristic for determining
* which classes might be serialized fails. That heuristic is, roughly speaking, to look at each
* parameter and return type of each RPC interface and to assume that implementations of those types
* might be serialized. Those types have their own dependencies -- their fields -- which are
* analyzed recursively and analogously.
*
*
For classes with final fields, GWT assumes that the class itself might be serialized but
* doesn't assume the same about its final fields. To work around this, we provide dummy
* implementations of our collections with their dependencies as non-final fields. Even though these
* implementations are never instantiated, they are visible to GWT when it performs its
* serialization analysis, and it assumes that their fields may be serialized.
*
*
Currently we provide dummy implementations of all the immutable collection classes necessary
* to support declarations like {@code ImmutableMultiset} in RPC interfaces. Support for
* {@code ImmutableMultiset} in the interface is support for {@code Multiset}, so there is nothing
* further to be done to support the new collection interfaces. It is not support, however, for an
* RPC interface in terms of {@code HashMultiset}. It is still possible to send a {@code
* HashMultiset} over GWT RPC; it is only the declaration of an interface in terms of {@code
* HashMultiset} that we haven't tried to support. (We may wish to revisit this decision in the
* future.)
*
* @author Chris Povirk
*/
@GwtCompatible
// None of these classes are instantiated, let alone serialized:
@SuppressWarnings("serial")
final class GwtSerializationDependencies {
private GwtSerializationDependencies() {}
static final class ImmutableListMultimapDependencies extends ImmutableListMultimap {
K key;
V value;
ImmutableListMultimapDependencies() {
super(null, 0);
}
}
// ImmutableMap is covered by ImmutableSortedMap/ImmutableBiMap.
// ImmutableMultimap is covered by ImmutableSetMultimap/ImmutableListMultimap.
static final class ImmutableSetMultimapDependencies extends ImmutableSetMultimap {
K key;
V value;
ImmutableSetMultimapDependencies() {
super(null, 0, null);
}
}
/*
* We support an interface declared in terms of LinkedListMultimap because it
* supports entry ordering not supported by other implementations.
*/
static final class LinkedListMultimapDependencies extends LinkedListMultimap {
K key;
V value;
LinkedListMultimapDependencies() {}
}
static final class HashBasedTableDependencies extends HashBasedTable {
HashMap> data;
HashBasedTableDependencies() {
super(null, null);
}
}
static final class TreeBasedTableDependencies extends TreeBasedTable {
TreeMap> data;
TreeBasedTableDependencies() {
super(null, null);
}
}
/*
* We don't normally need "implements Serializable," but we do here. That's
* because ImmutableTable itself is not Serializable as of this writing. We
* need for GWT to believe that this dummy class is serializable, or else it
* won't generate serialization code for R, C, and V.
*/
static final class ImmutableTableDependencies extends SingletonImmutableTable
implements Serializable {
R rowKey;
C columnKey;
V value;
ImmutableTableDependencies() {
super(null, null, null);
}
}
static final class TreeMultimapDependencies extends TreeMultimap {
Comparator keyComparator;
Comparator valueComparator;
K key;
V value;
TreeMultimapDependencies() {
super(null, null);
}
}
}