---

PrintStream.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/IOException>
#include <stdnet/io/PrintStream>

#include <stdio.h>
#include <string.h>

namespace stdbase {
    namespace io {

const system::reference<PrintStream> PrintStream::
    create( const OutputStreamRef & ref)
{
    const system::reference<PrintStream> object = new PrintStream( ref );
    return object;
}

void PrintStream::
    flush()
    throw (IOException)
{
    try
    {
        output->flush();
    }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }
}

void PrintStream::
    close()
    throw (IOException)
{
    try
    {
        output->close();
    }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }
}

void PrintStream::
    write( int b )
    throw (IOException)
{
    try
    {   output->write(b); }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }
}

void PrintStream::
    write( byte b[], int len)
    throw (IOException)
{
    try
    {   output->write(b, len); }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }
}

void PrintStream::
    println( system::StringRef str)
{
    int len = str->length();
    char * buffer = new char[ len + 2];
    str-> getChars( 0, len, buffer, 0);
    buffer[ len ] = '\n';
    buffer[ len + 1] = 0;

    try
    {   output->write( (byte *)(buffer), len + 1 ); }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }

    delete [] buffer;
}

void PrintStream::
    println( const char text[] )
{
    int len = strlen( text );
    try
    {
        output->write( (byte *)(text), len );
        output->write( (byte) '\n' );
    }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }
}

void PrintStream::
    println( int i )
{
    int len;
    const int max = 64;
    char buffer[ max ];

    len = snprintf( buffer, max, "%d\n", i );

    try
    {   output->write( (byte *)(buffer), len ); }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }
}

void PrintStream::
    print( system::StringRef str)
{
    int len = str->length();
    char * buffer = new char[ len + 2];
    str-> getChars( 0, len, buffer, 0);
    buffer[ len ] = 0;

    try
    {   output->write( (byte *)(buffer), len ); }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }

    delete [] buffer;
}

void PrintStream::
    print( const char text[] )
{
    int len = strlen( text );
    try
    {
        output->write( (byte *)(text), len );
    }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }
}

void PrintStream::
    print( int i )
{
    int len;
    const int max = 64;
    char buffer[ max ];

    len = snprintf( buffer, max, "%d", i );

    try
    {   output->write( (byte *)(buffer), len ); }
    catch( IOException e)
    {
        e = e; // avoid warning
        error = true;
    }
}

bool PrintStream::
    checkError()
{
    return error;
}

bool PrintStream::
    equals( system::ObjectRef o) const
{
    return const_cast<const stdbase::system::Object *>(o.get()) == this;
}

PrintStream::
PrintStream( const OutputStreamRef & ref)
    :   Object(),
        output( ref ),
        error(false)
{}

PrintStream::
~PrintStream()
{
    try {
        output->close();
    }
    catch( IOException e)
    {
        e = e; // avoid warning
    }
}

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

---