---

FileInputStream.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/FileInputStream>

#include <memory.h>

/*
 *  $Revision: 1.1 $
 *  $Author: w-molloy $
 *  $Date: 2002/08/13 04:42:20 $
 */

namespace stdbase {
    namespace io {

//      --- Static Create Functions ---
//
system::reference< FileInputStream > FileInputStream::
    create( system::StringRef name )
{
    return FileInputStreamRef( new FileInputStream( name ) );
}
    
system::reference< FileInputStream > FileInputStream::
    create( const system::platform::FileDescriptor & fd)
{
    return FileInputStreamRef( new FileInputStream( fd ) );
}

//
//      --- Static Create Functions ---



int FileInputStream::
    available() throw (IOException)
{
    return length - position;
}
    
void FileInputStream::
    close() throw (IOException)
{
    if ( input.isOpen() )
    {
        input.close();
    }
}

void FileInputStream::
    mark( int readlimit)
{
}

void FileInputStream::
    reset() throw (IOException)
{
    //  We don't support mark/reset here.
    throw IOException();
}

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

/*
 *  Read a buffer of bytes - NEEDS Array.
 */
int FileInputStream::
    read( byte buffer[], int len)
    throw (IOException)
{
    //  Use memcpy
    //

    int read_len = 0;

    if ( length == 0 ||
         position == length &&
         ! input.eof() )
    {
        //  Reload the buffer...
        //
        length = input.read(
                    (char*) data_buffer,
                    DATA_BUFFER_SIZE
                 );
        if ( length < 0 )
            throw IOException();

        position = 0;
    }
    
    if ( position == length &&
         input.eof() )
    {
        return 0;
    }

    memcpy( buffer, & data_buffer[ position ], ( length - position ) );
    read_len += length - position;

    //  Ensure next read operation gets a new buffer...
    length = position = 0;

    if ( read_len < len )
    {
        //  Read the rest directly into the provided buffer...
        //
        int result;

        result =    input.read(
                        (char*) & buffer[ read_len ],
                        len - read_len
                    );

        if ( result < 0 )
            throw IOException();

        read_len += result;
    }

    return read_len;
}
        
/*
 *  Read a single byte from the stream and return it as an
 *  integer.
 *
 *  @return the number of bytes read.
 */
int FileInputStream::
    read() throw (IOException)
{
    int val;
    
    if ( length == 0 ||
         position == length &&
         ! input.eof() )
    {
        //  Reload the buffer...
        //
        length = input.read( (char*) data_buffer, DATA_BUFFER_SIZE);
        if ( length < 0 )
            throw IOException();

        position = 0;
    }
    
    //  Still no data in the buffer ?
    //
    if ( position == length ||
         input.eof() )
    {
        throw IOException();
    }

    val = (int) data_buffer[ position++ ]; 
    return val;
}

/*
 *  Skip the next n bytes from the input stream.
 *
 *  returns the number of bytes skipped.
 */
long FileInputStream::
    skip( long n ) throw (IOException)
{
    long    skipped = 0;

    if ( ! input.isOpen() )
    {
        throw IOException();
    }

    try
    {
        while( skipped < n )
        {
            read();
            skipped++;
        }
    }
    catch( IOException & e)
    { e =  e;}
    
    return skipped;
}


FileInputStream::
FileInputStream( ::stdbase::system::StringRef name)
    :   InputStream(),
        input(),
        position( 0 ),
        length( 0 )
{
    int    len = name->length();
    char * n = new char [ len + 1];
    name->getChars( 0, len, n, 0);

    input.open( n, system::platform::FileDescriptor:: OPEN_READ_TEXT);

    delete [] n;
}

FileInputStream::
FileInputStream( const ::stdbase::system::platform::FileDescriptor &fd)
    :   InputStream(),
        input( fd ),
        position( 0 ),
        length( 0 )
{
}

FileInputStream::
~FileInputStream()
{
    try {
        if ( input.isOpen() )
        {
            close();
        }
    }
    catch ( IOException &e)
    {
        e = e;
    }
}

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

---