com.google.gwt.inject.rebind.reflect.MemberLiteral Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gin Show documentation
GIN (GWT INjection) brings automatic dependency injection to Google Web Toolkit client-side code. GIN is built on top of Guice and uses (a subset of) Guice's binding language.
There is a newer version: 2.1.2
Show newest version
/*
 * Copyright 2010 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.gwt.inject.rebind.reflect;

import com.google.inject.BindingAnnotation;
import com.google.inject.ProvisionException;
import com.google.inject.TypeLiteral;

import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Member;
import java.lang.reflect.Modifier;

import javax.inject.Named;

/**
 * Generic member representation preserving the member's type parameters.
 *
 * @see TypeLiteral
 */
public abstract class MemberLiteral {

  private final M member;
  private final TypeLiteral declaringType;

  protected MemberLiteral(M member, TypeLiteral declaringType) {
    this.member = member;
    this.declaringType = declaringType;
  }

  /**
   * Returns the type declaring this member.
   *
   * @return declaring type
   */
  public TypeLiteral getDeclaringType() {
    return declaringType;
  }

  /**
   * Returns this member's name.
   *
   * @return name
   */
  public String getName() {
    return member.getName();
  }

  /**
   * Returns this member's raw (i.e. non-parametrized) declaring type.
   *
   * @return raw declaring type
   */
  public Class getRawDeclaringType() {
    return getDeclaringType().getRawType();
  }

  /**
   * Returns this member's modifiers.
   *
   * @return modifiers
   */
  public int getModifiers() {
    return member.getModifiers();
  }

  /**
   * Returns this member's annotations.
   *
   * @return annotations
   */
  public Annotation[] getAnnotations() {
    return member.getAnnotations();
  }

  /**
   * Returns this member's annotation of the passed type or {@code null} if no
   * matching annotation is present.
   *
   * @param type annotation type
   * @return annotation instance or {@code null} if no matching annotation
   *    exists
   */
  public  T getAnnotation(Class type) {
    return member.getAnnotation(type);
  }

  /**
   * Returns {@code true} if an annotation of the passed type is present on
   * this member.
   *
   * @param type annotation type to check for
   * @return {@code true} if the annotation is present
   */
  public boolean isAnnotationPresent(Class type) {
    return member.isAnnotationPresent(type);
  }

  /**
   * Returns this member's binding annotation or {@code null} if no such
   * annotation is present.
   *
   * @return binding annotation or {@code null}
   */
  public Annotation getBindingAnnotation() {
    return getBindingAnnotation(getAnnotations());
  }

  /**
   * Returns {@code true} if this member is declared as default access.
   *
   * @return {@code true} if default access
   */
  public boolean isDefaultAccess() {
    return !Modifier.isPrivate(getModifiers())
        && !Modifier.isProtected(getModifiers())
        && !Modifier.isPublic(getModifiers());
  }

  /**
   * Returns {@code true} if this member is declared public.
   *
   * @return {@code true} if public
   */
  public boolean isPublic() {
    return Modifier.isPublic(getModifiers());
  }

  /**
   * Returns {@code true} if this member is declared private.
   *
   * @return {@code true} if private
   */
  public boolean isPrivate() {
    return Modifier.isPrivate(getModifiers());
  }

  /**
   * Returns {@code true} if this member is declared static.
   *
   * @return {@code true} if static
   */
  public boolean isStatic() {
    return Modifier.isStatic(getModifiers());
  }

  protected Annotation getBindingAnnotation(Annotation[] annotations) {
    Annotation bindingAnnotation = null;
    for (Annotation annotation : annotations) {
      if (annotation.annotationType().getAnnotation(BindingAnnotation.class) != null
          || annotation.annotationType() == Named.class) {
        if (bindingAnnotation != null) {
          throw new ProvisionException(
              String.format("More than one binding annotation found on %s: %s, %s.",
                   this, annotation, bindingAnnotation));
        }

        bindingAnnotation = annotation;

        // Keep going so we can find any rogue additional binding annotations
      }
    }

    return bindingAnnotation;
  }

  protected M getMember() {
    return member;
  }
}