jan-leila/Slipstream-Mod-Manager
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Removed SizeLimitInputStream

Browse source
This commit is contained in:
Vhati 2013-08-22 02:52:47 -04:00
parent 1a2324f4de
commit 0fa8c30744
2 changed files with 0 additions and 253 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/main/java/net/vhati/ftldat/FTLDat.java
View file

@ -26,7 +26,6 @@ import java.util.Map;
import java.util.Stack; import java.util.Stack;
import net.vhati.ftldat.FileChannelRegionInputStream; import net.vhati.ftldat.FileChannelRegionInputStream;
import net.vhati.ftldat.SizeLimitInputStream;
public class FTLDat { public class FTLDat {
@ -790,11 +789,6 @@ public class FTLDat {
// Multiple read-only streams can coexist (each has its own position). // Multiple read-only streams can coexist (each has its own position).
InputStream stream = new FileChannelRegionInputStream( raf.getChannel(), entry.dataOffset, entry.dataSize ); InputStream stream = new FileChannelRegionInputStream( raf.getChannel(), entry.dataOffset, entry.dataSize );
// Create a stream that can only see this region.
// There must be no other reads/seeks until it is closed.
//InputStream tmpStream = Channels.newInputStream( raf.getChannel().position( entry.dataOffset ) );
//InputStream stream = new SizeLimitInputStream( tmpStream, entry.dataSize );
// Mapped regions may not garbage collect promptly. // Mapped regions may not garbage collect promptly.
// That would keep the file in use: bad. // That would keep the file in use: bad.
// Closing raf doesn't affect them. :/ // Closing raf doesn't affect them. :/

247
src/main/java/net/vhati/ftldat/SizeLimitInputStream.java
View file

@ -1,247 +0,0 @@
/*
* Input stream wrapper with a byte limit.
* Copyright (C) 2004 Stephen Ostermiller
* http://ostermiller.org/contact.pl?regarding=Java+Utilities
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* See COPYING.TXT for details.
*/
package net.vhati.ftldat;
import java.io.*;
/**
* An input stream wrapper that will read only a set number of bytes from the
* underlying stream.
*
* @author Stephen Ostermiller http://ostermiller.org/contact.pl?regarding=Java+Utilities
* @since ostermillerutils 1.04.00
*/
public class SizeLimitInputStream extends InputStream {
/**
* The input stream that is being protected.
* All methods should be forwarded to it,
* after checking the size that has been read.
*
* @since ostermillerutils 1.04.00
*/
protected InputStream in;
/**
* The number of bytes to read at most from this
* Stream. Read methods should
* check to ensure that bytesRead never
* exceeds maxBytesToRead.
*
* @since ostermillerutils 1.04.00
*/
protected long maxBytesToRead = 0;
/**
* The number of bytes that have been read
* from this stream. Read methods should
* check to ensure that bytesRead never
* exceeds maxBytesToRead.
*
* @since ostermillerutils 1.04.00
*/
protected long bytesRead = 0;
/**
* The number of bytes that have been read
* from this stream since mark() was called.
*
* @since ostermillerutils 1.04.00
*/
protected long bytesReadSinceMark = 0;
/**
* The number of bytes the user has request
* to have been marked for reset.
*
* @since ostermillerutils 1.04.00
*/
protected long markReadLimitBytes = -1;
/**
* Get the number of bytes actually read
* from this stream.
*
* @return number of bytes that have already been taken from this stream.
*
* @since ostermillerutils 1.04.00
*/
public long getBytesRead(){
return bytesRead;
}
/**
* Get the maximum number of bytes left to read
* before the limit (set in the constructor) is reached.
*
* @return The number of bytes that (at a maximum) are left to be taken from this stream.
*
* @since ostermillerutils 1.04.00
*/
public long getBytesLeft(){
return maxBytesToRead - bytesRead;
}
/**
* Tell whether the number of bytes specified
* in the constructor have been read yet.
*
* @return true iff the specified number of bytes have all been read.
*
* @since ostermillerutils 1.04.00
*/
public boolean allBytesRead(){
return getBytesLeft() == 0;
}
/**
* Get the number of total bytes (including bytes already read)
* that can be read from this stream (as set in the constructor).
* @return Maximum bytes that can be read until the size limit runs out
*
* @since ostermillerutils 1.04.00
*/
public long getMaxBytesToRead(){
return maxBytesToRead;
}
/**
* Create a new size limit input stream from
* another stream given a size limit.
*
* @param in The input stream.
* @param maxBytesToRead the max number of bytes to allow to be read from the underlying stream.
*
* @since ostermillerutils 1.04.00
*/
public SizeLimitInputStream( InputStream in, long maxBytesToRead ){
this.in = in;
this.maxBytesToRead = maxBytesToRead;
}
/**
* {@inheritDoc}
*/
@Override public int read() throws IOException {
if ( bytesRead >= maxBytesToRead ){
return -1;
}
int b = in.read();
if ( b != -1 ){
bytesRead++;
bytesReadSinceMark++;
}
return b;
}
/**
* {@inheritDoc}
*/
@Override public int read( byte[] b ) throws IOException {
return this.read( b, 0, b.length );
}
/**
* {@inheritDoc}
*/
@Override public int read( byte[] b, int off, int len ) throws IOException {
if ( bytesRead >= maxBytesToRead ){
return -1;
}
long bytesLeft = getBytesLeft();
if ( len > bytesLeft ){
len = (int)bytesLeft;
}
int bytesJustRead = in.read( b, off, len );
bytesRead += bytesJustRead;
bytesReadSinceMark += bytesJustRead;
return bytesJustRead;
}
/**
* {@inheritDoc}
*/
@Override public long skip(long n) throws IOException {
if ( bytesRead >= maxBytesToRead ){
return -1;
}
long bytesLeft = getBytesLeft();
if ( n > bytesLeft ){
n = bytesLeft;
}
return in.skip(n);
}
/**
* {@inheritDoc}
*/
@Override public int available() throws IOException {
int available = in.available();
long bytesLeft = getBytesLeft();
if ( available > bytesLeft ){
available = (int)bytesLeft;
}
return available;
}
/**
* Close this stream and underlying streams.
* Calling this method may make data on the
* underlying stream unavailable.
* <p>
* Consider wrapping this stream in a NoCloseStream
* so that clients can
* call close() with no effect.
*
* @since ostermillerutils 1.04.00
*/
@Override public void close() throws IOException {
in.close();
}
/**
* {@inheritDoc}
*/
@Override public void mark(int readlimit){
if ( in.markSupported() ){
markReadLimitBytes = readlimit;
bytesReadSinceMark = 0;
in.mark(readlimit);
}
}
/**
* {@inheritDoc}
*/
@Override public void reset() throws IOException {
if ( in.markSupported() && bytesReadSinceMark <= markReadLimitBytes ){
bytesRead -= bytesReadSinceMark;
in.reset();
bytesReadSinceMark = 0;
}
}
/**
* {@inheritDoc}
*/
@Override public boolean markSupported(){
return in.markSupported();
}
}