/*
* 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.
*/
package org.apache.harmony.x.imageio.stream;
import java.util.ArrayList;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public final class RandomAccessMemoryCache {
private static final int BLOCK_SHIFT = 9;
private static final int BLOCK_SIZE = 1 << BLOCK_SHIFT;
private static final int BLOCK_MASK = BLOCK_SIZE - 1;
private long length;
private int firstUndisposed = 0;
private ArrayList<byte[]> blocks = new ArrayList<byte[]>();
public RandomAccessMemoryCache() {
}
public long length() {
return length;
}
public void close() {
blocks.clear();
length = 0;
}
private void grow(long pos) {
int blocksNeeded = (int)(pos >> BLOCK_SHIFT) - blocks.size() + 1;
for (int i=0; i < blocksNeeded; i++) {
blocks.add(new byte[BLOCK_SIZE]);
}
length = pos + 1;
}
public void putData(int oneByte, long pos) {
if (pos >= length) {
grow(pos);
}
byte[] block = blocks.get((int)(pos >> BLOCK_SHIFT));
block[(int)(pos & BLOCK_MASK)] = (byte) oneByte;
}
public void putData(byte[] buffer, int offset, int count, long pos) {
if (count > buffer.length - offset || count < 0 || offset < 0) {
throw new IndexOutOfBoundsException();
}
if (count == 0){
return;
}
long lastPos = pos + count - 1;
if (lastPos >= length) {
grow(lastPos);
}
while (count > 0) {
byte[] block = blocks.get((int)(pos >> BLOCK_SHIFT));
int blockOffset = (int)(pos & BLOCK_MASK);
int toCopy = Math.min(BLOCK_SIZE - blockOffset, count);
System.arraycopy(buffer, offset, block, blockOffset, toCopy);
pos += toCopy;
count -= toCopy;
offset += toCopy;
}
}
public int getData(long pos) {
if (pos >= length) {
return -1;
}
byte[] block = blocks.get((int)(pos >> BLOCK_SHIFT));
return block[(int)(pos & BLOCK_MASK)] & 0xFF;
}
public int getData(byte[] buffer, int offset, int count, long pos) {
if (count > buffer.length - offset || count < 0 || offset < 0) {
throw new IndexOutOfBoundsException();
}
if (count == 0) {
return 0;
}
if (pos >= length) {
return -1;
}
if (count + pos > length) {
count = (int) (length - pos);
}
byte[] block = blocks.get((int)(pos >> BLOCK_SHIFT));
int nbytes = Math.min(count, BLOCK_SIZE - (int)(pos & BLOCK_MASK));
System.arraycopy(block, (int)(pos & BLOCK_MASK), buffer, offset, nbytes);
return nbytes;
}
/*
public void seek(long pos) throws IOException {
if (pos < 0) {
throw new IOException("seek position is negative");
}
this.pos = pos;
}
public void readFully(byte[] buffer) throws IOException {
readFully(buffer, 0, buffer.length);
}
public void readFully(byte[] buffer, int offset, int count) throws IOException {
if (0 <= offset && offset <= buffer.length && 0 <= count && count <= buffer.length - offset) {
while (count > 0) {
int result = read(buffer, offset, count);
if (result >= 0) {
offset += result;
count -= result;
} else {
throw new EOFException();
}
}
} else {
throw new IndexOutOfBoundsException();
}
}
public long getFilePointer() {
return pos;
}
*/
public void freeBefore(long pos) {
int blockIdx = (int)(pos >> BLOCK_SHIFT);
if (blockIdx <= firstUndisposed) { // Nothing to do
return;
}
for (int i = firstUndisposed; i < blockIdx; i++) {
blocks.set(i, null);
}
firstUndisposed = blockIdx;
}
public int appendData(InputStream is, int count) throws IOException {
if (count <= 0) {
return 0;
}
long startPos = length;
long lastPos = length + count - 1;
grow(lastPos); // Changes length
int blockIdx = (int)(startPos >> BLOCK_SHIFT);
int offset = (int) (startPos & BLOCK_MASK);
int bytesAppended = 0;
while (count > 0) {
byte[] block = blocks.get(blockIdx);
int toCopy = Math.min(BLOCK_SIZE - offset, count);
count -= toCopy;
while (toCopy > 0) {
int bytesRead = is.read(block, offset, toCopy);
if (bytesRead < 0) {
length -= (count - bytesAppended);
return bytesAppended;
}
toCopy -= bytesRead;
offset += bytesRead;
}
blockIdx++;
offset = 0;
}
return count;
}
public void getData(OutputStream os, int count, long pos) throws IOException {
if (pos + count > length) {
throw new IndexOutOfBoundsException("Argument out of cache");
}
int blockIdx = (int)(pos >> BLOCK_SHIFT);
int offset = (int) (pos & BLOCK_MASK);
if (blockIdx < firstUndisposed) {
throw new IndexOutOfBoundsException("The requested data are already disposed");
}
while (count > 0) {
byte[] block = blocks.get(blockIdx);
int toWrite = Math.min(BLOCK_SIZE - offset, count);
os.write(block, offset, toWrite);
blockIdx++;
offset = 0;
count -= toWrite;
}
}
}