[Jython-checkins] CVS: jython/Lib/jxxload_help DiscardHelp.java,NONE,1.1 PackageManager.java,NONE,1.1 PathVFS.java,NONE,1.1 PathVFSJavaLoader.java,NONE,1.1

[Samuele P. <ped...@us...>]

Update of /cvsroot/jython/jython/Lib/jxxload_help
In directory usw-pr-cvs1:/tmp/cvs-serv22086

Added Files:
	DiscardHelp.java PackageManager.java PathVFS.java 
	PathVFSJavaLoader.java 
Log Message:
experimental java classes reload support (0.1).


--- NEW FILE ---
// Copyright 2000 Samuele Pedroni

package jxxload_help;

import org.python.core.PyJavaClass;

public class DiscardHelp extends Object {

  private DiscardHelp() {
  }

  private static boolean check(Class c,ClassLoader loader,java.util.Vector interfaces) {
    try {
        Class s = c;
        do {
            if (s.getClassLoader() == loader) return true;
            s = s.getSuperclass();
        } while (s != null);
        
        for(java.util.Enumeration enum=interfaces.elements(); enum.hasMoreElements();) {
            Class intf = (Class)enum.nextElement();
            if (intf.isAssignableFrom(c)) return true;
        }
        
    } catch(SecurityException e) {
    }
    return false;
  }

  // clearly not thread safe
  public static void discard(ClassLoader loader,java.util.Vector interfaces) {
    
    org.python.core.InternalTables tbl = PyJavaClass.getInternalTables();
    
    tbl._beginCanonical();
    
    PyJavaClass jc;
    while ((jc = (PyJavaClass)tbl._next()) != null ) {
        Class c = (Class)jc.__tojava__(Class.class);
        if(check(c,loader,interfaces)) tbl._flushCurrent();    
    }
    
    tbl._beginOverAdapterClasses();
    
    Class c;
    
    while ((c = (Class)tbl._next()) != null) {
        if(interfaces.contains(c)) tbl._flushCurrent();
    }
    
    tbl._beginOverAdapters();
    
    while ((c = (Class)tbl._next()) != null) {
        if(interfaces.contains(c)) tbl._flushCurrent();
    }
    
  }

}
--- NEW FILE ---
// Copyright 2000 Samuele Pedroni

package jxxload_help;

public class PackageManager extends org.python.core.PathPackageManager {
    
    private ClassLoader parent;
    private ClassLoader loader;
    public PathVFS vfs;
    
    public synchronized ClassLoader getLoader() {
        if (loader == null) loader = new PathVFSJavaLoader(vfs,parent);
        return loader;
    }
    
    public synchronized void resetLoader() {
        loader = null;
    }
    
    // ??pending add cache support?
    public PackageManager(org.python.core.PyList path,ClassLoader parent) { 
        vfs = new PathVFS();
        this.parent = parent;
        
        for (int i = 0; i < path.__len__(); i++) {
            String entry = path.__finditem__(i).toString();
            if (entry.endsWith(".jar") || entry.endsWith(".zip")) {
                addJarToPackages(new java.io.File(entry),false);
            } else {
                java.io.File dir = new java.io.File(entry);
                if (entry.length() == 0 || dir.isDirectory()) addDirectory(dir);
            }
            vfs.addVFS(entry);
        }
    }

    public Class findClass(String pkg,String name,String reason) {
        if (pkg != null && pkg.length()>0) name = pkg + '.' + name;
        try {
            return getLoader().loadClass(name);
        } 
        catch(ClassNotFoundException e) {
            return null;
        }
        catch (LinkageError e) {
            throw org.python.core.Py.JavaError(e);
        }
    }
  
}
--- NEW FILE ---
// Copyright 2000 Samuele Pedroni

package jxxload_help;

import java.util.Vector;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.zip.ZipFile;
import java.util.zip.ZipEntry;
import java.io.*;

public class PathVFS extends Object {
    
    public interface VFS {
        
       public InputStream open(String id);
        
    }
        
    public static class JarVFS implements VFS {
        private ZipFile zipfile;
        
        public JarVFS(String fname) throws IOException {
            zipfile = new ZipFile(fname);
        }
        
        public InputStream open(String id) {
            ZipEntry ent = zipfile.getEntry(id);
            if (ent == null) return null;
            try {
                return zipfile.getInputStream(ent);
            } catch(IOException e) {
                return null;
            }
        }
        
    }
    
    public static class DirVFS implements VFS {
        private String prefix;
        
        public DirVFS(String dir) {
            if (dir.length() == 0)
                prefix = null;
            else
                prefix = dir;
        }
        
        public InputStream open(String id) {
            File file = new File(prefix,id.replace('/',File.separatorChar));
            if (file.isFile()) {
                try {
                    return new BufferedInputStream(new FileInputStream(file));
                } catch(IOException e) {
                    return null;
                }
            }           
            return null;
        }
    }
    
    private Vector vfs = new Vector();
    private Hashtable once = new Hashtable();
    
    private final static Object PRESENT = new Object();
    
    public void addVFS(String fname) {
        if (fname.length() == 0) {
            if (!once.containsKey("")) {
                once.put("",PRESENT);
                vfs.addElement(new DirVFS(""));
            }
            return;
        }
        try {
            File file = new File(fname);
            String canon = file.getCanonicalPath().toString();
            if (!once.containsKey(canon)) {
                once.put(canon,PRESENT);
                if (file.isDirectory()) vfs.addElement(new DirVFS(fname));
                else if (file.exists() &&  (fname.endsWith(".jar") || fname.endsWith(".zip"))) {
                    vfs.addElement(new JarVFS(fname));
                }
            }
            
        } catch(IOException e) {}
    }
    
    public InputStream open(String id) {
        for(Enumeration enum = vfs.elements(); enum.hasMoreElements();) {
            VFS v = (VFS)enum.nextElement();
            InputStream stream = v.open(id);
            if (stream != null) return stream;
        }
        return null;
    }
      
}
--- NEW FILE ---
// Copyright 2000 Samuele Pedroni

package jxxload_help;

public class PathVFSJavaLoader extends ClassLoader {
    private ClassLoader parent;
   
    private PathVFS vfs;
    
    public java.util.Vector interfaces = new java.util.Vector();
    
    public PathVFSJavaLoader(PathVFS vfs,ClassLoader parent) {
        this.vfs = vfs;
        this.parent = parent;
    }
    
    protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
        Class c;
        
        c = findLoadedClass(name);
        if (c != null) return c;
        
        try {
            if (parent != null) return parent.loadClass(name);
        } catch(ClassNotFoundException e) {
        }
        
        java.io.InputStream in = vfs.open(name.replace('.','/')+".class");
        if (in == null) throw new ClassNotFoundException(name);
        
        try {
            int av = in.available();
            byte[] buf = new byte[av];
            in.read(buf);
            in.close();
            return loadClassFromBytes(name,buf);
        } catch(java.io.IOException e) {
            throw new ClassNotFoundException(name);
        }
        
    }

    
    private Class loadClassFromBytes(String name, byte[] data) {
        Class c = defineClass(name, data, 0, data.length);
        resolveClass(c);
        if (c.isInterface()) interfaces.addElement(c);
        if (!org.python.core.Options.skipCompile) {
            Compiler.compileClass(c);
        }
        return c;
    }
  
}