/*
 * 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:crazybob@google.com (Bob Lee)
/** * Matcher implementations. Supports matching classes and methods. * * @author crazybob@google.com (Bob Lee) */
public class Matchers { private Matchers() {}
Returns a matcher which matches any input.
/** Returns a matcher which matches any input. */
public static Matcher<Object> any() { return ANY; } private static final Matcher<Object> ANY = new Any(); private static class Any extends AbstractMatcher<Object> 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.
/** Inverts the given matcher. */
public static <T> Matcher<T> not(final Matcher<? super T> p) { return new Not<T>(p); } private static class Not<T> extends AbstractMatcher<T> implements Serializable { final Matcher<? super T> delegate; private Not(Matcher<? super T> 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<? extends Annotation> 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.
/** Returns a matcher which matches elements (methods, classes, etc.) with a given annotation. */
public static Matcher<AnnotatedElement> annotatedWith( final Class<? extends Annotation> annotationType) { return new AnnotatedWithType(annotationType); } private static class AnnotatedWithType extends AbstractMatcher<AnnotatedElement> implements Serializable { private final Class<? extends Annotation> annotationType; public AnnotatedWithType(Class<? extends Annotation> 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.
/** Returns a matcher which matches elements (methods, classes, etc.) with a given annotation. */
public static Matcher<AnnotatedElement> annotatedWith(final Annotation annotation) { return new AnnotatedWith(annotation); } private static class AnnotatedWith extends AbstractMatcher<AnnotatedElement> 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).
/** Returns a matcher which matches subclasses of the given type (as well as the given type). */
public static Matcher<Class> subclassesOf(final Class<?> superclass) { return new SubclassesOf(superclass); } private static class SubclassesOf extends AbstractMatcher<Class> 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.
/** Returns a matcher which matches objects equal to the given object. */
public static Matcher<Object> only(Object value) { return new Only(value); } private static class Only extends AbstractMatcher<Object> 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.
/** Returns a matcher which matches only the given object. */
public static Matcher<Object> identicalTo(final Object value) { return new IdenticalTo(value); } private static class IdenticalTo extends AbstractMatcher<Object> 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.
/** * 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<Class> inPackage(final Package targetPackage) { return new InPackage(targetPackage); } private static class InPackage extends AbstractMatcher<Class> 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 inPackage(), this matches classes from any classloader.
Since:2.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<Class> inSubpackage(final String targetPackageName) { return new InSubpackage(targetPackageName); } private static class InSubpackage extends AbstractMatcher<Class> 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.
/** Returns a matcher which matches methods with matching return types. */
public static Matcher<Method> returns(final Matcher<? super Class<?>> returnType) { return new Returns(returnType); } private static class Returns extends AbstractMatcher<Method> implements Serializable { private final Matcher<? super Class<?>> returnType; public Returns(Matcher<? super Class<?>> 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; } }