/* * 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. */ #ifndef _DECAF_IO_BYTEARRAYINPUTSTREAM_H_ #define _DECAF_IO_BYTEARRAYINPUTSTREAM_H_ #include #include #include namespace decaf{ namespace io{ /** * A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from * the stream. An internal counter keeps track of the next byte to be supplied by the read method. * The ByteArrayInputStream never copies the supplied buffers, only points to them, therefore the * caller must ensure that the supplied buffer remain in scope, or is not deleted before this * ByteArrayInputStream is freed. If the own argument of one of the constructors that accepts an * array pointer is set to true than the ByteArrayInputStream instance will take ownership of the * supplied pointer and delete it when that instance is destroyed. * * Closing a ByteArrayInputStream has no effect. The methods in this class can be called after * the stream has been closed without generating an IOException. * * @since 1.0 */ class DECAF_API ByteArrayInputStream: public InputStream { private: /** * An array of bytes that was provided by the creator of the stream. Elements buffer[0] * through buffer[count-1] are the only bytes that can ever be read from the stream; element * buffer[pos] is the next byte to be read. */ const unsigned char* buffer; /** * The Size of the input buffer. */ int size; /** * Does this object own the supplied pointer. */ bool own; /** * The index one greater than the last valid character in the input stream buffer. This * value should always be nonnegative and not larger than the length of buffer. It is one * greater than the position of the last byte within buffer that can ever be read from the * input stream buffer. */ int count; /** * The index of the next character to read from the input stream buffer. This value should * always be nonnegative and not larger than the value of count. The next byte to be read * from the input stream buffer will be buffer[pos]. */ int pos; /** * The currently marked position in the stream. ByteArrayInputStream objects are marked at * position zero by default when constructed. They may be marked at another position within * the buffer by the mark() method. The current buffer position is set to this point by the * reset() method. * * If no mark has been set, then the value of mark is the offset passed to the constructor * (or 0 if the offset was not supplied). */ int markpos; private: ByteArrayInputStream(const ByteArrayInputStream&); ByteArrayInputStream& operator=(const ByteArrayInputStream&); public: /** * Creates an ByteArrayInputStream with an empty input buffer, the buffer can be * initialized with a call to setByteArray. */ ByteArrayInputStream(); /** * Creates the input stream and calls setBuffer with the * specified buffer object. * * @param buffer * The buffer to be used. */ ByteArrayInputStream(const std::vector& buffer); /** * Create an instance of the ByteArrayInputStream with the given buffer as * the source of input for all read operations. * * @param buffer * The initial byte array to use to read from. * @param bufferSize * The size of the buffer. * @param own * Indicates if this object should take ownership of the array, default is false. * * @throws NullPointerException if the buffer is Null. * @throws IllegalArguementException if the bufferSize is negative. */ ByteArrayInputStream(const unsigned char* buffer, int bufferSize, bool own = false); /** * Create an instance of the ByteArrayInputStream with the given buffer as * the source of input for all read operations. * * @param buffer * The initial byte array to use to read from. * @param bufferSize * The size of the buffer. * @param offset * The offset into the buffer to begin reading from. * @param length * The number of bytes to read past the offset. * @param own * Indicates if this object should take ownership of the array, default is false. * * @throws NullPointerException if the buffer is Null. * @throws IllegalArguementException if the bufferSize is negative. */ ByteArrayInputStream(const unsigned char* buffer, int bufferSize, int offset, int length, bool own = false); virtual ~ByteArrayInputStream(); /** * Sets the internal buffer. The input stream will wrap around * this buffer and will perform all read operations on it. The * position will be reinitialized to the beginning of the specified * buffer. This class will not own the given buffer - it is the * caller's responsibility to free the memory of the given buffer * as appropriate. * * @param buffer * The buffer to be used. */ virtual void setByteArray(const std::vector& buffer); /** * Sets the data that this reader uses, replaces any existing * data and resets to beginning of the buffer. * * @param buffer * The initial byte array to use to read from. * @param bufferSize * The size of the buffer. * * @throws NullPointerException if the buffer is Null. * @throws IllegalArguementException if the bufferSize is negative. */ virtual void setByteArray(const unsigned char* buffer, int bufferSize); /** * Sets the data that this reader uses, replaces any existing * data and resets to beginning of the buffer. * * @param buffer * The initial byte array to use to read from. * @param bufferSize * The size of the buffer. * @param offset * The offset into the buffer to begin reading from. * @param length * The number of bytes to read past the offset. * * @throws NullPointerException if the buffer is Null. * @throws IllegalArguementException if the bufferSize is negative. */ virtual void setByteArray(const unsigned char* buffer, int bufferSize, int offset, int length); /** * {@inheritDoc} */ virtual int available() const; /** * {@inheritDoc} */ virtual long long skip(long long num); /** * {@inheritDoc} */ virtual void mark(int readLimit); /** * {@inheritDoc} */ virtual void reset(); /** * {@inheritDoc} */ virtual bool markSupported() const { return true; } protected: virtual int doReadByte(); virtual int doReadArrayBounded(unsigned char* buffer, int size, int offset, int length); }; }} #endif /*_DECAF_IO_BYTEARRAYINPUTSTREAM_H_*/