OutputStreamWriter.cpp

Go to the documentation of this file.

 
#include <dcl/Config.h>
 
#if __DCL_WINDOWS
#include <windows.h>
#endif
 
#include <dcl/Charset.h>
#include <dcl/OutputStreamWriter.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/OutputStreamWriter.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(OutputStreamWriter, Writer)
 
String OutputStreamWriter::toString() const
{
    StringBuilder r = className();
    if (__output)
    {
        r += __T("(") + __output->toString() + __T(",");
        if (__encoder)
            r += __encoder->className();
        else
            r += __T("null");
        r += __T(")");
    }
    else
        r += __T(" closed");
    return r;
}
 
OutputStreamWriter::OutputStreamWriter()
{
    __output = NULL;
    __encoder = NULL;
    __closeDestroy = false;
}
 
OutputStreamWriter::OutputStreamWriter(
        OutputStream&   _output,
        CharsetEncoder& _encoder
        )
{
    __output = &_output;
    __encoder = &_encoder;
    __closeDestroy = false;
}
 
OutputStreamWriter::OutputStreamWriter(
        OutputStream*   _pOutput,       // new OutputStream
        CharsetEncoder*   _pEncoder   // = NULL
        )
{
    __DCL_ASSERT_PARAM(_pOutput != NULL);
 
    __output = _pOutput;
    __encoder = _pEncoder;
    __closeDestroy = true;
 
    if (!__encoder)
        __encoder = new LocaleEncoder();
}
 
OutputStreamWriter::~OutputStreamWriter()
{
    if (__output)
    {
        try
        {
            close();
        }
        catch (Exception* cause)
        {
            __DCL_TRACE1(__T("%ls\n"), cause->toString().data());
            cause->destroy();
        }
    }
}
 
void OutputStreamWriter::close()
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__output != NULL);
 
    Exception* e = NULL;
    OutputStream* output = __output;
    CharsetEncoder* encoder = __encoder;
    __output = NULL;
    __encoder = NULL;
 
    if (__closeDestroy)
    {
        if (encoder)
            encoder->destroy();
 
        try
        {
            output->close();
        }
        catch (Exception* cause)
        {
            e = cause;
        }
        output->destroy();
    }
 
    if (e)
        throw e;
}
 
void OutputStreamWriter::flush()
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__output != NULL);
 
    __output->flush();
}
 
Writer& OutputStreamWriter::write(const wchar_t* _buf, size_t _n)
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__output != NULL);
    __DCL_ASSERT_PARAM(_buf != NULL);
 
    __DCL_ASSERT(__encoder != NULL);
 
    const wchar_t* pCur = _buf;
    const wchar_t* pEnd = _buf + _n;
    byte_t aOutBuf[512];
    size_t nInCount;
 
    while ((nInCount = pEnd - pCur) > 0)
    {
        size_t nOutCount = __countof(aOutBuf, byte_t);
        int r = __encoder->encode(pCur, nInCount, aOutBuf, nOutCount);
        if (r != CS_NOERROR)
            throw (new IOException(toString(), new CharsetConvertException(r)));
        __output->write(aOutBuf, nOutCount);
        pCur += nInCount;
    }
 
    return *this;
}
 
__DCL_END_NAMESPACE