locked_logger.cpp

Go to the documentation of this file.

#ifndef LOCKED_LOGGER_IMPLEMENTATION_FILE
#define LOCKED_LOGGER_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : locked_logger                                                     *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2002-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#ifndef OMIT_PROGRAM_WIDE_LOGGER

#include "locked_logger.h"

#include <basis/istring.h>
#include <basis/set.cpp>

locked_logger::locked_logger(log_base *the_logger)
: log_base(),
  locked_object<log_base>(the_logger)
{
#ifdef NOISY_LOCKED_LOGGER
  // debugging code.
  write_to_critical_events((istring("app ") + portable::application_name()
      + isprintf(" pid %d creating locked logger.", process_id())).s());
#endif
}

locked_logger::~locked_logger()
{
  log_base *old_log = swap(NIL);
  WHACK(old_log);
}

#define LOCK_LOGGER(retval) \
  log_base *real_guy = lock_object(); \
  if (!real_guy) { \
    unlock_object(real_guy); \
    return retval; \
  }

#define UNLOCK_LOGGER \
  unlock_object(real_guy)

bool locked_logger::established()
{
  LOCK_LOGGER(false);
  UNLOCK_LOGGER;
  return true;
}

void locked_logger::add_filter(int new_filter)
{
  LOCK_LOGGER();
  real_guy->add_filter(new_filter);
  UNLOCK_LOGGER;
}

void locked_logger::remove_filter(int old_filter)
{
  LOCK_LOGGER();
  real_guy->remove_filter(old_filter);
  UNLOCK_LOGGER;
}

bool locked_logger::member(int filter_to_check)
{
  LOCK_LOGGER(false);
  bool to_return = real_guy->member(filter_to_check);
  UNLOCK_LOGGER;
  return to_return;
}

void locked_logger::clear_filters()
{
  LOCK_LOGGER();
  real_guy->clear_filters();
  UNLOCK_LOGGER;
}

int_set locked_logger::filter_set()
{
  LOCK_LOGGER(int_set());
  int_set to_return = real_guy->filter_set();
  UNLOCK_LOGGER;
  return to_return;
}

log_base::line_ending locked_logger::eol()
{
  LOCK_LOGGER(LF_AT_END);
  log_base::line_ending to_return = real_guy->eol();
  UNLOCK_LOGGER;
  return to_return;
}

void locked_logger::eol(line_ending to_set)
{
  LOCK_LOGGER();
  real_guy->eol(to_set);
  UNLOCK_LOGGER;
}

istring locked_logger::get_ending()
{
  LOCK_LOGGER(istring::empty_string());
  istring to_return = real_guy->get_ending();
  UNLOCK_LOGGER;
  return to_return;
}

void locked_logger::get_ending(istring &to_end)
{
  LOCK_LOGGER();
  real_guy->get_ending(to_end);
  UNLOCK_LOGGER;
}

outcome locked_logger::log(const istring &info, int filter)
{
  LOCK_LOGGER(common::BAD_INPUT);
  outcome to_return = real_guy->log(info, filter);
  UNLOCK_LOGGER;
  return to_return;
}

#endif


#endif //LOCKED_LOGGER_IMPLEMENTATION_FILE

---