예제 #1
0
        /// <summary>
        /// Flushes this output stream and forces any buffered output bytes
        /// to be written out.
        /// </summary>
        /// <exception cref="java.io.IOException">
        /// If an I/O error occurs.
        /// </exception>
        public override void flush()
        {
            try
            {
                m_stream.Flush();
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
예제 #2
0
        /// <summary>
        /// Writes <c>length</c> bytes from the specified byte array
        /// starting at <c>offset</c> to this output stream.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        /// <param name="offset">The offset.</param>
        /// <param name="length">The length.</param>
        /// <remarks>
        /// The general contract is that some of the bytes in the array
        /// <code>buffer</code> are written to the output stream in order;
        /// element <code>buffer[offset]</code> is the first byte written
        /// and <code>buffer[offset+length-1]</code> is the last byte written
        /// by this operation.
        /// </remarks>
        /// <exception cref="java.io.IOException">
        /// If an I/O error occurs. In particular, an exception is thrown
        /// if the output stream is closed.
        /// </exception>
        public override void write(byte[] buffer, int offset, int length)
        {
            try
            {
                m_stream.Write(buffer, offset, length);
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
예제 #3
0
        /// <summary>
        /// Writes the specified byte to this output stream.
        /// </summary>
        /// <param name="b">The <c>byte</c>.</param>
        /// <remarks>
        /// The general contract for <c>write</c> is that one
        /// byte is written  to the output stream. The byte to be
        /// written is the eight low-order bits of the argument
        /// <c>b</c>. The 24 high-order bits of <c>b</c>
        /// are ignored.
        /// </remarks>
        /// <exception cref="Exception">
        /// If an I/O error occurs. In particular, an
        /// <code>IOException</code> may be thrown if the
        /// output stream has been closed.
        /// </exception>
        public override void write(int b)
        {
            try
            {
                m_stream.WriteByte((byte)(b & 0xff));
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
예제 #4
0
        /// <summary>
        /// Reads the next byte of data from this input stream.
        /// </summary>
        /// <remarks>
        /// The byte value is returned as an <c>int</c> in
        /// the range <c>0</c> to <c>255</c>. If no byte
        /// is available because the end of the stream has been reached,
        /// the value <c>-1</c> is returned. This method blocks
        /// until input data is available, the end of the stream is
        /// detected, or an exception is thrown.
        /// </remarks>
        /// <returns>
        /// The next byte of data, or <c>-1</c> if the end of the
        /// stream is reached.
        /// </returns>
        /// <exception cref="java.io.IOException">
        /// if an I/O error occurs.
        /// </exception>
        public override int read()
        {
            try
            {
                return(m_stream.ReadByte());
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
예제 #5
0
        /// <summary>
        /// Returns an estimate of the number of bytes that can be read (or
        /// skipped over) from this input stream without blocking by the next
        /// invocation of a method for this input stream. The next invocation
        /// might be the same thread or another thread.  A single read or skip of this
        /// many bytes will not block, but may read or skip fewer bytes.
        /// </summary>
        /// <remarks>
        /// <para> Note that while some implementations of {@code InputStream} will return
        /// the total number of bytes in the stream, many will not.  It is
        /// never correct to use the return value of this method to allocate
        /// a buffer intended to hold all data in this stream.
        /// </para>
        /// <para> A subclass' implementation of this method may choose to throw a
        /// java.io.IOException if this input stream has been closed by
        /// invoking the close() method.
        /// </para>
        /// <para> The <c>available</c> method of the java.io.InputStream class always
        /// returns {@code 0}.
        /// </para>
        /// <para> This method should be overridden by subclasses.
        /// </para>
        /// </remarks>
        /// <returns>
        /// an estimate of the number of bytes that can be read (or skipped
        /// over) from this input stream without blocking or {@code 0} when
        /// it reaches the end of the input stream.
        /// </returns>
        /// <exception cref="java.io.IOException">if an I/O error occurs.</exception>
        public override int available()
        {
            try
            {
                checked
                {
                    return((m_stream.CanRead && m_stream.CanSeek)
                        ? (int)(m_stream.Length - m_stream.Position)
                        : base.available());
                }
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
예제 #6
0
        /// <summary>
        /// Reads up to <c>length</c> bytes of data from the input/ stream
        /// into an array of bytes.
        /// </summary>
        /// <remarks>
        /// <para>
        /// An attempt is made to read as many as <c>length</c> bytes, but
        /// a smaller number may be read. The number of bytes actually
        /// read is returned as an integer.
        /// </para>
        /// <para>
        /// This method blocks until input data is available, end of file
        /// is detected, or an exception is thrown.
        /// </para>
        /// <para>
        /// If <c>length</c> is zero, then no bytes are read and <c>0</c> is
        /// returned; otherwise, there is an attempt to read at least one byte.
        /// If no byte is available because the stream is at end of file, the
        /// value <c>-1</c> is returned; otherwise, at least one byte is read
        /// and stored into <c>buffer</c>.
        /// </para>
        /// <para>
        /// The first byte read is stored into element <c>buffer[offset]</c>,
        /// the next one into <c>buffer[offset+1]</c>, and so on. The number
        /// of bytes read is, at most, equal to <c>length</c>. Let <i>k</i>
        /// be the number of bytes actually read; these bytes will be stored
        /// in elements <c>buffer[offset]</c> through <c>buffer[offset+</c>
        /// <i>k</i><c>-1]</c>, leaving elements <c>buffer[offset+</c><i>k</i>
        /// <c>]</c> through <c>buffer[offset+length-1]</c> unaffected.
        /// </para>
        /// <para>
        /// In every case, elements <c>buffer[0]</c> through
        /// <c>buffer[offset]</c> and elements <c>buffer[offset+length]</c>
        /// through <c>buffer[b.length-1]</c> are unaffected.
        /// </para>
        /// </remarks>
        /// <param name="buffer">
        /// The buffer into which the data is read.
        /// </param>
        /// <param name="offset">
        /// The start offset in array <c>buffer</c> at which the data
        /// is written.
        /// </param>
        /// <param name="length">
        /// The maximum number of bytes to read.
        /// </param>
        /// <returns>
        /// The total number of bytes read into the buffer, or <c>-1</c> if
        /// there is no more data because the end of the stream has been
        /// reached.
        /// </returns>
        /// <exception cref="java.io.IOException">
        /// If the first byte cannot be read for any reason other than end of
        /// file, or if the input stream has been closed, or if some other
        /// I/O error occurs.
        /// </exception>
        /// <exception cref="java.lang.NullPointerException">
        /// If <c>buffer</c> is <c>null</c>.
        /// </exception>
        /// <exception cref="java.lang.IndexOutOfBoundsException">
        /// If <c>offset</c> is negative,  <c>length</c> is negative,
        /// or <c>length</c> is greater than  <c>b.length - offset</c>.
        /// </exception>
        public override int read(
            byte[] buffer,
            int offset,
            int length)
        {
            try
            {
                int bytesRead = m_stream.Read(buffer, offset, length);

                return((bytesRead == 0)
                    ? -1
                    : bytesRead);
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
        /// <summary>
        /// Reads up to <c>length</c> bytes of data from the input/ stream
        /// into an array of bytes.
        /// </summary>
        /// <remarks>
        /// <para>
        /// An attempt is made to read as many as <c>length</c> bytes, but
        /// a smaller number may be read. The number of bytes actually
        /// read is returned as an integer.
        /// </para>
        /// <para>
        /// This method blocks until input data is available, end of file
        /// is detected, or an exception is thrown.
        /// </para>
        /// <para>
        /// If <c>length</c> is zero, then no bytes are read and <c>0</c> is
        /// returned; otherwise, there is an attempt to read at least one byte.
        /// If no byte is available because the stream is at end of file, the
        /// value <c>-1</c> is returned; otherwise, at least one byte is read
        /// and stored into <c>buffer</c>.
        /// </para>
        /// <para>
        /// The first byte read is stored into element <c>buffer[offset]</c>,
        /// the next one into <c>buffer[offset+1]</c>, and so on. The number
        /// of bytes read is, at most, equal to <c>length</c>. Let <i>k</i>
        /// be the number of bytes actually read; these bytes will be stored
        /// in elements <c>buffer[offset]</c> through <c>buffer[offset+</c>
        /// <i>k</i><c>-1]</c>, leaving elements <c>buffer[offset+</c><i>k</i>
        /// <c>]</c> through <c>buffer[offset+length-1]</c> unaffected.
        /// </para>
        /// <para>
        /// In every case, elements <c>buffer[0]</c> through
        /// <c>buffer[offset]</c> and elements <c>buffer[offset+length]</c>
        /// through <c>buffer[b.length-1]</c> are unaffected.
        /// </para>
        /// </remarks>
        /// <param name="buffer">
        /// The buffer into which the data is read.
        /// </param>
        /// <param name="offset">
        /// The start offset in array <c>buffer</c> at which the data
        /// is written.
        /// </param>
        /// <param name="length">
        /// The maximum number of bytes to read.
        /// </param>
        /// <returns>
        /// The total number of bytes read into the buffer, or <c>-1</c> if
        /// there is no more data because the end of the stream has been
        /// reached.
        /// </returns>
        /// <exception cref="java.io.IOException">
        /// If the first byte cannot be read for any reason other than end of
        /// file, or if the input stream has been closed, or if some other
        /// I/O error occurs.
        /// </exception>
        /// <exception cref="java.lang.NullPointerException">
        /// If <c>buffer</c> is <c>null</c>.
        /// </exception>
        /// <exception cref="java.lang.IndexOutOfBoundsException">
        /// If <c>offset</c> is negative,  <c>length</c> is negative,
        /// or <c>length</c> is greater than  <c>b.length - offset</c>.
        /// </exception>
        public override int read(
            byte[] buffer,
            int offset,
            int length)
        {
            try
            {
                int bytesRead = m_stream.Read(buffer, offset, length);

                return (bytesRead == 0)
                    ? -1
                    : bytesRead;
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
        /// <summary>
        /// Reads the next byte of data from this input stream. 
        /// </summary>
        /// <remarks>
        /// The byte value is returned as an <c>int</c> in
        /// the range <c>0</c> to <c>255</c>. If no byte
        /// is available because the end of the stream has been reached,
        /// the value <c>-1</c> is returned. This method blocks
        /// until input data is available, the end of the stream is
        /// detected, or an exception is thrown.
        /// </remarks>
        /// <returns>    
        /// The next byte of data, or <c>-1</c> if the end of the
        /// stream is reached.
        /// </returns>
        /// <exception cref="java.io.IOException">
        /// if an I/O error occurs.
        /// </exception>
        public override int read()
        {
            try
            {
                return m_stream.ReadByte();
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
        /// <summary>
        /// Closes this input stream and releases any system
        /// resources associated with it.
        /// </summary>
        /// <exception cref="Exception">
        /// If an I/O error occurs.
        /// </exception>
        public override void close()
        {
            try
            {
                m_stream.Close();
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
        /// <summary>
        /// Returns an estimate of the number of bytes that can be read (or 
        /// skipped over) from this input stream without blocking by the next
        /// invocation of a method for this input stream. The next invocation
        /// might be the same thread or another thread.  A single read or skip of this
        /// many bytes will not block, but may read or skip fewer bytes.
        /// </summary>
        /// <remarks>
        /// <para> Note that while some implementations of {@code InputStream} will return
        /// the total number of bytes in the stream, many will not.  It is
        /// never correct to use the return value of this method to allocate
        /// a buffer intended to hold all data in this stream.
        /// </para>
        /// <para> A subclass' implementation of this method may choose to throw a
        /// java.io.IOException if this input stream has been closed by
        /// invoking the close() method.
        /// </para>
        /// <para> The <c>available</c> method of the java.io.InputStream class always
        /// returns {@code 0}.
        /// </para>
        /// <para> This method should be overridden by subclasses.
        /// </para>
        /// </remarks>
        /// <returns>
        /// an estimate of the number of bytes that can be read (or skipped
        /// over) from this input stream without blocking or {@code 0} when
        /// it reaches the end of the input stream.
        /// </returns>
        /// <exception cref="java.io.IOException">if an I/O error occurs.</exception>
        public override int available()
        {
            try
            {
                checked
                {
                    return (m_stream.CanRead && m_stream.CanSeek)
                        ? (int)(m_stream.Length - m_stream.Position)
                        : base.available();
                }
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
        /// <summary>
        /// Writes <c>length</c> bytes from the specified byte array
        /// starting at <c>offset</c> to this output stream.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        /// <param name="offset">The offset.</param>
        /// <param name="length">The length.</param>
        /// <remarks>
        /// The general contract is that some of the bytes in the array
        /// <code>buffer</code> are written to the output stream in order;
        /// element <code>buffer[offset]</code> is the first byte written
        /// and <code>buffer[offset+length-1]</code> is the last byte written
        /// by this operation.
        /// </remarks>
        /// <exception cref="java.io.IOException">
        /// If an I/O error occurs. In particular, an exception is thrown
        /// if the output stream is closed.
        /// </exception>
        public override void write(byte[] buffer, int offset, int length)
        {
            try
            {
                m_stream.Write(buffer, offset, length);
            }
            catch (Exception ex)
            {
                IOException ioe =  new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }
        /// <summary>
        /// Writes the specified byte to this output stream.
        /// </summary>
        /// <param name="b">The <c>byte</c>.</param>
        /// <remarks>
        /// The general contract for <c>write</c> is that one
        /// byte is written  to the output stream. The byte to be
        /// written is the eight low-order bits of the argument
        /// <c>b</c>. The 24 high-order bits of <c>b</c>
        /// are ignored.
        /// </remarks>
        /// <exception cref="Exception">
        /// If an I/O error occurs. In particular, an
        /// <code>IOException</code> may be thrown if the
        /// output stream has been closed.
        /// </exception>
        public override void write(int b)
        {
            try
            {
                m_stream.WriteByte((byte)(b & 0xff));
            }
            catch (Exception ex)
            {
                IOException ioe = new IOException(ex.Message);

                ioe.initCause(ex);

                throw ioe;
            }
        }