public static BuildMetaClass makeProxy(final MetaClass toProxy,
final String privateAccessorType,
final Map<String, ProxyProperty> proxyProperties,
final Map<MetaMethod, Map<WeaveType, Collection<Statement>>> weavingStatements) {
return makeProxy(
PrivateAccessUtil.condensify(toProxy.getPackageName()) + "_" + toProxy.getName() + "_proxy",
toProxy,
privateAccessorType, proxyProperties, weavingStatements);
}
public static ReachableTypes getAllReachableClasses(final GeneratorContext context) {
if (System.getProperty(SYSPROP_USE_REACHABILITY_ANALYSIS) == null
|| !Boolean.getBoolean(SYSPROP_USE_REACHABILITY_ANALYSIS)) {
log.warn("reachability analysis disabled. errai may generate unnecessary code.");
log.warn(
"enable reachability analysis with -D" + SYSPROP_USE_REACHABILITY_ANALYSIS + "=true");
return ReachableTypes.EVERYTHING_REACHABLE_INSTANCE;
}
ReachabilityCache cache;
if (reachabilityCache == null || (cache = reachabilityCache.get()) == null) {
reachabilityCache = new SoftReference<ReachabilityCache>(cache = new ReachabilityCache());
}
if (cache.isCacheValid(context)) {
return cache.getCache(context);
}
final EnvironmentConfig config = getEnvironmentConfig();
long time = System.currentTimeMillis();
final Set<String> packages = new HashSet<String>();
if (isJUnitTest()) {
packages.addAll(RebindUtils.findTranslatablePackagesInModule(context));
} else {
packages.addAll(RebindUtils.getOuterTranslatablePackages(context));
}
class Reachability {
private final Set<String> packages;
private final Set<String> negativeHits = new HashSet<String>();
Reachability(final Set<String> packages) {
this.packages = new HashSet<String>(packages);
}
public boolean isReachablePackage(final String pkg) {
if (pkg == null || packages.contains(pkg)) {
return true;
}
if (negativeHits.contains(pkg)) {
return false;
}
for (final String p : packages) {
if (pkg.startsWith(p)) {
packages.add(pkg);
return true;
}
}
negativeHits.add(pkg);
return false;
}
}
final Set<String> allDependencies =
Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(100));
final Collection<MetaClass> allCachedClasses = MetaClassFactory.getAllCachedClasses();
final ClassLoader classLoader = EnvUtil.class.getClassLoader();
final ExecutorService executor =
Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
final Reachability reachability = new Reachability(packages);
try {
for (final MetaClass mc : allCachedClasses) {
String fullyQualifiedName = mc.getFullyQualifiedName();
int splitPoint;
while ((splitPoint = fullyQualifiedName.lastIndexOf('$')) != -1) {
fullyQualifiedName = fullyQualifiedName.substring(0, splitPoint);
}
if (mc.isPrimitive() || mc.isArray()) {
continue;
} else if (isReachabilityExcluded(mc.getPackageName())) {
continue;
} else if (!config.getExplicitTypes().contains(fullyQualifiedName)
&& !reachability.isReachablePackage(mc.getPackageName())) {
continue;
}
final URL resource =
classLoader.getResource(fullyQualifiedName.replaceAll("\\.", "/") + ".java");
if (resource != null) {
InputStream stream = null;
try {
stream = new BufferedInputStream(resource.openStream());
final byte[] readBuffer = new byte[stream.available()];
stream.read(readBuffer);
if (log.isDebugEnabled()) {
log.debug("scanning " + fullyQualifiedName + " for reachable types ...");
}
executor.execute(new ReachabilityRunnable(readBuffer, allDependencies));
} catch (IOException e) {
log.warn("could not open resource: " + resource.getFile());
} finally {
if (stream != null) {
stream.close();
}
}
} else {
log.warn("source for " + fullyQualifiedName + " is missing.");
}
}
} catch (Throwable e) {
e.printStackTrace();
}
try {
executor.shutdown();
executor.awaitTermination(60, TimeUnit.MINUTES);
} catch (InterruptedException e) {
log.warn("the reachability analysis was interrupted", e);
cache.putCache(context, ReachableTypes.EVERYTHING_REACHABLE_INSTANCE);
return ReachableTypes.EVERYTHING_REACHABLE_INSTANCE;
}
if (log.isDebugEnabled()) {
log.debug("*** REACHABILITY ANALYSIS (production mode: " + EnvUtil.isProdMode() + ") ***");
for (final String s : allDependencies) {
log.debug(" -> " + s);
}
time = System.currentTimeMillis() - time;
log.debug("*** END OF REACHABILITY ANALYSIS (" + time + "ms) *** ");
}
final ReachableTypes reachableTypes = new ReachableTypes(allDependencies, true);
cache.putCache(context, reachableTypes);
return reachableTypes;
}