Chapter 9. The ClassLoading Layer

public abstract class ClassLoaderPolicy extends BaseClassLoaderPolicy {
    public DelegateLoader getExported()

        public String[] getPackageNames()

        protected List<? extends DelegateLoader> getDelegates()

        protected boolean isImportAll()
        protected boolean isCacheable()
        protected boolean isBlackListable()

        public abstract URL getResource(String path);

    public InputStream getResourceAsStream(String path)

        public abstract void getResources(String name, Set<URL> urls) throws IOException;

    protected ProtectionDomain getProtectionDomain(String className, String path)
        public PackageInformation getPackageInformation(String packageName)
        public PackageInformation getClassPackageInformation(String className, String packageName)

        protected ClassLoader isJDKRequest(String name)
        }
}
			
			
			

public class RegexpClassLoaderPolicy extends ClassLoaderPolicy {
    private VirtualFile[] roots;
    private String[] packageNames;

    public RegexpClassLoaderPolicy(VirtualFile[] roots)
    {
	this.roots = roots;
    }

    @Override
	public String[] getPackageNames()
    {
	if (packageNames == null)
	    {
		Set<String> exportedPackages = PackageVisitor.determineAllPackages(roots, null, ExportAll.NON_EMPTY, null, null, null);
		packageNames = exportedPackages.toArray(new String[exportedPackages.size()]);
	    }
	return packageNames;
    }

    protected Pattern createPattern(String regexp)
    {
	boolean outside = true;
	StringBuilder builder = new StringBuilder();
	for (int i = 0; i < regexp.length(); i++)
	    {
		char ch = regexp.charAt(i);
		if ((ch == '[' || ch == ']' || ch == '.') && escaped(regexp, i) == false)
		    {
			switch (ch)
			    {
			    case '[' : outside = false; break;
			    case ']' : outside = true; break;
			    case '.' : if (outside) builder.append("\\"); break;
			    }
		    }

		builder.append(ch);
	    }
	return Pattern.compile(builder.toString());
    }

    protected boolean escaped(String regexp, int i)
    {
	return i > 0 && regexp.charAt(i - 1) == '\\';
    }

    public URL getResource(String path)
    {
	Pattern pattern = createPattern(path);
	for (VirtualFile root : roots)
	    {
		URL url = findURL(root, root, pattern);
		if (url != null)
		    return url;
	    }
	return null;
    }

    private URL findURL(VirtualFile root, VirtualFile file, Pattern pattern)
    {
	try
	    {
		String path = AbstractStructureDeployer.getRelativePath(root, file);
		Matcher matcher = pattern.matcher(path);
		if (matcher.matches())
		    return file.toURL();

		List<VirtualFile> children = file.getChildren();
		for (VirtualFile child : children)
		    {
			URL url = findURL(root, child, pattern);
			if (url != null)
			    return url;
		    }

		return null;
	    }
	catch (Exception e)
	    {
		throw new RuntimeException(e);
	    }
    }

    public void getResources(String name, Set<URL> urls) throws IOException
    {
	Pattern pattern = createPattern(name);
	for (VirtualFile root : roots)
	    {
		RegexpVisitor visitor = new RegexpVisitor(root, pattern);
		root.visit(visitor);
		urls.addAll(visitor.getUrls());
	    }
    }

    private static class RegexpVisitor implements VirtualFileVisitor
    {
	private VirtualFile root;
	private Pattern pattern;
	private Set<URL> urls = new HashSet<URL>();

	private RegexpVisitor(VirtualFile root, Pattern pattern)
	{
	    this.root = root;
	    this.pattern = pattern;
	}

	public VisitorAttributes getAttributes()
	{
	    return VisitorAttributes.RECURSE_LEAVES_ONLY;
	}

	public void visit(VirtualFile file)
	{
	    try
		{
		    String path = AbstractStructureDeployer.getRelativePath(root, file);
		    Matcher matcher = pattern.matcher(path);
		    if (matcher.matches())
			urls.add(file.toURL());
		}
	    catch (Exception e)
		{
		    throw new RuntimeException(e);
		}
	}

	public Set<URL> getUrls()
	{
	    return urls;
	}
    }
}
			
			
			

public class RegexpService extends PrintService {
    public void start() throws Exception
    {
	System.out.println();

	ClassLoader cl = getClass().getClassLoader();
	Enumeration<URL> urls = cl.getResources("config/[^.]+\\.[^.]{1,4}");
	while (urls.hasMoreElements())
	    {
		URL url = urls.nextElement();
		print(url.openStream(), url.toExternalForm());
	    }
    }
}
			
			
			

public class CrypterClassLoaderPolicy extends VFSClassLoaderPolicy {
    private Crypter crypter;

    public CrypterClassLoaderPolicy(String name, VirtualFile[] roots, VirtualFile[] excludedRoots, Crypter crypter) {
        super(name, roots, excludedRoots);
        this.crypter = crypter;
    }

    @Override
    public URL getResource(String path) {
        try
            {
                URL resource = super.getResource(path);
                return wrap(resource);
            }
        catch (IOException e)
            {
                throw new RuntimeException(e);
            }
    }

    @Override
    public InputStream getResourceAsStream(String path) {
        InputStream stream = super.getResourceAsStream(path);
        return crypter.crypt(stream);
    }

    @Override
    public void getResources(String name, Set<URL> urls) throws IOException {
        super.getResources(name, urls);
        Set<URL> temp = new HashSet<URL>(urls.size());
        for (URL url : urls)
            {
                temp.add(wrap(url));
            }
        urls.clear();
        urls.addAll(temp);
    }

    protected URL wrap(URL url) throws IOException {
        return new URL(url.getProtocol(), url.getHost(), url.getPort(), url.getFile(), new CrypterURLStreamHandler(crypter));
    }
}
			
			
			

public class EncryptedService extends PrintService {
    public void start() throws Exception
    {
	ClassLoader cl = getClass().getClassLoader();

	URL url = cl.getResource("config/settings.txt");
	if (url == null)
	    throw new IllegalArgumentException("No such settings.txt.");

	InputStream is = url.openStream();
	print(is, "Printing settings:\n");

	is = cl.getResourceAsStream("config/properties.xml");
	if (is == null)
	    throw new IllegalArgumentException("No such properties.xml.");

	print(is, "\nPrinting properties:\n");
    }
}