Refine search
public <T> BackedAnnotatedType<T> getBackedAnnotatedType(final Class<T> rawType, final Type baseType, final String bdaId, final String suffix) { try { return backedAnnotatedTypes.getCastValue(new TypeHolder<T>(rawType, baseType, bdaId, suffix)); } catch (RuntimeException e) { if (e instanceof TypeNotPresentException || e instanceof ResourceLoadingException) { BootstrapLogger.LOG.exceptionWhileLoadingClass(rawType.getName(), e); throw new ResourceLoadingException("Exception while loading class " + rawType.getName(), e); } throw e; } catch (Error e) { if(e instanceof NoClassDefFoundError || e instanceof LinkageError) { throw new ResourceLoadingException("Error while loading class " + rawType.getName(), e); } BootstrapLogger.LOG.errorWhileLoadingClass(rawType.getName(), e); throw e; } }
@Override public boolean equals(Object obj) { if (obj instanceof TypeHolder<?>) { TypeHolder<?> that = (TypeHolder<?>) obj; return Objects.equals(this.getBaseType(), that.getBaseType()) && Objects.equals(this.getBdaId(), that.getBdaId()) && Objects.equals(this.getSuffix(), that.getSuffix()); } return false; }
@Override public int hashCode() { return Objects.hash(this.getBaseType(), this.getBdaId(), this.getSuffix()); }
@Override public BackedAnnotatedType<?> apply(TypeHolder<?> typeHolder) { // make sure declaring class (if any) is loadable before loading this class Reflections.checkDeclaringClassLoadable(typeHolder.getRawType()); BackedAnnotatedType<?> type = BackedAnnotatedType.of(typeHolder.getRawType(), typeHolder.getBaseType(), cache, reflectionCache, contextId, typeHolder.getBdaId(), typeHolder.getSuffix()); return updateLookupTable(type); } }
@Override public BackedAnnotatedType<?> apply(TypeHolder<?> typeHolder) { // make sure declaring class (if any) is loadable before loading this class Reflections.checkDeclaringClassLoadable(typeHolder.getRawType()); BackedAnnotatedType<?> type = BackedAnnotatedType.of(typeHolder.getRawType(), typeHolder.getBaseType(), cache, reflectionCache, contextId, typeHolder.getBdaId(), typeHolder.getSuffix()); return updateLookupTable(type); } }
@Override public BackedAnnotatedType<?> apply(TypeHolder<?> typeHolder) { BackedAnnotatedType<?> type = BackedAnnotatedType.of(typeHolder.getRawType(), typeHolder.getBaseType(), cache, reflectionCache, contextId, typeHolder.getBdaId(), typeHolder.getSuffix()); return updateLookupTable(type); } }
@Override public BackedAnnotatedType<?> apply(TypeHolder<?> typeHolder) { // make sure declaring class (if any) is loadable before loading this class Reflections.checkDeclaringClassLoadable(typeHolder.getRawType()); BackedAnnotatedType<?> type = BackedAnnotatedType.of(typeHolder.getRawType(), typeHolder.getBaseType(), cache, reflectionCache, contextId, typeHolder.getBdaId(), typeHolder.getSuffix()); return updateLookupTable(type); } }
@Override public BackedAnnotatedType<?> apply(TypeHolder<?> typeHolder) { // make sure declaring class (if any) is loadable before loading this class Reflections.checkDeclaringClassLoadable(typeHolder.getRawType()); BackedAnnotatedType<?> type = BackedAnnotatedType.of(typeHolder.getRawType(), typeHolder.getBaseType(), cache, reflectionCache, contextId, typeHolder.getBdaId(), typeHolder.getSuffix()); return updateLookupTable(type); } }
public <T> void disposeBackedAnnotatedType(Class<T> rawType, String bdaId, String suffix) { TypeHolder<T> typeHolder = new TypeHolder<>(rawType, rawType, bdaId, suffix); BackedAnnotatedType<T> annotatedType = cast(this.backedAnnotatedTypes.getValueIfPresent(typeHolder)); if (annotatedType != null) { this.backedAnnotatedTypes.invalidate(typeHolder); this.slimAnnotatedTypesById.remove(annotatedType.getIdentifier()); this.enhancedAnnotatedTypes.invalidate(annotatedType); } }
@Override public BackedAnnotatedType<?> apply(TypeHolder<?> typeHolder) { // make sure declaring class (if any) is loadable before loading this class Reflections.checkDeclaringClassLoadable(typeHolder.getRawType()); BackedAnnotatedType<?> type = BackedAnnotatedType.of(typeHolder.getRawType(), typeHolder.getBaseType(), cache, reflectionCache, contextId, typeHolder.getBdaId(), typeHolder.getSuffix()); return updateLookupTable(type); } }
public <T> void disposeBackedAnnotatedType(Class<T> rawType, String bdaId, String suffix) { TypeHolder<T> typeHolder = new TypeHolder<>(rawType, rawType, bdaId, suffix); BackedAnnotatedType<T> annotatedType = cast(this.backedAnnotatedTypes.getValueIfPresent(typeHolder)); if (annotatedType != null) { this.backedAnnotatedTypes.invalidate(typeHolder); this.slimAnnotatedTypesById.remove(annotatedType.getIdentifier()); this.enhancedAnnotatedTypes.invalidate(annotatedType); } }
public <T> void disposeBackedAnnotatedType(Class<T> rawType, String bdaId, String suffix) { TypeHolder<T> typeHolder = new TypeHolder<>(rawType, rawType, bdaId, suffix); BackedAnnotatedType<T> annotatedType = cast(this.backedAnnotatedTypes.getValueIfPresent(typeHolder)); if (annotatedType != null) { this.backedAnnotatedTypes.invalidate(typeHolder); this.slimAnnotatedTypesById.remove(annotatedType.getIdentifier()); this.enhancedAnnotatedTypes.invalidate(annotatedType); } }
public <T> void disposeBackedAnnotatedType(Class<T> rawType, String bdaId, String suffix) { TypeHolder<T> typeHolder = new TypeHolder<>(rawType, rawType, bdaId, suffix); BackedAnnotatedType<T> annotatedType = cast(this.backedAnnotatedTypes.getValueIfPresent(typeHolder)); if (annotatedType != null) { this.backedAnnotatedTypes.invalidate(typeHolder); this.slimAnnotatedTypesById.remove(annotatedType.getIdentifier()); this.enhancedAnnotatedTypes.invalidate(annotatedType); } }
public <T> void disposeBackedAnnotatedType(Class<T> rawType, String bdaId, String suffix) { TypeHolder<T> typeHolder = new TypeHolder<>(rawType, rawType, bdaId, suffix); BackedAnnotatedType<T> annotatedType = cast(this.backedAnnotatedTypes.getValueIfPresent(typeHolder)); if (annotatedType != null) { this.backedAnnotatedTypes.invalidate(typeHolder); this.slimAnnotatedTypesById.remove(annotatedType.getIdentifier()); this.enhancedAnnotatedTypes.invalidate(annotatedType); } }
public <T> void disposeBackedAnnotatedType(Class<T> rawType, String bdaId, String suffix) { TypeHolder<T> typeHolder = new TypeHolder<>(rawType, rawType, bdaId, suffix); BackedAnnotatedType<T> annotatedType = cast(this.backedAnnotatedTypes.getValueIfPresent(typeHolder)); if (annotatedType != null) { this.backedAnnotatedTypes.invalidate(typeHolder); this.slimAnnotatedTypesById.remove(annotatedType.getIdentifier()); this.enhancedAnnotatedTypes.invalidate(annotatedType); } }
public <T> BackedAnnotatedType<T> getBackedAnnotatedType(final Class<T> rawType, final Type baseType, final String bdaId, final String suffix) { try { return backedAnnotatedTypes.getCastValue(new TypeHolder<T>(rawType, baseType, bdaId, suffix)); } catch (RuntimeException e) { if (e instanceof TypeNotPresentException || e instanceof ResourceLoadingException) { BootstrapLogger.LOG.exceptionWhileLoadingClass(rawType.getName(), e); throw new ResourceLoadingException("Exception while loading class " + rawType.getName(), e); } throw e; } catch (Error e) { if(e instanceof NoClassDefFoundError || e instanceof LinkageError) { throw new ResourceLoadingException("Error while loading class " + rawType.getName(), e); } BootstrapLogger.LOG.errorWhileLoadingClass(rawType.getName(), e); throw e; } }
public <T> BackedAnnotatedType<T> getBackedAnnotatedType(final Class<T> rawType, final Type baseType, final String bdaId, final String suffix) { try { return backedAnnotatedTypes.getCastValue(new TypeHolder<T>(rawType, baseType, bdaId, suffix)); } catch (RuntimeException e) { if (e instanceof TypeNotPresentException || e instanceof ResourceLoadingException) { BootstrapLogger.LOG.exceptionWhileLoadingClass(rawType.getName(), e); throw new ResourceLoadingException("Exception while loading class " + rawType.getName(), e); } throw e; } catch (Error e) { if(e instanceof NoClassDefFoundError || e instanceof LinkageError) { throw new ResourceLoadingException("Error while loading class " + rawType.getName(), e); } BootstrapLogger.LOG.errorWhileLoadingClass(rawType.getName(), e); throw e; } }
public <T> BackedAnnotatedType<T> getBackedAnnotatedType(final Class<T> rawType, final Type baseType, final String bdaId, final String suffix) { try { return backedAnnotatedTypes.getCastValue(new TypeHolder<T>(rawType, baseType, bdaId, suffix)); } catch (RuntimeException e) { if (e instanceof TypeNotPresentException || e instanceof ResourceLoadingException) { BootstrapLogger.LOG.exceptionWhileLoadingClass(rawType.getName(), e); throw new ResourceLoadingException("Exception while loading class " + rawType.getName(), e); } throw e; } catch (Error e) { if(e instanceof NoClassDefFoundError || e instanceof LinkageError) { throw new ResourceLoadingException("Error while loading class " + rawType.getName(), e); } BootstrapLogger.LOG.errorWhileLoadingClass(rawType.getName(), e); throw e; } }
public <T> BackedAnnotatedType<T> getBackedAnnotatedType(final Class<T> rawType, final Type baseType, final String bdaId, final String suffix) { try { return backedAnnotatedTypes.getCastValue(new TypeHolder<T>(rawType, baseType, bdaId, suffix)); } catch (RuntimeException e) { if (e instanceof TypeNotPresentException || e instanceof ResourceLoadingException) { BootstrapLogger.LOG.exceptionWhileLoadingClass(rawType.getName(), e); throw new ResourceLoadingException("Exception while loading class " + rawType.getName(), e); } throw e; } catch (Error e) { if(e instanceof NoClassDefFoundError || e instanceof LinkageError) { throw new ResourceLoadingException("Error while loading class " + rawType.getName(), e); } BootstrapLogger.LOG.errorWhileLoadingClass(rawType.getName(), e); throw e; } }
public <T> BackedAnnotatedType<T> getBackedAnnotatedType(final Class<T> rawType, final Type baseType, final String bdaId, final String suffix) { try { return backedAnnotatedTypes.getCastValue(new TypeHolder<T>(rawType, baseType, bdaId, suffix)); } catch (RuntimeException e) { if (e instanceof TypeNotPresentException || e instanceof ResourceLoadingException) { BootstrapLogger.LOG.exceptionWhileLoadingClass(rawType.getName(), e); throw new ResourceLoadingException("Exception while loading class " + rawType.getName(), e); } throw e; } catch (Error e) { if(e instanceof NoClassDefFoundError || e instanceof LinkageError) { throw new ResourceLoadingException("Error while loading class " + rawType.getName(), e); } BootstrapLogger.LOG.errorWhileLoadingClass(rawType.getName(), e); throw e; } }