org.elasticsearch.common.inject.Key Maven / Gradle / Ivy
/**
* 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 org.elasticsearch.common.inject;
import org.elasticsearch.common.inject.internal.Annotations;
import org.elasticsearch.common.inject.internal.MoreTypes;
import org.elasticsearch.common.inject.internal.ToStringBuilder;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Binding key consisting of an injection type and an optional annotation.
* Matches the type and annotation at a point of injection.
*
* For example, {@code Key.get(Service.class, Transactional.class)} will
* match:
*
*
* {@literal @}Inject
* public void setService({@literal @}Transactional Service service) {
* ...
* }
*
*
* {@code Key} supports generic types via subclassing just like {@link
* TypeLiteral}.
*
* Keys do not differentiate between primitive types (int, char, etc.) and
* their correpsonding wrapper types (Integer, Character, etc.). Primitive
* types will be replaced with their wrapper types when keys are created.
*
* @author [email protected] (Bob Lee)
*/
public class Key {
private final AnnotationStrategy annotationStrategy;
private final TypeLiteral typeLiteral;
private final int hashCode;
/**
* Constructs a new key. Derives the type from this class's type parameter.
*
* Clients create an empty anonymous subclass. Doing so embeds the type
* parameter in the anonymous class's type hierarchy so we can reconstitute it
* at runtime despite erasure.
*
* Example usage for a binding of type {@code Foo} annotated with
* {@code @Bar}:
*
* {@code new Key(Bar.class) {}}.
*/
@SuppressWarnings("unchecked")
protected Key(Class annotationType) {
this.annotationStrategy = strategyFor(annotationType);
this.typeLiteral = (TypeLiteral) TypeLiteral.fromSuperclassTypeParameter(getClass());
this.hashCode = computeHashCode();
}
/**
* Constructs a new key. Derives the type from this class's type parameter.
*
* Clients create an empty anonymous subclass. Doing so embeds the type
* parameter in the anonymous class's type hierarchy so we can reconstitute it
* at runtime despite erasure.
*
* Example usage for a binding of type {@code Foo} annotated with
* {@code @Bar}:
*
* {@code new Key(new Bar()) {}}.
*/
@SuppressWarnings("unchecked")
protected Key(Annotation annotation) {
// no usages, not test-covered
this.annotationStrategy = strategyFor(annotation);
this.typeLiteral = (TypeLiteral) TypeLiteral.fromSuperclassTypeParameter(getClass());
this.hashCode = computeHashCode();
}
/**
* Constructs a new key. Derives the type from this class's type parameter.
*
* Clients create an empty anonymous subclass. Doing so embeds the type
* parameter in the anonymous class's type hierarchy so we can reconstitute it
* at runtime despite erasure.
*
* Example usage for a binding of type {@code Foo}:
*
* {@code new Key() {}}.
*/
@SuppressWarnings("unchecked")
protected Key() {
this.annotationStrategy = NullAnnotationStrategy.INSTANCE;
this.typeLiteral = (TypeLiteral) TypeLiteral.fromSuperclassTypeParameter(getClass());
this.hashCode = computeHashCode();
}
/**
* Unsafe. Constructs a key from a manually specified type.
*/
@SuppressWarnings("unchecked")
private Key(Type type, AnnotationStrategy annotationStrategy) {
this.annotationStrategy = annotationStrategy;
this.typeLiteral = MoreTypes.makeKeySafe((TypeLiteral) TypeLiteral.get(type));
this.hashCode = computeHashCode();
}
/**
* Constructs a key from a manually specified type.
*/
private Key(TypeLiteral typeLiteral, AnnotationStrategy annotationStrategy) {
this.annotationStrategy = annotationStrategy;
this.typeLiteral = MoreTypes.makeKeySafe(typeLiteral);
this.hashCode = computeHashCode();
}
private int computeHashCode() {
return typeLiteral.hashCode() * 31 + annotationStrategy.hashCode();
}
/**
* Gets the key type.
*/
public final TypeLiteral getTypeLiteral() {
return typeLiteral;
}
/**
* Gets the annotation type.
*/
public final Class getAnnotationType() {
return annotationStrategy.getAnnotationType();
}
/**
* Gets the annotation.
*/
public final Annotation getAnnotation() {
return annotationStrategy.getAnnotation();
}
boolean hasAnnotationType() {
return annotationStrategy.getAnnotationType() != null;
}
String getAnnotationName() {
Annotation annotation = annotationStrategy.getAnnotation();
if (annotation != null) {
return annotation.toString();
}
// not test-covered
return annotationStrategy.getAnnotationType().toString();
}
Class getRawType() {
return typeLiteral.getRawType();
}
/**
* Gets the key of this key's provider.
*/
Key> providerKey() {
return ofType(typeLiteral.providerType());
}
@Override
public final boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof Key)) {
return false;
}
Key other = (Key) o;
return annotationStrategy.equals(other.annotationStrategy)
&& typeLiteral.equals(other.typeLiteral);
}
@Override
public final int hashCode() {
return this.hashCode;
}
@Override
public final String toString() {
return new ToStringBuilder(Key.class)
.add("type", typeLiteral)
.add("annotation", annotationStrategy)
.toString();
}
/**
* Gets a key for an injection type and an annotation strategy.
*/
static Key get(Class type,
AnnotationStrategy annotationStrategy) {
return new Key<>(type, annotationStrategy);
}
/**
* Gets a key for an injection type.
*/
public static Key get(Class type) {
return new Key<>(type, NullAnnotationStrategy.INSTANCE);
}
/**
* Gets a key for an injection type and an annotation type.
*/
public static Key get(Class type,
Class annotationType) {
return new Key<>(type, strategyFor(annotationType));
}
/**
* Gets a key for an injection type and an annotation.
*/
public static Key get(Class type, Annotation annotation) {
return new Key<>(type, strategyFor(annotation));
}
/**
* Gets a key for an injection type.
*/
public static Key get(Type type) {
return new Key