Excluder.java

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;
import com.google.gson.TypeAdapterFactory;
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.util.Collections;
import java.util.List;

public final class Excluder
  implements TypeAdapterFactory, Cloneable
{
  public static final Excluder DEFAULT = new Excluder();

  private double version = -1.0D;
  private int modifiers = 136;
  private boolean serializeInnerClasses = true;
  private boolean requireExpose;
  private List<ExclusionStrategy> serializationStrategies = Collections.emptyList();
  private List<ExclusionStrategy> deserializationStrategies = Collections.emptyList();

  protected Excluder clone() {
    try {
      return (Excluder)super.clone(); } catch (CloneNotSupportedException e) {
    }
    throw new AssertionError();
  }

  public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> type)
  {
    Class rawType = type.getRawType();
    final boolean skipSerialize = excludeClass(rawType, true);
    final boolean skipDeserialize = excludeClass(rawType, false);

    if ((!skipSerialize) && (!skipDeserialize)) {
      return null;
    }

    return new TypeAdapter()
    {
      private TypeAdapter<T> delegate;

      public T read(JsonReader in) throws IOException {
        if (skipDeserialize) {
          in.skipValue();
          return null;
        }
        return delegate().read(in);
      }

      public void write(JsonWriter out, T value) throws IOException {
        if (skipSerialize) {
          out.nullValue();
          return;
        }
        delegate().write(out, value);
      }

      private TypeAdapter<T> delegate() {
        TypeAdapter d = this.delegate;
        return this.delegate = gson.getDelegateAdapter(Excluder.this, type);
      }
    };
  }

  public boolean excludeField(Field field, boolean serialize)
  {
    if ((this.modifiers & field.getModifiers()) != 0) {
      return true;
    }

    if ((this.version != -1.0D) && (!isValidVersion((Since)field.getAnnotation(Since.class), (Until)field.getAnnotation(Until.class))))
    {
      return true;
    }

    if (field.isSynthetic()) {
      return true;
    }

    if (this.requireExpose) {
      Expose annotation = (Expose)field.getAnnotation(Expose.class);
      if ((annotation == null) || (serialize ? !annotation.serialize() : !annotation.deserialize())) {
        return true;
      }
    }

    if ((!this.serializeInnerClasses) && (isInnerClass(field.getType()))) {
      return true;
    }

    if (isAnonymousOrLocal(field.getType())) {
      return true;
    }

    List list = serialize ? this.serializationStrategies : this.deserializationStrategies;
    FieldAttributes fieldAttributes;
    if (!list.isEmpty()) {
      fieldAttributes = new FieldAttributes(field);
      for (ExclusionStrategy exclusionStrategy : list) {
        if (exclusionStrategy.shouldSkipField(fieldAttributes)) {
          return true;
        }
      }
    }

    return false;
  }

  public boolean excludeClass(Class<?> clazz, boolean serialize) {
    if ((this.version != -1.0D) && (!isValidVersion((Since)clazz.getAnnotation(Since.class), (Until)clazz.getAnnotation(Until.class))))
    {
      return true;
    }

    if ((!this.serializeInnerClasses) && (isInnerClass(clazz))) {
      return true;
    }

    if (isAnonymousOrLocal(clazz)) {
      return true;
    }

    List list = serialize ? this.serializationStrategies : this.deserializationStrategies;
    for (ExclusionStrategy exclusionStrategy : list) {
      if (exclusionStrategy.shouldSkipClass(clazz)) {
        return true;
      }
    }

    return false;
  }

  private boolean isAnonymousOrLocal(Class<?> clazz) {
    return (!Enum.class.isAssignableFrom(clazz)) && ((clazz.isAnonymousClass()) || (clazz.isLocalClass()));
  }

  private boolean isInnerClass(Class<?> clazz)
  {
    return (clazz.isMemberClass()) && (!isStatic(clazz));
  }

  private boolean isStatic(Class<?> clazz) {
    return (clazz.getModifiers() & 0x8) != 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();
      if (annotationVersion > this.version) {
        return false;
      }
    }
    return true;
  }

  private boolean isValidUntil(Until annotation) {
    if (annotation != null) {
      double annotationVersion = annotation.value();
      if (annotationVersion <= this.version) {
        return false;
      }
    }
    return true;
  }
}