2011-11-22 08:37:13 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2008 Google Inc.
|
|
|
|
*
|
|
|
|
* 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.gson.internal;
|
|
|
|
|
|
|
|
import com.google.gson.ExclusionStrategy;
|
|
|
|
import com.google.gson.FieldAttributes;
|
|
|
|
import com.google.gson.Gson;
|
|
|
|
import com.google.gson.TypeAdapter;
|
2011-12-23 19:27:13 +01:00
|
|
|
import com.google.gson.TypeAdapterFactory;
|
2011-11-22 08:37:13 +01:00
|
|
|
import com.google.gson.annotations.Expose;
|
|
|
|
import com.google.gson.annotations.Since;
|
|
|
|
import com.google.gson.annotations.Until;
|
|
|
|
import com.google.gson.reflect.TypeToken;
|
|
|
|
import com.google.gson.stream.JsonReader;
|
|
|
|
import com.google.gson.stream.JsonWriter;
|
|
|
|
import java.io.IOException;
|
|
|
|
import java.lang.reflect.Field;
|
|
|
|
import java.lang.reflect.Modifier;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.List;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This class selects which fields and types to omit. It is configurable,
|
|
|
|
* supporting version attributes {@link Since} and {@link Until}, modifiers,
|
|
|
|
* synthetic fields, anonymous and local classes, inner classes, and fields with
|
|
|
|
* the {@link Expose} annotation.
|
|
|
|
*
|
|
|
|
* <p>This class is a type adapter factory; types that are excluded will be
|
|
|
|
* adapted to null. It may delegate to another type adapter if only one
|
|
|
|
* direction is excluded.
|
|
|
|
*
|
|
|
|
* @author Joel Leitch
|
|
|
|
* @author Jesse Wilson
|
|
|
|
*/
|
2011-12-23 19:27:13 +01:00
|
|
|
public final class Excluder implements TypeAdapterFactory, Cloneable {
|
2011-11-22 08:37:13 +01:00
|
|
|
private static final double IGNORE_VERSIONS = -1.0d;
|
|
|
|
public static final Excluder DEFAULT = new Excluder();
|
|
|
|
|
|
|
|
private double version = IGNORE_VERSIONS;
|
|
|
|
private int modifiers = Modifier.TRANSIENT | Modifier.STATIC;
|
|
|
|
private boolean serializeInnerClasses = true;
|
|
|
|
private boolean requireExpose;
|
|
|
|
private List<ExclusionStrategy> serializationStrategies = Collections.emptyList();
|
|
|
|
private List<ExclusionStrategy> deserializationStrategies = Collections.emptyList();
|
|
|
|
|
|
|
|
@Override protected Excluder clone() {
|
|
|
|
try {
|
|
|
|
return (Excluder) super.clone();
|
|
|
|
} catch (CloneNotSupportedException e) {
|
2015-11-16 18:16:23 +01:00
|
|
|
throw new AssertionError(e);
|
2011-11-22 08:37:13 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public Excluder withVersion(double ignoreVersionsAfter) {
|
|
|
|
Excluder result = clone();
|
|
|
|
result.version = ignoreVersionsAfter;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Excluder withModifiers(int... modifiers) {
|
|
|
|
Excluder result = clone();
|
|
|
|
result.modifiers = 0;
|
|
|
|
for (int modifier : modifiers) {
|
|
|
|
result.modifiers |= modifier;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Excluder disableInnerClassSerialization() {
|
|
|
|
Excluder result = clone();
|
|
|
|
result.serializeInnerClasses = false;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Excluder excludeFieldsWithoutExposeAnnotation() {
|
|
|
|
Excluder result = clone();
|
|
|
|
result.requireExpose = true;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Excluder withExclusionStrategy(ExclusionStrategy exclusionStrategy,
|
|
|
|
boolean serialization, boolean deserialization) {
|
|
|
|
Excluder result = clone();
|
|
|
|
if (serialization) {
|
2022-04-18 00:27:21 +02:00
|
|
|
result.serializationStrategies = new ArrayList<>(serializationStrategies);
|
2011-11-22 08:37:13 +01:00
|
|
|
result.serializationStrategies.add(exclusionStrategy);
|
|
|
|
}
|
|
|
|
if (deserialization) {
|
2022-04-18 00:27:21 +02:00
|
|
|
result.deserializationStrategies = new ArrayList<>(deserializationStrategies);
|
2011-11-22 08:37:13 +01:00
|
|
|
result.deserializationStrategies.add(exclusionStrategy);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2022-02-18 03:40:40 +01:00
|
|
|
@Override public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> type) {
|
2011-11-22 08:37:13 +01:00
|
|
|
Class<?> rawType = type.getRawType();
|
2017-12-28 01:33:45 +01:00
|
|
|
boolean excludeClass = excludeClassChecks(rawType);
|
|
|
|
|
|
|
|
final boolean skipSerialize = excludeClass || excludeClassInStrategy(rawType, true);
|
|
|
|
final boolean skipDeserialize = excludeClass || excludeClassInStrategy(rawType, false);
|
2011-11-22 08:37:13 +01:00
|
|
|
|
|
|
|
if (!skipSerialize && !skipDeserialize) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return new TypeAdapter<T>() {
|
|
|
|
/** The delegate is lazily created because it may not be needed, and creating it may fail. */
|
|
|
|
private TypeAdapter<T> delegate;
|
|
|
|
|
2011-12-03 20:46:25 +01:00
|
|
|
@Override public T read(JsonReader in) throws IOException {
|
2011-11-22 08:37:13 +01:00
|
|
|
if (skipDeserialize) {
|
2011-12-03 20:46:25 +01:00
|
|
|
in.skipValue();
|
2011-11-22 08:37:13 +01:00
|
|
|
return null;
|
|
|
|
}
|
2011-12-03 20:46:25 +01:00
|
|
|
return delegate().read(in);
|
2011-11-22 08:37:13 +01:00
|
|
|
}
|
|
|
|
|
2011-12-03 20:46:25 +01:00
|
|
|
@Override public void write(JsonWriter out, T value) throws IOException {
|
2011-11-22 08:37:13 +01:00
|
|
|
if (skipSerialize) {
|
2011-12-03 20:46:25 +01:00
|
|
|
out.nullValue();
|
2011-11-22 08:37:13 +01:00
|
|
|
return;
|
|
|
|
}
|
2011-12-03 20:46:25 +01:00
|
|
|
delegate().write(out, value);
|
2011-11-22 08:37:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private TypeAdapter<T> delegate() {
|
|
|
|
TypeAdapter<T> d = delegate;
|
|
|
|
return d != null
|
|
|
|
? d
|
2012-04-12 20:49:27 +02:00
|
|
|
: (delegate = gson.getDelegateAdapter(Excluder.this, type));
|
2011-11-22 08:37:13 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean excludeField(Field field, boolean serialize) {
|
|
|
|
if ((modifiers & field.getModifiers()) != 0) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (version != Excluder.IGNORE_VERSIONS
|
|
|
|
&& !isValidVersion(field.getAnnotation(Since.class), field.getAnnotation(Until.class))) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (field.isSynthetic()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (requireExpose) {
|
|
|
|
Expose annotation = field.getAnnotation(Expose.class);
|
|
|
|
if (annotation == null || (serialize ? !annotation.serialize() : !annotation.deserialize())) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!serializeInnerClasses && isInnerClass(field.getType())) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-09-18 03:12:47 +02:00
|
|
|
if (isAnonymousOrNonStaticLocal(field.getType())) {
|
2011-11-22 08:37:13 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
List<ExclusionStrategy> list = serialize ? serializationStrategies : deserializationStrategies;
|
|
|
|
if (!list.isEmpty()) {
|
|
|
|
FieldAttributes fieldAttributes = new FieldAttributes(field);
|
|
|
|
for (ExclusionStrategy exclusionStrategy : list) {
|
|
|
|
if (exclusionStrategy.shouldSkipField(fieldAttributes)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-12-28 01:33:45 +01:00
|
|
|
private boolean excludeClassChecks(Class<?> clazz) {
|
|
|
|
if (version != Excluder.IGNORE_VERSIONS && !isValidVersion(clazz.getAnnotation(Since.class), clazz.getAnnotation(Until.class))) {
|
|
|
|
return true;
|
|
|
|
}
|
2011-11-22 08:37:13 +01:00
|
|
|
|
2017-12-28 01:33:45 +01:00
|
|
|
if (!serializeInnerClasses && isInnerClass(clazz)) {
|
|
|
|
return true;
|
|
|
|
}
|
2011-11-22 08:37:13 +01:00
|
|
|
|
2021-09-18 03:12:47 +02:00
|
|
|
if (isAnonymousOrNonStaticLocal(clazz)) {
|
2017-12-28 01:33:45 +01:00
|
|
|
return true;
|
2011-11-22 08:37:13 +01:00
|
|
|
}
|
|
|
|
|
2017-12-28 01:33:45 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean excludeClass(Class<?> clazz, boolean serialize) {
|
|
|
|
return excludeClassChecks(clazz) ||
|
|
|
|
excludeClassInStrategy(clazz, serialize);
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean excludeClassInStrategy(Class<?> clazz, boolean serialize) {
|
|
|
|
List<ExclusionStrategy> list = serialize ? serializationStrategies : deserializationStrategies;
|
|
|
|
for (ExclusionStrategy exclusionStrategy : list) {
|
|
|
|
if (exclusionStrategy.shouldSkipClass(clazz)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
2011-11-22 08:37:13 +01:00
|
|
|
}
|
|
|
|
|
2021-09-18 03:12:47 +02:00
|
|
|
private boolean isAnonymousOrNonStaticLocal(Class<?> clazz) {
|
|
|
|
return !Enum.class.isAssignableFrom(clazz) && !isStatic(clazz)
|
2011-11-22 08:37:13 +01:00
|
|
|
&& (clazz.isAnonymousClass() || clazz.isLocalClass());
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean isInnerClass(Class<?> clazz) {
|
|
|
|
return clazz.isMemberClass() && !isStatic(clazz);
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean isStatic(Class<?> clazz) {
|
|
|
|
return (clazz.getModifiers() & Modifier.STATIC) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean isValidVersion(Since since, Until until) {
|
|
|
|
return isValidSince(since) && isValidUntil(until);
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean isValidSince(Since annotation) {
|
|
|
|
if (annotation != null) {
|
|
|
|
double annotationVersion = annotation.value();
|
2022-10-03 01:38:43 +02:00
|
|
|
return version >= annotationVersion;
|
2011-11-22 08:37:13 +01:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean isValidUntil(Until annotation) {
|
|
|
|
if (annotation != null) {
|
|
|
|
double annotationVersion = annotation.value();
|
2022-10-03 01:38:43 +02:00
|
|
|
return version < annotationVersion;
|
2011-11-22 08:37:13 +01:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|