loglog.cc

// Module:  Log4CPLUS
// File:    loglog.cxx
// Created: 6/2001
// Author:  Tad E. Smith
//
//
// Copyright 2001-2010 Tad E. Smith
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "dcmtk/oflog/streams.h"
#include "dcmtk/oflog/helpers/loglog.h"
#include "dcmtk/oflog/thread/syncpub.h"
#include "dcmtk/oflog/thread/threads.h"
#include "dcmtk/oflog/internal/env.h"
#include "dcmtk/oflog/consap.h"
#include <ostream>
#include <stdexcept>


namespace dcmtk {
namespace log4cplus { namespace helpers {

namespace
{

static tchar const PREFIX[] = DCMTK_LOG4CPLUS_TEXT("log4cplus: ");
static tchar const WARN_PREFIX[] = DCMTK_LOG4CPLUS_TEXT("log4cplus:WARN ");
static tchar const ERR_PREFIX[] = DCMTK_LOG4CPLUS_TEXT("log4cplus:ERROR ");

} // namespace


LogLog *
LogLog::getLogLog()
{
    return &helpers::getLogLog ();
}


LogLog::LogLog()
    : debugEnabled(TriUndef)
    , quietMode(TriUndef)
    , mutex()
{ }


LogLog::~LogLog()
{ }


void
LogLog::setInternalDebugging(bool enabled)
{
    thread::MutexGuard guard (mutex);

    debugEnabled = enabled ? TriTrue : TriFalse;
}


void
LogLog::setQuietMode(bool quietModeVal)
{
    thread::MutexGuard guard (mutex);

    quietMode = quietModeVal ? TriTrue : TriFalse;
}


void
LogLog::debug(const log4cplus::tstring& msg) const
{
    logging_worker (tcout, &LogLog::get_debug_mode, PREFIX, msg.c_str());
}


void
LogLog::debug(tchar const * msg) const
{
    logging_worker (tcout, &LogLog::get_debug_mode, PREFIX, msg);
}


void
LogLog::warn(const log4cplus::tstring& msg) const
{
    logging_worker (tcerr, &LogLog::get_not_quiet_mode, WARN_PREFIX, msg.c_str());
}


void
LogLog::warn(tchar const * msg) const
{
    logging_worker (tcerr, &LogLog::get_not_quiet_mode, WARN_PREFIX, msg);
}


void
LogLog::error(const log4cplus::tstring& msg, bool throw_flag) const
{
    logging_worker (tcerr, &LogLog::get_not_quiet_mode, ERR_PREFIX, msg.c_str(),
        throw_flag);
}


void
LogLog::error(tchar const * msg, bool throw_flag) const
{
    logging_worker (tcerr, &LogLog::get_not_quiet_mode, ERR_PREFIX, msg,
        throw_flag);
}


bool
LogLog::get_quiet_mode () const
{
    if (quietMode == TriUndef)
        set_tristate_from_env (&quietMode,
            DCMTK_LOG4CPLUS_TEXT ("DCMTK_LOG4CPLUS_LOGLOG_QUIETMODE"));

    return quietMode == TriTrue;
}


bool
LogLog::get_not_quiet_mode () const
{
    return ! get_quiet_mode ();
}


bool
LogLog::get_debug_mode () const
{
    if (debugEnabled == TriUndef)
        set_tristate_from_env (&debugEnabled,
            DCMTK_LOG4CPLUS_TEXT ("DCMTK_LOG4CPLUS_LOGLOG_DEBUGENABLED"));

    return debugEnabled && ! get_quiet_mode ();
}


void
LogLog::set_tristate_from_env (TriState * result, tchar const * envvar_name)
{
    tstring envvar_value;
    bool exists = internal::get_env_var (envvar_value, envvar_name);
    bool value = false;
    if (exists && internal::parse_bool (value, envvar_value) && value)
        *result = TriTrue;
    else
        *result = TriFalse;
}


void
LogLog::logging_worker (tostream & os, bool (LogLog:: * cond) () const,
    tchar const * prefix, tchar const * msg, bool throw_flag) const
{
    bool output;
    {
        thread::MutexGuard guard (mutex);
        output = (this->*cond) ();
    }

    if (DCMTK_LOG4CPLUS_UNLIKELY (output))
    {
        // XXX This is potential recursive lock of
        // ConsoleAppender::outputMutex.
        thread::MutexGuard outputGuard (ConsoleAppender::getOutputMutex ());
        os << prefix << msg << OFendl;
    }

    if (DCMTK_LOG4CPLUS_UNLIKELY (throw_flag))
        throw STD_NAMESPACE runtime_error (DCMTK_LOG4CPLUS_TSTRING_TO_STRING (msg));
}


} } // namespace log4cplus { namespace helpers {
} // end namespace dcmtk