All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.google.inject.matcher.Matchers Maven / Gradle / Ivy

Go to download

There is a newer version: 3.0.0-alpha-3
Show newest version
/*
 * Copyright (C) 2006 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.inject.matcher;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;

import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;

/**
 * Matcher implementations. Supports matching classes and methods.
 *
 * @author [email protected] (Bob Lee)
 */
public class Matchers {
  private Matchers() {}

  /** Returns a matcher which matches any input. */
  public static Matcher any() {
    return ANY;
  }

  private static final Matcher ANY = new Any();

  private static class Any extends AbstractMatcher implements Serializable {
    @Override
    public boolean matches(Object o) {
      return true;
    }

    @Override
    public String toString() {
      return "any()";
    }

    public Object readResolve() {
      return any();
    }

    private static final long serialVersionUID = 0;
  }

  /** Inverts the given matcher. */
  public static  Matcher not(final Matcher p) {
    return new Not(p);
  }

  private static class Not extends AbstractMatcher implements Serializable {
    final Matcher delegate;

    private Not(Matcher delegate) {
      this.delegate = checkNotNull(delegate, "delegate");
    }

    @Override
    public boolean matches(T t) {
      return !delegate.matches(t);
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof Not && ((Not) other).delegate.equals(delegate);
    }

    @Override
    public int hashCode() {
      return -delegate.hashCode();
    }

    @Override
    public String toString() {
      return "not(" + delegate + ")";
    }

    private static final long serialVersionUID = 0;
  }

  private static void checkForRuntimeRetention(Class annotationType) {
    Retention retention = annotationType.getAnnotation(Retention.class);
    checkArgument(
        retention != null && retention.value() == RetentionPolicy.RUNTIME,
        "Annotation %s is missing RUNTIME retention",
        annotationType.getSimpleName());
  }

  /** Returns a matcher which matches elements (methods, classes, etc.) with a given annotation. */
  public static Matcher annotatedWith(
      final Class annotationType) {
    return new AnnotatedWithType(annotationType);
  }

  private static class AnnotatedWithType extends AbstractMatcher
      implements Serializable {
    private final Class annotationType;

    public AnnotatedWithType(Class annotationType) {
      this.annotationType = checkNotNull(annotationType, "annotation type");
      checkForRuntimeRetention(annotationType);
    }

    @Override
    public boolean matches(AnnotatedElement element) {
      return element.isAnnotationPresent(annotationType);
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof AnnotatedWithType
          && ((AnnotatedWithType) other).annotationType.equals(annotationType);
    }

    @Override
    public int hashCode() {
      return 37 * annotationType.hashCode();
    }

    @Override
    public String toString() {
      return "annotatedWith(" + annotationType.getSimpleName() + ".class)";
    }

    private static final long serialVersionUID = 0;
  }

  /** Returns a matcher which matches elements (methods, classes, etc.) with a given annotation. */
  public static Matcher annotatedWith(final Annotation annotation) {
    return new AnnotatedWith(annotation);
  }

  private static class AnnotatedWith extends AbstractMatcher
      implements Serializable {
    private final Annotation annotation;

    public AnnotatedWith(Annotation annotation) {
      this.annotation = checkNotNull(annotation, "annotation");
      checkForRuntimeRetention(annotation.annotationType());
    }

    @Override
    public boolean matches(AnnotatedElement element) {
      Annotation fromElement = element.getAnnotation(annotation.annotationType());
      return fromElement != null && annotation.equals(fromElement);
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof AnnotatedWith
          && ((AnnotatedWith) other).annotation.equals(annotation);
    }

    @Override
    public int hashCode() {
      return 37 * annotation.hashCode();
    }

    @Override
    public String toString() {
      return "annotatedWith(" + annotation + ")";
    }

    private static final long serialVersionUID = 0;
  }

  /** Returns a matcher which matches subclasses of the given type (as well as the given type). */
  public static Matcher subclassesOf(final Class superclass) {
    return new SubclassesOf(superclass);
  }

  private static class SubclassesOf extends AbstractMatcher implements Serializable {
    private final Class superclass;

    public SubclassesOf(Class superclass) {
      this.superclass = checkNotNull(superclass, "superclass");
    }

    @Override
    public boolean matches(Class subclass) {
      return superclass.isAssignableFrom(subclass);
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof SubclassesOf && ((SubclassesOf) other).superclass.equals(superclass);
    }

    @Override
    public int hashCode() {
      return 37 * superclass.hashCode();
    }

    @Override
    public String toString() {
      return "subclassesOf(" + superclass.getSimpleName() + ".class)";
    }

    private static final long serialVersionUID = 0;
  }

  /** Returns a matcher which matches objects equal to the given object. */
  public static Matcher only(Object value) {
    return new Only(value);
  }

  private static class Only extends AbstractMatcher implements Serializable {
    private final Object value;

    public Only(Object value) {
      this.value = checkNotNull(value, "value");
    }

    @Override
    public boolean matches(Object other) {
      return value.equals(other);
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof Only && ((Only) other).value.equals(value);
    }

    @Override
    public int hashCode() {
      return 37 * value.hashCode();
    }

    @Override
    public String toString() {
      return "only(" + value + ")";
    }

    private static final long serialVersionUID = 0;
  }

  /** Returns a matcher which matches only the given object. */
  public static Matcher identicalTo(final Object value) {
    return new IdenticalTo(value);
  }

  private static class IdenticalTo extends AbstractMatcher implements Serializable {
    private final Object value;

    public IdenticalTo(Object value) {
      this.value = checkNotNull(value, "value");
    }

    @Override
    public boolean matches(Object other) {
      return value == other;
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof IdenticalTo && ((IdenticalTo) other).value == value;
    }

    @Override
    public int hashCode() {
      return 37 * System.identityHashCode(value);
    }

    @Override
    public String toString() {
      return "identicalTo(" + value + ")";
    }

    private static final long serialVersionUID = 0;
  }

  /**
   * Returns a matcher which matches classes in the given package. Packages are specific to their
   * classloader, so classes with the same package name may not have the same package at runtime.
   */
  public static Matcher inPackage(final Package targetPackage) {
    return new InPackage(targetPackage);
  }

  private static class InPackage extends AbstractMatcher implements Serializable {
    private final transient Package targetPackage;
    private final String packageName;

    public InPackage(Package targetPackage) {
      this.targetPackage = checkNotNull(targetPackage, "package");
      this.packageName = targetPackage.getName();
    }

    @Override
    public boolean matches(Class c) {
      return c.getPackage().equals(targetPackage);
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof InPackage && ((InPackage) other).targetPackage.equals(targetPackage);
    }

    @Override
    public int hashCode() {
      return 37 * targetPackage.hashCode();
    }

    @Override
    public String toString() {
      return "inPackage(" + targetPackage.getName() + ")";
    }

    public Object readResolve() {
      return inPackage(Package.getPackage(packageName));
    }

    private static final long serialVersionUID = 0;
  }

  /**
   * Returns a matcher which matches classes in the given package and its subpackages. Unlike {@link
   * #inPackage(Package) inPackage()}, this matches classes from any classloader.
   *
   * @since 2.0
   */
  public static Matcher inSubpackage(final String targetPackageName) {
    return new InSubpackage(targetPackageName);
  }

  private static class InSubpackage extends AbstractMatcher implements Serializable {
    private final String targetPackageName;

    public InSubpackage(String targetPackageName) {
      this.targetPackageName = targetPackageName;
    }

    @Override
    public boolean matches(Class c) {
      String classPackageName = c.getPackage().getName();
      return classPackageName.equals(targetPackageName)
          || classPackageName.startsWith(targetPackageName + ".");
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof InSubpackage
          && ((InSubpackage) other).targetPackageName.equals(targetPackageName);
    }

    @Override
    public int hashCode() {
      return 37 * targetPackageName.hashCode();
    }

    @Override
    public String toString() {
      return "inSubpackage(" + targetPackageName + ")";
    }

    private static final long serialVersionUID = 0;
  }

  /** Returns a matcher which matches methods with matching return types. */
  public static Matcher returns(final Matcher> returnType) {
    return new Returns(returnType);
  }

  private static class Returns extends AbstractMatcher implements Serializable {
    private final Matcher> returnType;

    public Returns(Matcher> returnType) {
      this.returnType = checkNotNull(returnType, "return type matcher");
    }

    @Override
    public boolean matches(Method m) {
      return returnType.matches(m.getReturnType());
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof Returns && ((Returns) other).returnType.equals(returnType);
    }

    @Override
    public int hashCode() {
      return 37 * returnType.hashCode();
    }

    @Override
    public String toString() {
      return "returns(" + returnType + ")";
    }

    private static final long serialVersionUID = 0;
  }

  static class AndMatcher extends AbstractMatcher implements Serializable {
    private final Matcher a, b;

    public AndMatcher(Matcher a, Matcher b) {
      this.a = a;
      this.b = b;
    }

    @Override
    public boolean matches(T t) {
      return a.matches(t) && b.matches(t);
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof AndMatcher
          && ((AndMatcher) other).a.equals(a)
          && ((AndMatcher) other).b.equals(b);
    }

    @Override
    public int hashCode() {
      return 41 * (a.hashCode() ^ b.hashCode());
    }

    @Override
    public String toString() {
      return "and(" + a + ", " + b + ")";
    }

    private static final long serialVersionUID = 0;
  }

  static class OrMatcher extends AbstractMatcher implements Serializable {
    private final Matcher a, b;

    public OrMatcher(Matcher a, Matcher b) {
      this.a = a;
      this.b = b;
    }

    @Override
    public boolean matches(T t) {
      return a.matches(t) || b.matches(t);
    }

    @Override
    public boolean equals(Object other) {
      return other instanceof OrMatcher
          && ((OrMatcher) other).a.equals(a)
          && ((OrMatcher) other).b.equals(b);
    }

    @Override
    public int hashCode() {
      return 37 * (a.hashCode() ^ b.hashCode());
    }

    @Override
    public String toString() {
      return "or(" + a + ", " + b + ")";
    }

    private static final long serialVersionUID = 0;
  }
}
    

    

    
            
    
            







    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy