Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2010-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   *
   * Licensed under the Apache License, Version 2.0 (the "License").
   * You may not use this file except in compliance with the License.
   * A copy of the License is located at
   *
   *  http://aws.amazon.com/apache2.0
   *
  * or in the "license" file accompanying this file. This file 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 com.amazonaws.services.s3.internal.crypto;
 
 
Reads only a specific range of bytes from the underlying input stream.
 
 public class AdjustedRangeInputStream extends SdkInputStream {
     private InputStream decryptedContents;
     private long virtualAvailable;
     private boolean closed;

    
Creates a new DecryptedContentsInputStream object.

Parameters:
objectContents The input stream containing the object contents retrieved from S3
rangeBeginning The position of the left-most byte desired by the user
rangeEnd The position of the right-most byte desired by the user
Throws:
java.io.IOException If there are errors skipping to the left-most byte desired by the user.
 
     public AdjustedRangeInputStream(InputStream objectContentslong rangeBeginninglong rangeEndthrows IOException {
         this. = objectContents;
         this. = false;
         initializeForRead(rangeBeginningrangeEnd);
     }

    
Skip to the start location of the range of bytes desired by the user.
 
     private void initializeForRead(long rangeBeginninglong rangeEndthrows IOException {
         // To get to the left-most byte desired by a user, we must skip over the 16 bytes of the
         // preliminary cipher block, and then possibly skip a few more bytes into the next block
         // to where the the left-most byte is located.
         int numBytesToSkip;
         if(rangeBeginning < .) {
             numBytesToSkip = (int)rangeBeginning;
         } else {
             int offsetIntoBlock = (int)(rangeBeginning % .);
             numBytesToSkip = . + offsetIntoBlock;
         }
         if(numBytesToSkip != 0) {
             // Skip to the left-most desired byte.  The read() method is used instead of the skip() method
             // since the skip() method will not block if the underlying input stream is waiting for more input.
             while(numBytesToSkip > 0) {
                 this..read();
                 numBytesToSkip--;
             }
         }
         // The number of bytes the user may read is equal to the number of the bytes in the range.
         // Note that the range includes the endpoints.
         this. = (rangeEnd - rangeBeginning) + 1;
     }
 
     /* (non-Javadoc)
      * @see java.io.InputStream#read()
      */
     @Override
     public int read() throws IOException {
         abortIfNeeded();
         int result = 0;
         // If there are no more available bytes, mark that we are at the end of the stream.
         if (this. <= 0) {
             result = -1;
         } else {
             // Otherwise, read a byte.
             result = this..read();
         }
 
         // If we have not reached the end of the stream, decrement the number of available bytes.
         if (result != -1) {
             this.--;
         } else {
             // If we are at the end of the stream, close it.
             close();
             this. = 0;
         }
         return result;
     }
    /* (non-Javadoc)
     * @see java.io.InputStream#read(byte[], int, int)
     */
    @Override
    public int read(byte[] bufferint offsetint lengththrows IOException {
        abortIfNeeded();
        int numBytesRead;
        // If no more bytes are available, do not read any bytes into the buffer
        if(this. <= 0) {
            numBytesRead = -1;
        } else {
            // If the desired read length is greater than the number of available bytes,
            // shorten the read length to the number of available bytes.
            if(length > this.) {
                // If the number of available bytes is greater than the maximum value of a 32 bit int, then
                // read as many bytes as an int can.
                length = (this. < .) ? (int)this. : .;
            }
            // Read bytes into the buffer.
            numBytesRead = this..read(bufferoffsetlength);
        }
        // If we were able to read bytes, decrement the number of bytes available to be read.
        if(numBytesRead != -1) {
            this. -= numBytesRead;
        } else {
            // If we've reached the end of the stream, close it
            close();
            this. = 0;
        }
        return numBytesRead;
    }
    /* (non-Javadoc)
     * @see java.io.InputStream#available()
     */
    @Override
    public int available() throws IOException {
        abortIfNeeded();
        int available = this..available();
        if(available < this.) {
            return available;
        } else {
            // Limit the number of bytes available to the number
            // of bytes remaining in the range.
            return (int)this.;
        }
    }
    /* (non-Javadoc)
     * @see java.io.InputStream#close()
     */
    @Override
    public void close() throws IOException {
        // If not already closed, then close the input stream.
        if(!this.) {
            this. = true;
            this..close();
        }
        abortIfNeeded();
    }
    @Override
    protected InputStream getWrappedInputStream() {
        return ;
    }
New to GrepCode? Check out our FAQ X