---

FilterInputStream.cpp

/*
 *
 * NOTE: "zlib/libpng" style License
 *
 *                 ----=== s t d n e t ===----
 *
 * Copyright (c) 2002 Warwick Molloy   w-molloy@users.sf.net
 *
 * Copyright (c) 2002 Stdnet Community
 * HTTP://Sourceforge.net/projects/stdnet
 *
 * All references to "software" refer to the stdnet.
 *
 * This software is provided 'as-is', without any express or
 * implied warranty. In no event will the authors be held liable
 * for any damages arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any
 * purpose, including commercial applications, and to alter it
 * and redistribute it freely, subject to the following
 * restrictions:
 *
 * 1.  The origin of this software must not be misrepresented;
 *     you must not claim that you wrote the original software.
 *     If you use this software in a product, an acknowledgment
 *     in the product documentation would be appreciated but
 *     is not required.
 *
 * 2.  Altered source versions must be plainly marked as such,
 *     and must not be misrepresented as being the original
 *     software.
 *
 * 3.  This notice may not be removed or altered from any source
 *     distribution.
 */

#include <stdnet/config.h>
#include <stdnet/io/FilterInputStream>

namespace stdbase {
    namespace io {

/*
 *  Get the number of bytes that can be read or skipped before
 *  the next read would block.
 */
int FilterInputStream::
    available() throw (IOException)
{
    return input_stream->available();
}

/*
 *  Closes the stream and releases any resources.
 */
void FilterInputStream::
    close() throw (IOException)
{
    input_stream->close();
}

/*
 *  Marks the current position in the input stream incase
 *  the caller need return to this point - done by calling
 *  reset().
 *
 *  @param readlimit the maximum limit of bytes before the
 *  marked position becomes invalid.
 */
void FilterInputStream::
    mark( int readlimit)
{
    input_stream-> mark( readlimit );
}

/*
 *  Returns the caller to a previously marked position in
 *  the input stream (if supported).
 *
 *  @throws IOException if mark/reset not supported or if the
 *  number of bytes read exceeds the mark readlimit when mark()
 *  was called.
 */
void FilterInputStream::
    reset() throw (IOException)
{
    input_stream->reset();
}

/*
 *  Test to see whether the FilterInputStream implementation supports
 *  the mark()/reset() methods.
 */
bool FilterInputStream::
    markSupported()
{
    return input_stream->markSupported();
}

/*
 *  Read a buffer of bytes - NEEDS Array.
 */
int FilterInputStream::
    read( byte buffer[], int len) throw (IOException)
{
    return input_stream->read( buffer, len);
}
    
/*
 *  Read a single byte from the stream and return it as an
 *  integer.
 *
 *  @return the number of bytes read.
 */
int FilterInputStream::
    read() throw (IOException)
{
    return input_stream->read();
}

/*
 *  Skip the next n bytes from the input stream.
 *
 *  @return the number of bytes skipped.
 */
long FilterInputStream::
    skip( long n ) throw (IOException)
{
    return input_stream->skip( n );
}


FilterInputStreamRef FilterInputStream::
    create( InputStreamRef r)
{
    return FilterInputStreamRef( new FilterInputStream( r ) );
}


FilterInputStream::
FilterInputStream( InputStreamRef input)
    :   InputStream(),
        input_stream( input )
{
}


FilterInputStream::
~FilterInputStream()
{ }

    } // -- end io --
} // -- end stdbase --

---