X-Git-Url: http://git.megacz.com/?p=nestedvm.git;a=blobdiff_plain;f=src%2Forg%2Fibex%2Fnestedvm%2Futil%2FSeekable.java;h=2bb195e3e3ae64893b93d9562a74b854d988aba1;hp=85a48cc0d4cac58bcd2bc86e739c8473ed0bd00c;hb=b11e7c6c29f2b5f7b0828bf93eb741c4a30ec411;hpb=c2b2704764af1ade923ba8f15d517b87f9d16189

diff --git a/src/org/ibex/nestedvm/util/Seekable.java b/src/org/ibex/nestedvm/util/Seekable.java
index 85a48cc..2bb195e 100644
--- a/src/org/ibex/nestedvm/util/Seekable.java
+++ b/src/org/ibex/nestedvm/util/Seekable.java
@@ -1,16 +1,49 @@
+// Copyright 2000-2005 the Contributors, as shown in the revision logs.
+// Licensed under the Apache License 2.0 ("the License").
+// You may not use this file except in compliance with the License.
+
 package org.ibex.nestedvm.util;
 
 import java.io.*;
 
-public interface Seekable { 
-    public int read(byte[] buf, int offset, int length) throws IOException;
-    public int write(byte[] buf, int offset, int length) throws IOException;
-    public int length() throws IOException;
-    public void seek(int pos) throws IOException;
-    public void close() throws IOException;
-    public int pos() throws IOException;
+public abstract class Seekable { 
+    public abstract int read(byte[] buf, int offset, int length) throws IOException;
+    public abstract int write(byte[] buf, int offset, int length) throws IOException;
+    public abstract int length() throws IOException;
+    public abstract void seek(int pos) throws IOException;
+    public abstract void close() throws IOException;
+    public abstract int pos() throws IOException;
+
+    public void sync() throws IOException {
+        throw new IOException("sync not implemented for " + getClass());
+    }
+    public void resize(long length) throws IOException {
+        throw new IOException("resize not implemented for " + getClass());
+    }
+    /** If pos == 0 and size == 0 lock covers whole file. */
+    public Lock lock(long pos, long size, boolean shared) throws IOException {
+        throw new IOException("lock not implemented for " + getClass());
+    }
+    
+    public int read() throws IOException {
+        byte[] buf = new byte[1];
+        int n = read(buf,0,1);
+        return n == -1 ? -1 : buf[0]&0xff;
+    }
+    
+    public int tryReadFully(byte[] buf, int off, int len) throws IOException {
+        int total = 0;
+        while(len > 0) {
+                int n = read(buf,off,len);
+                if(n == -1) break;
+                off += n;
+                len -= n;
+            total += n;
+        }
+        return total == 0 ? -1 : total;
+    }
     
-    public class ByteArray implements Seekable {
+    public static class ByteArray extends Seekable {
         protected byte[] data;
         protected int pos;
         private final boolean writable;
@@ -28,7 +61,7 @@ public interface Seekable {
             pos += len;
             return len;
         }
-        
+                
         public int write(byte[] buf, int off, int len) throws IOException {
             if(!writable) throw new IOException("read-only data");
             len = Math.min(len,data.length-pos);
@@ -44,28 +77,39 @@ public interface Seekable {
         public void close() { /*noop*/ }
     }
     
-    public class File implements Seekable {
+    public static class File extends Seekable {
+        private final java.io.File file;
         private final RandomAccessFile raf;
         
         public File(String fileName) throws IOException { this(fileName,false); }
-        public File(String fileName, boolean writable) throws IOException { this(new java.io.File(fileName),writable); }    
+        public File(String fileName, boolean writable) throws IOException { this(new java.io.File(fileName),writable,false); }    
         
-        public File(java.io.File file, boolean writable) throws IOException {
-            raf = new RandomAccessFile(file,writable ? "rw" : "r");
+        public File(java.io.File file, boolean writable, boolean truncate) throws IOException {
+            this.file = file;
+            String mode = writable ? "rw" : "r";
+            raf = new RandomAccessFile(file,mode);
+            if (truncate) Platform.setFileLength(raf, 0);
         }
         
-        // NOTE: RandomAccessFile.setLength() is a Java2 function
-        public void setLength(int n) throws IOException { raf.setLength(n); }
-        
         public int read(byte[] buf, int offset, int length) throws IOException { return raf.read(buf,offset,length); }
         public int write(byte[] buf, int offset, int length) throws IOException { raf.write(buf,offset,length); return length; }
+        public void sync() throws IOException { raf.getFD().sync(); }
         public void seek(int pos) throws IOException{ raf.seek(pos); }
         public int pos()  throws IOException { return (int) raf.getFilePointer(); }
         public int length() throws IOException { return (int)raf.length(); }
         public void close() throws IOException { raf.close(); }
+        public void resize(long length) throws IOException { Platform.setFileLength(raf, (int)length); }
+        public boolean equals(Object o) {
+            return o != null && o instanceof File
+                   && file.equals(((File)o).file);
+        }
+        public Lock lock(long pos, long size, boolean shared)
+                throws IOException {
+            return Platform.lockFile(this, raf, pos, size, shared);
+        }
     }
     
-    public class InputStream implements Seekable {
+    public static class InputStream extends Seekable {
         private byte[] buffer = new byte[4096];
         private int bytesRead = 0;
         private boolean eof = false;
@@ -110,4 +154,29 @@ public interface Seekable {
         public void close() throws IOException { is.close(); }
     }
     
+    public abstract static class Lock {
+        private Object owner = null;
+
+        public abstract Seekable seekable();
+        public abstract boolean isShared();
+        public abstract boolean isValid();
+        public abstract void release() throws IOException;
+        public abstract long position();
+        public abstract long size();
+
+        public void setOwner(Object o) { owner = o; }
+        public Object getOwner() { return owner; }
+
+        public final boolean contains(int start, int len) {
+            return start >= position() &&  position() + size() >= start + len;
+        }
+
+        public final boolean contained(int start, int len) {
+            return start < position() && position() + size() < start + len;
+        }
+
+        public final boolean overlaps(int start, int len) {
+            return contains(start, len) || contained(start, len);
+        }
+    }
 }