de.japkit.services

Class TypesRegistry

java.lang.Object

de.japkit.services.TypesRegistry

public class TypesRegistry
extends Object

Registry for generated types. Helps with the resolution of those type when they are used in other classes.

Constructor Summary

Constructors

Constructor and Description
TypesRegistry()

Method Summary

Modifier and Type	Method and Description
protected String	_getSimpleNameForErrorType(GenDeclaredType errorType)
protected String	_getSimpleNameForErrorType(TypeMirror errorType)
protected CharSequence	_getSimpleOrPartiallyQualifiedName(Element element)
protected CharSequence	_getSimpleOrPartiallyQualifiedName(TypeElement typeElement) For top level classes, that method returns the simple name.
protected void	_registerTypeDependencyForAnnotatedClass(TypeElement annotatedClass, DeclaredType type)
protected void	_registerTypeDependencyForAnnotatedClass(TypeElement annotatedClass, TypeMirror type)
protected String	_tryToGetFqnForErrorType(GenDeclaredType errorType)
protected String	_tryToGetFqnForErrorType(TypeMirror errorType)
Set<String>	annotatedClassesOnWhichThatOneDependsOn(String annotatedClassFqn) Based on the dependencies and generated type elements registered so far, this method examines, on which other annotated classes the given class depends on.
TypeElement	asTypeElement(TypeMirror declType) Get the TypeElement for the type.
void	cleanUpTypesAtEndOfRound() Removes all type elements from cache.
void	clearCaches()
void	commitGeneratedTypeElement(GenTypeElement genTypeElement) DEPRECATED ...
boolean	dependOnOtherAnnotatedClasses(Set<String> annotatedClassesFqn) Determines, whether the given annotated classes depend on any other annotated class not within the set.
boolean	dependOnUnknownTypes(Set<String> annotatedClassesFqn)
boolean	dependsOnOtherAnnotatedClasses(String annotatedClassFqn)
boolean	dependsOnUnknownTypes(CharSequence annotatedClassFqn) Does the annotated class have type dependencies where javac has only returned the String "error" instead of an ErrorType with the short name of the missing type?
boolean	dependsOnUnknownTypes(CharSequence annotatedClassFqn, CharSequence genClassFqn)
Iterable<TypeElement>	findAllTypeElementsWithTriggerAnnotation(String triggerFqn, boolean shadow)
Iterable<TypeElement>	findAllTypeElementsWithTriggerAnnotation(String clienAnnotatedClassFqn, String triggerFqn, boolean shadow)
Iterable<TypeElement>	findAllTypeElementsWithTriggerAnnotation(TypeElement annotatedClass, String triggerFqn, boolean shadow)
Iterable<Set<String>>	findCyclesInAnnotatedClasses(Set<String> annotatedClasses) Returns a list of strongly connected components within the graph of the given annotated classes.
AnnotationMirror	findGenAnnotation(TypeElement typeElement)
TypeElement	findGenTypeElementForFqn(String fqn)
TypeElement	findGenTypeElementForShortName(String shortname)
Element	findNestedElement(Element e, String[] path)
TypeElement	findTypeElement(String typeFqn)
protected TypeElement	findTypeInCurrentGeneratedClass(String typeFqnOrShortname)
Set<String>	getAnnotatedClassesDependingGenericallyOnThatTriggerAnnotation(String triggerFqn, boolean shadow)
Iterable<TypeElement>	getAnnotatedClassesDependingGenericallyOnThatTriggerAnnotations(Iterable<AnnotationMirror> triggers)
Set<String>	getAnnotatedClassesThatDependentOn(TypeElement type)
TypeElement	getAnnotatedClassForGenClassOnDisk(TypeElement typeElement)
String	getGenAnnotationFqn()
String	getSimpleNameForErrorType(TypeMirror errorType)
CharSequence	getSimpleOrPartiallyQualifiedName(Element typeElement)
Set<String>	getTriggerAnnotationsForMetaTypeElements(Iterable<TypeElement> metaTypeElements)
Map<String,GenTypeElement>	getTypeElementInCurrentRoundByFqn()
Set<org.eclipse.xtext.xbase.lib.Pair<String,String>>	getTypesByGenClassOnWhichThatAnnotatedClassDependsOn(CharSequence annotatedClassFqn)
Set<String>	getTypesOnWhichThatAnnotatedClassDependsOn(CharSequence annotatedClassFqn)
void	handleTypeElementNotFound(CharSequence msg, String typeFqnOrShortname)
void	handleTypeElementNotFound(CharSequence msg, String typeFqnOrShortname, TypeElement annotatedClass)
void	handleTypeElementNotFound(CharSequence msg, TypeElement annotatedClass, org.eclipse.xtext.xbase.lib.Procedures.Procedure1<? super Object> closure)
<T> T	handleTypeElementNotFound(T defaultValue, CharSequence msg, org.eclipse.xtext.xbase.lib.Functions.Function1<? super Object,? extends T> closure)
<T> T	handleTypeElementNotFound(T defaultValue, CharSequence msg, TypeElement annotatedClass, org.eclipse.xtext.xbase.lib.Functions.Function1<? super Object,? extends T> closure)
void	handleTypeElementNotFound(TypeElementNotFoundException e, TypeElement annotatedClass)
boolean	hasGenericDependencyOnTriggerShadowAnnotation(TypeElement annotatedClass, Iterable<AnnotationMirror> triggers)
boolean	hasUnresolvedTypeDependencies(String annotatedClassFqn, Set<String> annotatedClassesInSameCycle) An annotated class is said to have unresolved type dependencies if it depends on types that do not yet exist or that exist but are re-generated in current round.
boolean	isCommitted(String fqn)
boolean	isCommitted(TypeElement typeElement)
boolean	isGenerated(TypeElement typeElement)
boolean	isThrowTypeElementNotFoundExceptionWhenResolvingSimpleTypeNames()
void	load()
void	loadAnnotatedClasses()
void	loadGenericDependencies()
<K,V> void	loadMultiMap(Map<K,Set<V>> map, String fileName, org.eclipse.xtext.xbase.lib.Functions.Function1<? super List<String>,? extends org.eclipse.xtext.xbase.lib.Pair<K,V>> lineParser)
void	markAsGenerated(GenTypeElement typeElement, TypeElement original)
void	persist()
void	persistAnnotatedClasses()
void	persistGenericDependencies()
<K,V> void	persistMultiMap(Map<K,Set<V>> map, String fileName, org.eclipse.xtext.xbase.lib.Functions.Function2<? super K,? super V,? extends List<String>> lineCreator)
void	registerAnnotatedClass(TypeElement annotatedClass, List<org.eclipse.xtext.xbase.lib.Pair<AnnotationMirror,Boolean>> triggers)
void	registerGeneratedTypeElement(GenTypeElement genTypeElement)
void	registerGeneratedTypeElement(GenTypeElement genTypeElement, TypeElement annotatedClass, AnnotationMirror trigger)
boolean	registerMetaTypeElement(TypeElement rootMetaTypeElement, TypeElement triggerAnnotation)
void	registerTypeDependencyForAnnotatedClass(TypeElement annotatedClass, TypeMirror type)
void	registerTypeDependencyForCurrentAnnotatedClass(TypeMirror type)
void	removeDependenciesForAnnotatedClass(String annotatedClassFqn)
void	setThrowTypeElementNotFoundExceptionWhenResolvingSimpleTypeNames(boolean throwTypeElementNotFoundExceptionWhenResolvingSimpleTypeNames)
boolean	startUsingUncomittedGenTypes() For cycle resolution, we need to be able to lookup GenTypes that are "half-done"
boolean	stopUsingUncommitedGenTypes() Stop using uncommitted generated type elements.
String	tryToGetFqnForErrorType(TypeMirror errorType)
Iterable<String>	unresolvableTypesOnWhichThatAnnotatedClassDependsOn(String annotatedClassFqn, boolean ignoreUnknownTypes) Based on the dependencies and generated type elements registered so far, this method examines, on which types the given class depends on that are not to be generated from some other annotated class and thus will never be resolved.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TypesRegistry

public TypesRegistry()

Method Detail

getGenAnnotationFqn

public String getGenAnnotationFqn()

markAsGenerated

public void markAsGenerated(GenTypeElement typeElement,
                            TypeElement original)

isGenerated

public boolean isGenerated(TypeElement typeElement)

findGenAnnotation

public AnnotationMirror findGenAnnotation(TypeElement typeElement)

getAnnotatedClassForGenClassOnDisk

public TypeElement getAnnotatedClassForGenClassOnDisk(TypeElement typeElement)

clearCaches

public void clearCaches()

persist

public void persist()

load

public void load()

persistAnnotatedClasses

public void persistAnnotatedClasses()

loadAnnotatedClasses

public void loadAnnotatedClasses()

persistGenericDependencies

public void persistGenericDependencies()

loadGenericDependencies

public void loadGenericDependencies()

registerAnnotatedClass

public void registerAnnotatedClass(TypeElement annotatedClass,
                                   List<org.eclipse.xtext.xbase.lib.Pair<AnnotationMirror,Boolean>> triggers)

getTypeElementInCurrentRoundByFqn

public Map<String,GenTypeElement> getTypeElementInCurrentRoundByFqn()

annotatedClassesOnWhichThatOneDependsOn

public Set<String> annotatedClassesOnWhichThatOneDependsOn(String annotatedClassFqn)

Based on the dependencies and generated type elements registered so far, this method examines, on which other annotated classes the given class depends on. TODO: This does not handle the "" case of javac yet.

findCyclesInAnnotatedClasses

public Iterable<Set<String>> findCyclesInAnnotatedClasses(Set<String> annotatedClasses)

Returns a list of strongly connected components within the graph of the given annotated classes. See also http://en.wikipedia.org/wiki/Strongly_connected_component.

dependsOnOtherAnnotatedClasses

public boolean dependsOnOtherAnnotatedClasses(String annotatedClassFqn)

dependOnOtherAnnotatedClasses

public boolean dependOnOtherAnnotatedClasses(Set<String> annotatedClassesFqn)

Determines, whether the given annotated classes depend on any other annotated class not within the set.

unresolvableTypesOnWhichThatAnnotatedClassDependsOn

public Iterable<String> unresolvableTypesOnWhichThatAnnotatedClassDependsOn(String annotatedClassFqn,
                                                                            boolean ignoreUnknownTypes)

Based on the dependencies and generated type elements registered so far, this method examines, on which types the given class depends on that are not to be generated from some other annotated class and thus will never be resolved.

With the flag ignoreUnknowTypes the caller can control how to cope with type references where javac only returns "" instead of an ErrorType with the short name of the missing type. If the flag is set to true, it is assumed, that those type can still be resolved (in one of the next rounds). So, types, that depend on an UNKNOWN_TYPE, are not considered as being unresolvable.

dependsOnUnknownTypes

public boolean dependsOnUnknownTypes(CharSequence annotatedClassFqn)

Does the annotated class have type dependencies where javac has only returned the String "error" instead of an ErrorType with the short name of the missing type?

dependsOnUnknownTypes

public boolean dependsOnUnknownTypes(CharSequence annotatedClassFqn,
                                     CharSequence genClassFqn)

dependOnUnknownTypes

public boolean dependOnUnknownTypes(Set<String> annotatedClassesFqn)

registerGeneratedTypeElement

public void registerGeneratedTypeElement(GenTypeElement genTypeElement)

registerGeneratedTypeElement

public void registerGeneratedTypeElement(GenTypeElement genTypeElement,
                                         TypeElement annotatedClass,
                                         AnnotationMirror trigger)

_getSimpleOrPartiallyQualifiedName

protected CharSequence _getSimpleOrPartiallyQualifiedName(TypeElement typeElement)

For top level classes, that method returns the simple name. For inner classes it returns the qualified name without the package name. The rationale behind this is, that at least Eclipse annotation processing provides this kind of names for ErrorTypes.

_getSimpleOrPartiallyQualifiedName

protected CharSequence _getSimpleOrPartiallyQualifiedName(Element element)

_tryToGetFqnForErrorType

protected String _tryToGetFqnForErrorType(GenDeclaredType errorType)

_tryToGetFqnForErrorType

protected String _tryToGetFqnForErrorType(TypeMirror errorType)

_getSimpleNameForErrorType

protected String _getSimpleNameForErrorType(GenDeclaredType errorType)

_getSimpleNameForErrorType

protected String _getSimpleNameForErrorType(TypeMirror errorType)

commitGeneratedTypeElement

public void commitGeneratedTypeElement(GenTypeElement genTypeElement)

DEPRECATED ... As soon as a GenTypeElement is written to disk, it should be removed from registry by calling this method. In next round, the "real" type element will be available, so there is no need for the generated one anymore. (and it cannot be changed anymore as soon as it is written to disk). DEPRECATED The dependencies, where this type is target, are also removed from the registry, since they are resolved (as soon as the next round starts and the type element is available).

removeDependenciesForAnnotatedClass

public void removeDependenciesForAnnotatedClass(String annotatedClassFqn)

isCommitted

public boolean isCommitted(TypeElement typeElement)

isCommitted

public boolean isCommitted(String fqn)

getAnnotatedClassesThatDependentOn

public Set<String> getAnnotatedClassesThatDependentOn(TypeElement type)

_registerTypeDependencyForAnnotatedClass

protected void _registerTypeDependencyForAnnotatedClass(TypeElement annotatedClass,
                                                        DeclaredType type)

_registerTypeDependencyForAnnotatedClass

protected void _registerTypeDependencyForAnnotatedClass(TypeElement annotatedClass,
                                                        TypeMirror type)

registerTypeDependencyForCurrentAnnotatedClass

public void registerTypeDependencyForCurrentAnnotatedClass(TypeMirror type)

hasUnresolvedTypeDependencies

public boolean hasUnresolvedTypeDependencies(String annotatedClassFqn,
                                             Set<String> annotatedClassesInSameCycle)

An annotated class is said to have unresolved type dependencies if it depends on types that do not yet exist or that exist but are re-generated in current round.

When resolving cyclic dependencies, all classes of the cycle must be passed as annotatedClassesInSameCycle. Type dependencies within the cycle are ignored.

getTypesOnWhichThatAnnotatedClassDependsOn

public Set<String> getTypesOnWhichThatAnnotatedClassDependsOn(CharSequence annotatedClassFqn)

getTypesByGenClassOnWhichThatAnnotatedClassDependsOn

public Set<org.eclipse.xtext.xbase.lib.Pair<String,String>> getTypesByGenClassOnWhichThatAnnotatedClassDependsOn(CharSequence annotatedClassFqn)

handleTypeElementNotFound

public void handleTypeElementNotFound(CharSequence msg,
                                      TypeElement annotatedClass,
                                      org.eclipse.xtext.xbase.lib.Procedures.Procedure1<? super Object> closure)

handleTypeElementNotFound

public <T> T handleTypeElementNotFound(T defaultValue,
                                       CharSequence msg,
                                       TypeElement annotatedClass,
                                       org.eclipse.xtext.xbase.lib.Functions.Function1<? super Object,? extends T> closure)

handleTypeElementNotFound

public <T> T handleTypeElementNotFound(T defaultValue,
                                       CharSequence msg,
                                       org.eclipse.xtext.xbase.lib.Functions.Function1<? super Object,? extends T> closure)

handleTypeElementNotFound

public void handleTypeElementNotFound(TypeElementNotFoundException e,
                                      TypeElement annotatedClass)

handleTypeElementNotFound

public void handleTypeElementNotFound(CharSequence msg,
                                      String typeFqnOrShortname)

handleTypeElementNotFound

public void handleTypeElementNotFound(CharSequence msg,
                                      String typeFqnOrShortname,
                                      TypeElement annotatedClass)

startUsingUncomittedGenTypes

public boolean startUsingUncomittedGenTypes()

For cycle resolution, we need to be able to lookup GenTypes that are "half-done"

stopUsingUncommitedGenTypes

public boolean stopUsingUncommitedGenTypes()

Stop using uncommitted generated type elements.

cleanUpTypesAtEndOfRound

public void cleanUpTypesAtEndOfRound()

Removes all type elements from cache.

asTypeElement

public TypeElement asTypeElement(TypeMirror declType)

Get the TypeElement for the type. For ErrorTypes, the generated TypeElement is returned, if available.

hasGenericDependencyOnTriggerShadowAnnotation

public boolean hasGenericDependencyOnTriggerShadowAnnotation(TypeElement annotatedClass,
                                                             Iterable<AnnotationMirror> triggers)

getAnnotatedClassesDependingGenericallyOnThatTriggerAnnotation

public Set<String> getAnnotatedClassesDependingGenericallyOnThatTriggerAnnotation(String triggerFqn,
                                                                                  boolean shadow)

getAnnotatedClassesDependingGenericallyOnThatTriggerAnnotations

public Iterable<TypeElement> getAnnotatedClassesDependingGenericallyOnThatTriggerAnnotations(Iterable<AnnotationMirror> triggers)

findAllTypeElementsWithTriggerAnnotation

public Iterable<TypeElement> findAllTypeElementsWithTriggerAnnotation(String triggerFqn,
                                                                      boolean shadow)

findAllTypeElementsWithTriggerAnnotation

public Iterable<TypeElement> findAllTypeElementsWithTriggerAnnotation(TypeElement annotatedClass,
                                                                      String triggerFqn,
                                                                      boolean shadow)

findAllTypeElementsWithTriggerAnnotation

public Iterable<TypeElement> findAllTypeElementsWithTriggerAnnotation(String clienAnnotatedClassFqn,
                                                                      String triggerFqn,
                                                                      boolean shadow)

findTypeElement

public TypeElement findTypeElement(String typeFqn)

findGenTypeElementForShortName

public TypeElement findGenTypeElementForShortName(String shortname)

findGenTypeElementForFqn

public TypeElement findGenTypeElementForFqn(String fqn)

findTypeInCurrentGeneratedClass

protected TypeElement findTypeInCurrentGeneratedClass(String typeFqnOrShortname)

findNestedElement

public Element findNestedElement(Element e,
                                 String[] path)

registerMetaTypeElement

public boolean registerMetaTypeElement(TypeElement rootMetaTypeElement,
                                       TypeElement triggerAnnotation)

getTriggerAnnotationsForMetaTypeElements

public Set<String> getTriggerAnnotationsForMetaTypeElements(Iterable<TypeElement> metaTypeElements)

persistMultiMap

public <K,V> void persistMultiMap(Map<K,Set<V>> map,
                                  String fileName,
                                  org.eclipse.xtext.xbase.lib.Functions.Function2<? super K,? super V,? extends List<String>> lineCreator)

loadMultiMap

public <K,V> void loadMultiMap(Map<K,Set<V>> map,
                               String fileName,
                               org.eclipse.xtext.xbase.lib.Functions.Function1<? super List<String>,? extends org.eclipse.xtext.xbase.lib.Pair<K,V>> lineParser)

getSimpleOrPartiallyQualifiedName

public CharSequence getSimpleOrPartiallyQualifiedName(Element typeElement)

tryToGetFqnForErrorType

public String tryToGetFqnForErrorType(TypeMirror errorType)

getSimpleNameForErrorType

public String getSimpleNameForErrorType(TypeMirror errorType)

registerTypeDependencyForAnnotatedClass

public void registerTypeDependencyForAnnotatedClass(TypeElement annotatedClass,
                                                    TypeMirror type)

isThrowTypeElementNotFoundExceptionWhenResolvingSimpleTypeNames

@Pure
public boolean isThrowTypeElementNotFoundExceptionWhenResolvingSimpleTypeNames()

setThrowTypeElementNotFoundExceptionWhenResolvingSimpleTypeNames

public void setThrowTypeElementNotFoundExceptionWhenResolvingSimpleTypeNames(boolean throwTypeElementNotFoundExceptionWhenResolvingSimpleTypeNames)