---

BufferedInputStream.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 <memory.h>

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

namespace stdbase {
    namespace io {

int BufferedInputStream::
    available() throw (IOException)
{
    int len;

    if (end_pos >= start_pos)
    {
        len = end_pos - start_pos;
    }
    else if ( start_pos > end_pos )
    {   // wrap around..
        len = (BUFFER_MAX - start_pos) + end_pos - 1;
    }
    return len;
}

/*
 *  Closes the stream and releases any resources.
 */

/*
void BufferedInputStream::
    close() throw (IOException)
{
    FilterInputStream::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 BufferedInputStream::
    mark( int readlimit)
{
    mark_pos = start_pos;
    mark_read_limit = readlimit;
    mark_read_count = 0;
}

/*
 *  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 BufferedInputStream::
    reset() throw (IOException)
{
    if ( mark_read_limit == MARK_READ_LIMIT_EXCEEDED ||
         mark_read_limit == MARK_READ_LIMIT_NULL ||
         mark_pos == MARK_POS_UNSET ||
         mark_pos == MARK_POS_OVERWRITTEN )
    {
        //  Can't reset.  Let caller know about it.
        //
        throw IOException();
    }

    start_pos = mark_pos;
    mark_read_limit = MARK_READ_LIMIT_NULL;
    mark_pos = 0;
    mark_read_count = 0;
}

/*
 *  Test to see whether the InputStream implementation supports
 *  the mark()/reset() methods.
 */
bool BufferedInputStream::
    markSupported()
{
    return true;
}

/*
 *  Read a buffer of bytes - NEEDS Array.
 */
int BufferedInputStream::
    read( byte buffer[], int len) throw (IOException)
{
    prepare_buffer();
    
    int ready       = available();
    int copy1_size  = len < ready ? len : ready;
    int remainder   = len;
    int inlen       = 0;

    if ( start_pos < end_pos && end_pos <= BUFFER_MAX )
    {
        // -- normal case --
        //
        memcpy( buffer,
            & this->buffer[ start_pos ],
            copy1_size
        );
        advance_start_pos( copy1_size );
        remainder -= copy1_size;
    }
    else
    {
        // -- wrapped case --
        //
        int block1 = BUFFER_MAX - start_pos;
        int block2 = end_pos - 1;
        int L1, L2;

        if ( block1 > copy1_size )
        {
            L1 = copy1_size;
            L2 = 0;
        }
        else
        {
            L1 = block1;
            L2 = block2 > (copy1_size - block1) ?
                    copy1_size - block1: block2;
        }

        memcpy(
            buffer,
            & this->buffer[ start_pos ],
            L1
        );

        memcpy(
            buffer,
            this->buffer,
            L2
        );
        remainder -= L1 + L2;
        advance_start_pos( L1 + L2);
    }

    if ( remainder > 0 )
    {
        inlen = FilterInputStream:: read(
                                        & buffer[ copy1_size ],
                                        remainder
                                    );
    }
    return inlen + copy1_size;
}
    
/*
 *  Read a single byte from the stream and return it as an
 *  integer.
 *
 *  @return the number of bytes read.
 */
int BufferedInputStream::
    read() throw (IOException)
{
    prepare_buffer();
    
    char    ch = buffer[ start_pos ];
    
    advance_start_pos( 1 );

    return ch;
}

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


void    BufferedInputStream::
    prepare_buffer() throw (IOException)
{
    //  The range of valid data is in (start_pos, end_pos].
    //  It begins and includes the start_pos and goes upto
    //  but not including the end_pos.
    //
    if ( end_pos == start_pos )
    {
        if ( end_pos == BUFFER_MAX )
        {
            //  The circular buffer has wrapped around.
            end_pos = start_pos = 0;
        }

        //  Need to read data in...
        int len;
        int remainder = BUFFER_MAX - end_pos;
        int size = remainder <  BUFF_CHUNK ? remainder : BUFF_CHUNK;
        
        len = FilterInputStream::   read(
                                        (byte *)& buffer[ end_pos ],
                                        size
                                    );
        if ( len < 0 )
            throw IOException();

        end_pos += len;
    }

    //  Check that the end_pos hasn't wrapped around and
    //  overwritten the mark position.
    //
    if ( mark_pos != MARK_POS_UNSET &&
         start_pos > end_pos &&
         end_pos > mark_pos )
    {
        mark_pos = MARK_POS_OVERWRITTEN;
        mark_read_limit = MARK_READ_LIMIT_EXCEEDED;
    }
    if ( mark_read_limit > 0 &&
         mark_read_count > mark_read_limit )
    {
        mark_pos = MARK_POS_UNSET;
        mark_read_limit = MARK_READ_LIMIT_EXCEEDED;
    }
}

//  Increment the start_pos by the given amount.
//
void BufferedInputStream::
    advance_start_pos( int count )
    throw (IOException)
{
    if ( count > BUFFER_MAX )
        throw IOException();
    
    start_pos += count;
    if ( start_pos > BUFFER_MAX )
        start_pos -= BUFFER_MAX;

    if ( mark_pos != MARK_POS_UNSET )
        mark_read_count += count;
}



system::reference< BufferedInputStream > BufferedInputStream::
        create( InputStreamRef r)
{
    return BufferedInputStreamRef( new BufferedInputStream( r ));
}



BufferedInputStream::
    BufferedInputStream( InputStreamRef input)
        :   FilterInputStream( input ),
            start_pos( 0 ),
            end_pos( 0 ),
            mark_pos( MARK_POS_UNSET ),
            mark_read_limit( MARK_READ_LIMIT_NULL ),
            mark_read_count( 0 )
{};

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

---