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);
}
}
}