file_logger.h

Go to the documentation of this file.

#ifndef FILE_LOGGER_CLASS
#define FILE_LOGGER_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : file_logger                                                       *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2000-$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 "console_logger.h"

#include <basis/function.h>
#include <basis/log_base.h>

// forward.
class byte_filer;

class LOGGERS_CLASS_STYLE file_logger : public log_base
{
public:
  file_logger();

  file_logger(const istring &filename, int limit = LOG_FILE_SIZE);

  virtual ~file_logger();

  IMPLEMENT_CLASS_NAME("file_logger");

  enum limits {
#ifndef EMBEDDED_BUILD
    LOG_FILE_SIZE = 0x10F00D
#else
    LOG_FILE_SIZE = 0x10FAB
#endif
  };

  bool good() const;

  bool reopen();

  outcome log(const istring &info, int filter = ALWAYS_PRINT);

  outcome log_bytes(const byte_array &to_log, int filter = ALWAYS_PRINT);

  outcome format_bytes(const byte_array &to_log, int filter = ALWAYS_PRINT);

  istring name() const;
  void name(const istring &new_name);

  int limit() const { return int(_file_limit); }
  void limit(int new_limit) { _file_limit = new_limit; }

  void flush();

  void truncate(size_t new_size);

private:
  istring *_filename;  
  size_t _file_limit;  
  byte_filer *_outfile;  
  mutex *_flock;  

  int size_reduction() const;

  bool open_file();

  void close_file();

  // unavailable.
  file_logger(const file_logger &);
  file_logger &operator =(const file_logger &);
};



istring LOGGERS_FUNCTION_STYLE app_name_for_file_logger();


log_base LOGGERS_FUNCTION_STYLE *set_PW_logger_for_file
    (const istring &file_name, int limit = file_logger::LOG_FILE_SIZE);

#ifndef OMIT_PROGRAM_WIDE_LOGGER
  #define SET_DEFAULT_FILE_LOGGER { \
    log_base *old_log = set_PW_logger_for_file(app_name_for_file_logger()); \
    WHACK(old_log); \
  }
#else
  #define SET_DEFAULT_FILE_LOGGER {}
#endif



class LOGGERS_CLASS_STYLE combo_logger : public file_logger
{
public:
  combo_logger(const istring &filename, int limit = LOG_FILE_SIZE,
          bool standard_error = false);
  virtual ~combo_logger();

  virtual outcome log(const istring &info, int filter = ALWAYS_PRINT);

  // overrides that enforce properties for both loggers.
  virtual void add_filter(int new_filter);
  virtual void remove_filter(int old_filter);
  virtual void clear_filters();
  virtual void eol(line_ending to_set);

  // note: currently the byte formatting routines are not supported.

private:
  console_logger *_out;  
};



log_base LOGGERS_FUNCTION_STYLE *set_PW_logger_for_combo
    (const istring &file_name, int limit = file_logger::LOG_FILE_SIZE,
     bool standard_error = false);

#ifndef OMIT_PROGRAM_WIDE_LOGGER
  #define SET_DEFAULT_COMBO_LOGGER { \
    log_base *old_log = set_PW_logger_for_combo(app_name_for_file_logger()); \
    WHACK(old_log); \
  }
  #define SET_DEFAULT_COMBO_ERROR_LOGGER { \
    log_base *old_log = set_PW_logger_for_combo(app_name_for_file_logger(), \
        file_logger::LOG_FILE_SIZE, true); \
    WHACK(old_log); \
  }
#else
  #define SET_DEFAULT_COMBO_LOGGER {}
  #define SET_DEFAULT_COMBO_ERROR_LOGGER {}
#endif

#endif

---