com.github.ruediste.salta.standard.DependencyKey Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of salta-core Show documentation
Core of the Salta Framework. Provides most of the infrastructure, but no API
There is a newer version: 1.1
package com.github.ruediste.salta.standard;

import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

import com.github.ruediste.salta.core.CoreDependencyKey;
import com.github.ruediste.salta.standard.binder.AnnotationProxy;
import com.google.common.reflect.TypeToken;

/**
 * The type and {@link InjectionPoint} to lookup an instance.
 */
public class DependencyKey extends CoreDependencyKey {
	private final TypeToken type;
	private Class rawType;
	private final Map, Annotation> annotations;
	private final int hashCode;

	public static  DependencyKey of(TypeToken type) {
		return new DependencyKey<>(type, null, new HashMap<>());
	}

	public static  DependencyKey of(TypeToken type, Class rawType) {
		return new DependencyKey<>(type, rawType, new HashMap<>());
	}

	public static  DependencyKey of(Class type) {
		return new DependencyKey<>(TypeToken.of(type), type, new HashMap<>());
	}

	private DependencyKey(TypeToken type, Class rawType,
			Map, Annotation> annotations) {
		this.type = type;
		this.rawType = rawType;
		this.annotations = annotations;

		// don't use Objects.hash() for performance reason
		this.hashCode = type.hashCode() + 31 * annotations.hashCode();
	}

	@Override
	public TypeToken getType() {
		return type;
	}

	@Override
	public AnnotatedElement getAnnotatedElement() {
		return new AnnotatedElement() {

			@Override
			public Annotation[] getDeclaredAnnotations() {
				return getAnnotations();
			}

			@Override
			public Annotation[] getAnnotations() {
				return annotations.values().toArray(new Annotation[] {});
			}

			@SuppressWarnings("unchecked")
			@Override
			public  A getAnnotation(
					Class annotationClass) {
				return (A) annotations.get(annotationClass);
			}
		};
	}

	public Map, Annotation> getAnnotations() {
		return Collections.unmodifiableMap(annotations);
	}

	@SafeVarargs
	@SuppressWarnings("unchecked")
	public final DependencyKey withAnnotations(
			Class... cls) {
		Annotation[] annotations = new Annotation[cls.length];
		for (int i = 0; i < cls.length; i++) {
			annotations[i] = AnnotationProxy.newProxy(cls[i]);
		}
		return withAnnotations(annotations);
	}

	public DependencyKey withAnnotations(Annotation... additionalAnnotations) {
		HashMap, Annotation> tmp = new HashMap<>(
				annotations);
		for (Annotation a : additionalAnnotations) {
			if (a == null)
				continue;
			tmp.put(a.annotationType(), a);
		}
		return new DependencyKey<>(type, rawType, tmp);
	}

	@Override
	public int hashCode() {
		return hashCode;
	}

	@Override
	public boolean equals(Object obj) {
		if (obj == this)
			return true;
		if (obj == null)
			return false;
		if (!Objects.equals(getClass(), obj.getClass()))
			return false;
		DependencyKey other = (DependencyKey) obj;
		return Objects.equals(type, other.type)
				&& Objects.equals(annotations, other.annotations);
	}

	@SuppressWarnings("unchecked")
	@Override
	public Class getRawType() {
		// no synchronization required. In the worst case, multiple
		// threads will compute the value and overwrite each other's result,
		// which is No Problem
		if (rawType == null)
			rawType = (Class) type.getRawType();
		return rawType;
	}

	@Override
	public String toString() {
		String result = getType().toString();
		if (!annotations.values().isEmpty())
			result += annotations.values();
		return result;
	}

}