log_base.cpp

Go to the documentation of this file.

#ifndef LOG_BASE_IMPLEMENTATION_FILE
#define LOG_BASE_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : log_base                                                          *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1996-$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                               *
\*****************************************************************************/

#include "function.h"
#include "istring.h"
#include "log_base.h"
#include "mutex.h"
#include "set.cpp"

log_base::log_base()
: _lock(new mutex),
  _filter_set(new int_set()),
  _ending(pick_ending_for_platform())
{}


log_base::log_base(const log_base &to_copy)
: object_base(),
  _lock(new mutex),
  _filter_set(new int_set(*to_copy._filter_set)),
  _ending(to_copy._ending)
{}

log_base::~log_base()
{
  WHACK(_filter_set);
  WHACK(_lock);
}

log_base &log_base::operator =(const log_base &to_copy)
{
  if (this == &to_copy) return *this;
  *_filter_set = *to_copy._filter_set;
  _ending = to_copy._ending;
  return *this;
}

outcome log_base::log(const char *info, int filter)
{ return log(istring(info), filter); }

void log_base::clear_filters()
{
  auto_synchronizer l(*_lock);
  _filter_set->clear();
}

void log_base::remove_filter(int old_filter)
{
  auto_synchronizer l(*_lock);
  _filter_set->remove(old_filter);
}

void log_base::add_filter(int new_filter)
{
  auto_synchronizer l(*_lock);
  _filter_set->add(new_filter);
}

void log_base::stuff_filter_set(const int_set &new_list)
{
  auto_synchronizer l(*_lock);
  *_filter_set = new_list;
}

bool log_base::member(int filter)
{
  auto_synchronizer l(*_lock);
  if (filter == NEVER_PRINT) return false;
  if (_filter_set->member(ALWAYS_PRINT)) return true;
  if (_filter_set->member(NEVER_PRINT)) return false;
  return (filter == ALWAYS_PRINT) || _filter_set->member(filter);
}

int_set log_base::filter_set()
{
  auto_synchronizer l(*_lock);
  return *_filter_set;
}

log_base::line_ending log_base::eol()
{
  auto_synchronizer l(*_lock);
  return _ending;
}

void log_base::eol(line_ending to_set)
{
  auto_synchronizer l(*_lock);
  _ending = (to_set == NO_ENDING)? NO_ENDING
      : (to_set == CRLF_AT_END)? CRLF_AT_END : LF_AT_END;
}

log_base::line_ending log_base::pick_ending_for_platform()
{
#ifdef __UNIX__
  // obviously a unix OS, unless someone's playing games with us.
  return LF_AT_END;
#elif defined(__WIN32__)
  // smells like DOS.
  return CRLF_AT_END;
#else
  // pick the unix default if we can't tell.
  return LF_AT_END;
#endif
}

const char *log_base::string_for_ending(line_ending end)
{
  static const char *CRLF_AT_END_STRING = "\r\n";
  static const char *LF_AT_END_STRING = "\n";
  static const char *NO_ENDING_STRING = "";

  switch (end) {
    case CRLF_AT_END: return CRLF_AT_END_STRING;
    case NO_ENDING: return NO_ENDING_STRING;
    case LF_AT_END:  // fall-through to default.
    default: return LF_AT_END_STRING;
  }
}

const char *log_base::platform_ending()
{ return string_for_ending(pick_ending_for_platform()); }

istring log_base::get_ending() { return string_for_ending(_ending); }

void log_base::get_ending(istring &to_end) { to_end += get_ending(); }


#endif //LOG_BASE_IMPLEMENTATION_FILE

---