diff options
Diffstat (limited to 'awt/javax/imageio/stream/ImageInputStreamImpl.java')
-rw-r--r-- | awt/javax/imageio/stream/ImageInputStreamImpl.java | 418 |
1 files changed, 418 insertions, 0 deletions
diff --git a/awt/javax/imageio/stream/ImageInputStreamImpl.java b/awt/javax/imageio/stream/ImageInputStreamImpl.java new file mode 100644 index 0000000..d79da41 --- /dev/null +++ b/awt/javax/imageio/stream/ImageInputStreamImpl.java @@ -0,0 +1,418 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * @author Rustem V. Rafikov + * @version $Revision: 1.3 $ + */ + +package javax.imageio.stream; + +import java.io.EOFException; +import java.io.IOException; +import java.nio.ByteOrder; + +/** + * The ImageInputStreamImpl abstract class implements the ImageInputStream + * interface. + * + * @since Android 1.0 + */ +public abstract class ImageInputStreamImpl implements ImageInputStream { + + /** + * The byte order. + */ + protected ByteOrder byteOrder = ByteOrder.BIG_ENDIAN; + + /** + * The stream position. + */ + protected long streamPos = 0; + + /** + * The flushed position. + */ + protected long flushedPos = 0; + + /** + * The bit offset. + */ + protected int bitOffset = 0; + + /** + * The closed. + */ + private boolean closed = false; + + /** + * The position stack. + */ + private final PositionStack posStack = new PositionStack(); + + /** + * Instantiates a new ImageInputStreamImpl. + */ + public ImageInputStreamImpl() { + } + + /** + * Check if the stream is closed and if true, throws an IOException. + * + * @throws IOException + * if the stream is closed. + */ + protected final void checkClosed() throws IOException { + if (closed) { + throw new IOException("stream is closed"); + } + } + + public void setByteOrder(ByteOrder byteOrder) { + this.byteOrder = byteOrder; + } + + public ByteOrder getByteOrder() { + return byteOrder; + } + + public abstract int read() throws IOException; + + public int read(byte[] b) throws IOException { + return read(b, 0, b.length); + } + + public abstract int read(byte[] b, int off, int len) throws IOException; + + public void readBytes(IIOByteBuffer buf, int len) throws IOException { + if (buf == null) { + throw new NullPointerException("buffer is NULL"); + } + + byte[] b = new byte[len]; + len = read(b, 0, b.length); + + buf.setData(b); + buf.setOffset(0); + buf.setLength(len); + } + + public boolean readBoolean() throws IOException { + int b = read(); + if (b < 0) { + throw new EOFException("EOF reached"); + } + return b != 0; + } + + public byte readByte() throws IOException { + int b = read(); + if (b < 0) { + throw new EOFException("EOF reached"); + } + return (byte)b; + } + + public int readUnsignedByte() throws IOException { + int b = read(); + if (b < 0) { + throw new EOFException("EOF reached"); + } + return b; + } + + public short readShort() throws IOException { + int b1 = read(); + int b2 = read(); + + if (b1 < 0 || b2 < 0) { + throw new EOFException("EOF reached"); + } + + return byteOrder == ByteOrder.BIG_ENDIAN ? (short)((b1 << 8) | (b2 & 0xff)) + : (short)((b2 << 8) | (b1 & 0xff)); + } + + public int readUnsignedShort() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public char readChar() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public int readInt() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public long readUnsignedInt() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public long readLong() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public float readFloat() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public double readDouble() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public String readLine() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public String readUTF() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public void readFully(byte[] b, int off, int len) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public void readFully(byte[] b) throws IOException { + readFully(b, 0, b.length); + } + + public void readFully(short[] s, int off, int len) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public void readFully(char[] c, int off, int len) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public void readFully(int[] i, int off, int len) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public void readFully(long[] l, int off, int len) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public void readFully(float[] f, int off, int len) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public void readFully(double[] d, int off, int len) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public long getStreamPosition() throws IOException { + checkClosed(); + return streamPos; + } + + public int getBitOffset() throws IOException { + checkClosed(); + return bitOffset; + } + + public void setBitOffset(int bitOffset) throws IOException { + checkClosed(); + this.bitOffset = bitOffset; + } + + public int readBit() throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public long readBits(int numBits) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public long length() { + return -1L; + } + + public int skipBytes(int n) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public long skipBytes(long n) throws IOException { + // -- TODO implement + throw new UnsupportedOperationException("Not implemented yet"); + } + + public void seek(long pos) throws IOException { + checkClosed(); + if (pos < getFlushedPosition()) { + throw new IllegalArgumentException("trying to seek before flushed pos"); + } + bitOffset = 0; + streamPos = pos; + } + + public void mark() { + try { + posStack.push(getStreamPosition()); + } catch (IOException e) { + e.printStackTrace(); + throw new RuntimeException("Stream marking error"); + } + } + + public void reset() throws IOException { + // -- TODO bit pos + if (!posStack.isEmpty()) { + long p = posStack.pop(); + if (p < flushedPos) { + throw new IOException("marked position lies in the flushed portion of the stream"); + } + seek(p); + } + } + + public void flushBefore(long pos) throws IOException { + if (pos > getStreamPosition()) { + throw new IndexOutOfBoundsException("Trying to flush outside of current position"); + } + if (pos < flushedPos) { + throw new IndexOutOfBoundsException("Trying to flush within already flushed portion"); + } + flushedPos = pos; + // -- TODO implement + } + + public void flush() throws IOException { + flushBefore(getStreamPosition()); + } + + public long getFlushedPosition() { + return flushedPos; + } + + public boolean isCached() { + return false; // def + } + + public boolean isCachedMemory() { + return false; // def + } + + public boolean isCachedFile() { + return false; // def + } + + public void close() throws IOException { + checkClosed(); + closed = true; + + } + + /** + * Finalizes this object. + * + * @throws Throwable + * if an error occurs. + */ + @Override + protected void finalize() throws Throwable { + if (!closed) { + try { + close(); + } finally { + super.finalize(); + } + } + } + + /** + * The Class PositionStack. + */ + private static class PositionStack { + + /** + * The Constant SIZE. + */ + private static final int SIZE = 10; + + /** + * The values. + */ + private long[] values = new long[SIZE]; + + /** + * The pos. + */ + private int pos = 0; + + /** + * Push. + * + * @param v + * the v. + */ + void push(long v) { + if (pos >= values.length) { + ensure(pos + 1); + } + values[pos++] = v; + } + + /** + * Pop. + * + * @return the long. + */ + long pop() { + return values[--pos]; + } + + /** + * Checks if is empty. + * + * @return true, if is empty. + */ + boolean isEmpty() { + return pos == 0; + } + + /** + * Ensure. + * + * @param size + * the size. + */ + private void ensure(int size) { + long[] arr = new long[Math.max(2 * values.length, size)]; + System.arraycopy(values, 0, arr, 0, values.length); + values = arr; + } + } +} |