public void pushToPermanentCache(final String fullyQualifiedName, final MetaClass clazz) { logger.trace("Creating new permanent " + clazz.getClass().getSimpleName() + " cache entry for " + fullyQualifiedName); pushCache(fullyQualifiedName, clazz); PERMANENT_CLASS_CACHE.put(fullyQualifiedName, PRIMARY_CLASS_CACHE.get(fullyQualifiedName)); }
public static boolean isKnownType(final String fqcn) { return getMetaClassCache().isKnownType(fqcn); }
public void updateCache(Map<String, MetaClass> mapToPush) { logger.debug("updateCache called for " + mapToPush.size() + " MetaClasses."); addNewOrUpdatedToInvalidated(mapToPush); addRemoved(); }
public static boolean isChangedOrDeleted(final String fqcn) { return getMetaClassCache().getAllDeletedClasses().contains(fqcn) || getMetaClassCache().isNewOrUpdated(fqcn); }
private static MetaClass createOrGet(final String clsName, final boolean erased) { if (clsName == null) return null; MetaClass mCls; if (erased) { mCls = getMetaClassCache().getErased(clsName); if (mCls == null) { getMetaClassCache().pushErasedCache(clsName, mCls = JavaReflectionClass.newUncachedInstance(loadClass(clsName), erased)); } } else { mCls = getMetaClassCache().get(clsName); if (mCls == null) { getMetaClassCache().pushCache(clsName, mCls = JavaReflectionClass.newUncachedInstance(loadClass(clsName), erased)); } } return mCls; }
private static MetaClass createOrGet(final Class cls, final Type type) { if (cls == null) return null; if (type != null) { if (cls.getTypeParameters() != null) { return JavaReflectionClass.newUncachedInstance(cls, type); } if (!getMetaClassCache().isKnownErasedType(cls.getName())) { final MetaClass javaReflectionClass = JavaReflectionClass.newUncachedInstance(cls, type); addLookups(cls, javaReflectionClass); return javaReflectionClass; } return getMetaClassCache().getErased(cls.getName()); } else { MetaClass mCls; mCls = getMetaClassCache().get(cls.getName()); if (mCls == null) { getMetaClassCache().pushCache(cls.getName(), mCls = JavaReflectionClass.newUncachedInstance(cls)); } return mCls; } }
} else if (!cache.isKnownType(clazz.getFullyQualifiedName())) { cache.pushCache(clazz); } else if (!cache.isKnownType(clazz.getFullyQualifiedName())) { cache.pushCache(clazz); cache.updateCache(classesToPush);
public static Collection<MetaClass> getAllCachedClasses() { return getMetaClassCache().getAllCached(); }
public static Set<String> getAllDeletedClasses() { return getMetaClassCache().getAllDeletedClasses(); }
private void addNewOrUpdatedToInvalidated(Map<String, MetaClass> mapToPush) { for (final Entry<String, MetaClass> entry : mapToPush.entrySet()) { logger.trace("Creating new " + entry.getValue().getClass().getSimpleName() + " cache entry for " + entry.getKey()); final CacheEntry newCacheEntry = createCacheEntry(entry.getValue()); PRIMARY_CLASS_CACHE.put(entry.getKey(), newCacheEntry); final CacheEntry previousCacheEntry = backupClassCache.get(entry.getKey()); if (previousCacheEntry == null || previousCacheEntry.hashCode != newCacheEntry.hashCode) { logger.trace("Old cache entry replaced for " + entry.getKey()); invalidated.add(entry.getKey()); if (previousCacheEntry == null) { added.add(entry.getValue()); } } } }
@Before @SuppressWarnings({ "unchecked", "rawtypes" }) public void setup() { MetaClassFactory.getMetaClassCache().clear(); FactoryGenerator.setDependencyGraph(null); final QualifierFactory qualFactory = new DefaultQualifierFactory(); when(injContext.getQualifierFactory()).thenReturn(qualFactory); when(injContext.getInjectableProviders()).thenReturn(HashMultimap.create()); when(injContext.getExactTypeInjectableProviders()).thenReturn(HashMultimap.create()); when(injContext.getAnnotationsForElementType(DependentBean)).thenReturn(Arrays.asList(Dependent.class)); when(injContext.getAnnotationsForElementType(NormalScopedBean)).thenReturn(Arrays.asList(ApplicationScoped.class)); when(injContext.getAnnotationsForElementType(PseudoScopedBean)).thenReturn(Arrays.asList(Singleton.class, Dependent.class)); when(injContext.getAnnotationsForElementType(AlternativeBean)).thenReturn(Arrays.asList(Alternative.class)); when(injContext.getAnnotationsForElementType(InjectionPoint)).thenReturn(Arrays.asList(Inject.class)); when(injContext.getAnnotationsForElementType(ProducerElement)).thenReturn(Arrays.asList(IOCProducer.class)); when(injContext.getAnnotationsForElementType(Provider)).thenReturn(Arrays.asList(IOCProvider.class)); when(injContext.isWhitelisted(any())).thenReturn(true); when(injContext.isBlacklisted(any())).thenReturn(false); final ClassStructureBuilder<?> classBuilder = ClassBuilder .define("org.jboss.errai.ioc.FakeBootstrapperImpl") .publicScope() .implementsInterface(Bootstrapper.class) .body(); final BlockBuilder blockBuilder = classBuilder.publicMethod(ContextManager.class, "bootstrap").body(); when(procContext.getBlockBuilder()).thenReturn(blockBuilder); when(procContext.getBootstrapBuilder()).thenReturn(classBuilder); when(procContext.getBootstrapClass()).thenReturn(classBuilder.getClassDefinition()); processor = new IOCProcessor(injContext); }
private static MetaClass createOrGet(final String clsName, final boolean erased) { if (clsName == null) return null; MetaClass mCls; if (erased) { mCls = getMetaClassCache().getErased(clsName); if (mCls == null) { getMetaClassCache().pushErasedCache(clsName, mCls = JavaReflectionClass.newUncachedInstance(loadClass(clsName), erased)); } } else { mCls = getMetaClassCache().get(clsName); if (mCls == null) { getMetaClassCache().pushCache(clsName, mCls = JavaReflectionClass.newUncachedInstance(loadClass(clsName), erased)); } } return mCls; }
private static MetaClass createOrGet(final Class cls, final Type type) { if (cls == null) return null; if (type != null) { if (cls.getTypeParameters() != null) { return JavaReflectionClass.newUncachedInstance(cls, type); } if (!getMetaClassCache().isKnownErasedType(cls.getName())) { final MetaClass javaReflectionClass = JavaReflectionClass.newUncachedInstance(cls, type); addLookups(cls, javaReflectionClass); return javaReflectionClass; } return getMetaClassCache().getErased(cls.getName()); } else { MetaClass mCls; mCls = getMetaClassCache().get(cls.getName()); if (mCls == null) { getMetaClassCache().pushCache(cls.getName(), mCls = JavaReflectionClass.newUncachedInstance(cls)); } return mCls; } }
} else if (!cache.isKnownType(clazz.getFullyQualifiedName())) { cache.pushCache(clazz); } else if (!cache.isKnownType(clazz.getFullyQualifiedName())) { cache.pushCache(clazz); cache.updateCache(classesToPush);
public static boolean isChangedOrDeleted(final String fqcn) { return getMetaClassCache().getAllDeletedClasses().contains(fqcn) || getMetaClassCache().isNewOrUpdated(fqcn); }
public static Collection<MetaClass> getAllCachedClasses() { return getMetaClassCache().getAllCached(); }
public static Set<String> getAllDeletedClasses() { return getMetaClassCache().getAllDeletedClasses(); }
private void addNewOrUpdatedToInvalidated(Map<String, MetaClass> mapToPush) { for (final Entry<String, MetaClass> entry : mapToPush.entrySet()) { logger.trace("Creating new " + entry.getValue().getClass().getSimpleName() + " cache entry for " + entry.getKey()); final CacheEntry newCacheEntry = createCacheEntry(entry.getValue()); PRIMARY_CLASS_CACHE.put(entry.getKey(), newCacheEntry); final CacheEntry previousCacheEntry = backupClassCache.get(entry.getKey()); if (previousCacheEntry == null || previousCacheEntry.hashCode != newCacheEntry.hashCode) { logger.trace("Old cache entry replaced for " + entry.getKey()); invalidated.add(entry.getKey()); if (previousCacheEntry == null) { added.add(entry.getValue()); } } } }
public void pushToPermanentCache(final String fullyQualifiedName, final MetaClass clazz) { logger.trace("Creating new permanent " + clazz.getClass().getSimpleName() + " cache entry for " + fullyQualifiedName); pushCache(fullyQualifiedName, clazz); PERMANENT_CLASS_CACHE.put(fullyQualifiedName, PRIMARY_CLASS_CACHE.get(fullyQualifiedName)); }
public void updateCache(Map<String, MetaClass> mapToPush) { logger.debug("updateCache called for " + mapToPush.size() + " MetaClasses."); addNewOrUpdatedToInvalidated(mapToPush); addRemoved(); }