XWriter.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
#include <windows.h>    // dcl/Thread.h
#endif
 
#include <dcl/XWriter.h>
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/XWriter.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(XWriter, Writer)
 
String XWriter::toString() const
{
    StringBuilder r = className() + __T("(");
    if (__writer)
        r += __writer->toString();
    else
        r += __T("null");
    r += __T(")");
 
    return r;
}
 
XWriter::XWriter(Writer* __destroy__ _pWriter)
{
    __writer = _pWriter;
}
 
Writer* XWriter::setWriter(Writer* __destroy__ _pWriter)
{
    Writer* r = __writer;
    __writer = _pWriter;
    return r;
}
 
XWriter::~XWriter()
{
    try {
        close();
    }
    catch (Exception* cause) {
        __DCL_TRACE1(__T("%ls\n"), cause->toString().data());
        cause->destroy();
    }
}
 
void XWriter::close()
    __DCL_THROWS1(IOException*)
{
    if (__writer) {
        Thread::SingleLockMutex lockAndUnlock(__lock);
        Exception* e = NULL;
        Writer* writer = __writer;
        __writer = NULL;
        try {
            writer->close();
        }
        catch (Exception* cause) {
            e = cause;
        }
        writer->destroy();
 
        if (e) {
            throw e;
        }
    }
}
 
void XWriter::flush()
    __DCL_THROWS1(IOException*)
{
    if (__writer) {
        Thread::SingleLockMutex lockAndUnlock(__lock);
        __writer->flush();
    }
}
 
Writer& XWriter::write(const wchar_t* _buf, size_t _n)
    __DCL_THROWS1(IOException*)
{
    if (__writer) {
        Thread::SingleLockMutex lockAndUnlock(__lock);
         __writer->write(_buf, _n);
    }
    return *this;
}
 
int XWriter::vprintf(const wchar_t* _format, va_list _arglist)
    __DCL_THROWS1(IOException*)
{
    int n = 0;
    if (__writer) {
        Thread::SingleLockMutex lockAndUnlock(__lock);
        n = __writer->vprintf(_format, _arglist);
    }
    return n;
}
 
__DCL_END_NAMESPACE