X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fxwt%2FStream.java;fp=src%2Forg%2Fxwt%2FStream.java;h=83004782735e5d8349571d9aae417c66a605f281;hb=d4fc62b0a4738cdab3dd605d7ec34dab94341867;hp=0000000000000000000000000000000000000000;hpb=e9492ed0cd0e8c1e717ede290f11ed187f7aee8a;p=org.ibex.core.git diff --git a/src/org/xwt/Stream.java b/src/org/xwt/Stream.java new file mode 100644 index 0000000..8300478 --- /dev/null +++ b/src/org/xwt/Stream.java @@ -0,0 +1,235 @@ +// FIXEME +// Copyright 2003 Adam Megacz, see the COPYING file for licensing [GPL] +package org.xwt; + +import java.io.*; +import java.util.*; +import java.util.zip.*; +import org.xwt.js.*; +import org.xwt.util.*; +import org.bouncycastle.util.encoders.Base64; + + +/** Base class for XWT resources */ +public abstract class Stream extends JS { + + /** return a resource for a given url */ + public static final Stream fromURL(String url) throws JSExn { + if (url.startsWith("http://")) return new Stream.HTTP(url); + else if (url.startsWith("https://")) return new Stream.HTTP(url); + else if (url.startsWith("data:")) return new Stream.ByteArray(Base64.decode(url.substring(5)), null); + else if (url.startsWith("utf8:")) return new Stream.ByteArray(url.substring(5).getBytes(), null); + throw new JSExn("invalid resource specifier " + url); + } + + // Base Class ////////////////////////////////////////////////////////////////////// + + public String typeName() { return "resource"; } + + /** so that we get the same subresource each time */ + private Hash refCache = null; + + public Template t = null; + + public final InputStream getInputStream() throws IOException { return getInputStream(""); } + public abstract InputStream getInputStream(String path) throws IOException; + + public Stream addExtension(String extension) { return new Ref(this, extension); } + + public Object get(Object key) throws JSExn { + if ("".equals(key)) { + try { + Template t = Template.getTemplate(addExtension(".xwt")); + return t == null ? null : t.getStatic(null); /** FIXME VERY BAD! */ + } catch (Exception e) { + Log.info(this, e); + return null; + } + } + Object ret = refCache == null ? null : refCache.get(key); + if (ret != null) return ret; + ret = new Ref(this, key); + if (refCache == null) refCache = new Hash(); + refCache.put(key, ret); + return ret; + } + + + + // Caching ////////////////////////////////////////////////////////////////////// + + public static class NotCacheableException extends Exception { } + public static NotCacheableException notCacheable = new NotCacheableException(); + + /** if it makes sense to cache a resource, the resource must return a unique key */ + public String getCacheKey() throws NotCacheableException { throw notCacheable; } + + /** subclass from this if you want a CachedInputStream for each path */ + public static class CachedStream extends Stream { + private Stream parent; + private boolean disk = false; + private String key; + public String getCacheKey() throws NotCacheableException { return key; } + public String toString() { return key; } + private Hash cachedInputStreams = new Hash(); + public CachedStream(Stream p, String s, boolean d) throws NotCacheableException { + this.parent = p; this.disk = d; this.key = p.getCacheKey(); + } + public InputStream getInputStream(String path) throws IOException { + CachedInputStream cis = (CachedInputStream)cachedInputStreams.get(path); + if (cis == null) { + if (disk) { + java.io.File f = LocalStorage.Cache.getCacheFileForKey(key); + if (f.exists()) return new FileInputStream(f); + cis = new CachedInputStream(parent.getInputStream(path), f); + } else { + cis = new CachedInputStream(parent.getInputStream(path)); + } + cachedInputStreams.put(path, cis); + } + return cis.getInputStream(); + } + } + + + // Useful Subclasses ////////////////////////////////////////////////////////////////////// + + /** HTTP or HTTPS resource */ + public static class HTTP extends Stream { + private String url; + HTTP(String url) { while (url.endsWith("/")) url = url.substring(0, url.length() - 1); this.url = url; } + public String toString() { return url; } + public String getCacheKey() throws NotCacheableException { return url; } + public InputStream getInputStream(String path) throws IOException { return new org.xwt.HTTP(url + path).GET(); } + } + + /** byte arrays */ + public static class ByteArray extends Stream { + private byte[] bytes; + private String cacheKey = null; + ByteArray(byte[] bytes, String cacheKey) { this.bytes = bytes; this.cacheKey = cacheKey; } + public String toString() { return "byte[]"; } + public String getCacheKey() throws NotCacheableException { return cacheKey; } + public InputStream getInputStream(String path) throws IOException { + if (!"".equals(path)) throw new IOException("can't get subresources of a byte[] resource"); + return new ByteArrayInputStream(bytes); + } + } + + /** a file */ + public static class File extends Stream { + private String path; + File(String path) { + while (path.endsWith(java.io.File.separatorChar + "")) path = path.substring(0, path.length() - 1); + this.path = path; + } + public String toString() { return "file:" + path; } + public String getCacheKey() throws NotCacheableException { throw notCacheable; } // already on the disk! + public InputStream getInputStream(String rest) throws IOException { + return new FileInputStream((path + rest).replace('/', java.io.File.separatorChar)); } + } + + /** "unwrap" a Zip archive */ + public static class Zip extends Stream { + private Stream parent; + Zip(Stream parent) { this.parent = parent; } + public String toString() { return parent.toString() + "!zip"; } + public String getCacheKey() throws NotCacheableException { return parent.getCacheKey() + "!zip:"; } + public InputStream getInputStream(String path) throws IOException { + if (path.startsWith("/")) path = path.substring(1); + InputStream pis = parent.getInputStream(); + ZipInputStream zis = new ZipInputStream(pis); + ZipEntry ze = zis.getNextEntry(); + while(ze != null && !ze.getName().equals(path)) ze = zis.getNextEntry(); + if (ze == null) throw new IOException("requested file (" + path + ") not found in archive"); + return new KnownLength.KnownLengthInputStream(zis, (int)ze.getSize()); + } + } + + /** "unwrap" a Cab archive */ + public static class Cab extends Stream { + private Stream parent; + Cab(Stream parent) { this.parent = parent; } + public String toString() { return parent.toString() + "!cab"; } + public String getCacheKey() throws NotCacheableException { return parent.getCacheKey() + "!cab:"; } + public InputStream getInputStream(String path) throws IOException { + if (path.startsWith("/")) path = path.substring(1); + return new org.xwt.translators.MSPack(parent.getInputStream()).getInputStream(path); + } + } + + /** the Builtin resource */ + public static class Builtin extends Stream { + public Builtin() { }; + public String getCacheKey() throws NotCacheableException { throw notCacheable; } // not cacheable + public String toString() { return "builtin:"; } + public InputStream getInputStream(String path) throws IOException { + if (!path.equals("")) throw new IOException("the builtin resource has no subresources"); + return Platform.getBuiltinInputStream(); + } + } + + /** what you get when you reference a subresource */ + public static class Ref extends Stream { + Stream parent; + Object key; + public String toString() { return parent.toString() + "/" + key; } + Ref(Stream parent, Object key) { this.parent = parent; this.key = key; } + public String getCacheKey() throws NotCacheableException { return parent.getCacheKey() + "/" + key; } + public Stream addExtension(String extension) { + return ((String)key).endsWith(extension) ? this : new Ref(parent, key + extension); } + public InputStream getInputStream(String path) throws IOException { return parent.getInputStream("/" + key + path); } + } + + /** provides redirection of a specified key */ + public static class Graft extends Stream { + Stream graftee; + Object replaced_key, replaced_val; + Graft(Stream graftee, Object key, Object val) { this.graftee = graftee; this.replaced_key = key; this.replaced_val = val; } + public boolean equals(Object o) { return this == o || graftee.equals(o); } + public int hashCode() { return graftee.hashCode(); } + public InputStream getInputStream(String s) throws IOException { return graftee.getInputStream(s); } + public Object get(Object key) throws JSExn { return replaced_key.equals(key) ? replaced_val : graftee.get(key); } + public Object callMethod(Object name, Object a, Object b, Object c, Object[] rest, int nargs) throws JSExn { + if (replaced_key.equals(name)) { + if (replaced_val instanceof JS) return ((JS)replaced_val).call(a, b, c, rest, nargs); + else throw new JSExn("attempted to call non-function (class="+replaced_val.getClass()+")"); + } else { + return graftee.callMethod(name, a, b, c, rest, nargs); + } + } + public Number coerceToNumber() { return graftee.coerceToNumber(); } + public String coerceToString() { return graftee.coerceToString(); } + public boolean coerceToBoolean() { return graftee.coerceToBoolean(); } + public String typeName() { return graftee.typeName(); } + } + + /** shadow resource which replaces the graft */ + public static class ProgressWatcher extends Stream { + final Stream watchee; + JSFunction callback; + ProgressWatcher(Stream watchee, JSFunction callback) { this.watchee = watchee; this.callback = callback; } + public String toString() { return watchee.toString(); } + public String getCacheKey() throws NotCacheableException { return watchee.getCacheKey(); } + public InputStream getInputStream(String s) throws IOException { + final InputStream is = watchee.getInputStream(s); + return new FilterInputStream(is) { + int bytesDownloaded = 0; + public int read() throws IOException { + int ret = super.read(); + if (ret != -1) bytesDownloaded++; + return ret; + } + public int read(byte[] b, int off, int len) throws IOException { + int ret = super.read(b, off, len); + if (ret != 1) bytesDownloaded += ret; + Scheduler.add(new Scheduler.Task() { public void perform() throws Exception { + callback.call(N(bytesDownloaded), + N(is instanceof KnownLength ? ((KnownLength)is).getLength() : 0), null, null, 2); + } }); + return ret; + } + }; + } + } +}