Scale Stack 0.3 Developer Documentation

scalestack/kernel/logger.h

Go to the documentation of this file.

/*
 * Scale Stack
 *
 * Copyright 2010 Eric Day
 *
 * 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.
 */

#ifndef SCALESTACK_KERNEL_LOGGER_H
#define SCALESTACK_KERNEL_LOGGER_H

#include <cstdarg>
#include <exception>

#include <scalestack/kernel/log.h>

namespace scalestack
{
namespace kernel
{

class logger
{
public:

  logger(size_t threshold);

  virtual ~logger();

  size_t get_threshold(void);

  void set_threshold(size_t threshold);

  void log_fatal(const char* format, ...) const;

  void log_error(const char* format, ...) const;

  void log_notice(const char* format, ...) const;

  void log_info(const char* format, ...) const;

  void log_debug(const char* format, ...) const;

protected:

  size_t _threshold;

private:

  logger(const logger&);

  logger& operator=(const logger&);

  virtual void _set_fatal_message(const char* format,
                                  std::va_list arguments) const = 0;

  virtual void _log_message(log::level log_level,
                            const char* format,
                            std::va_list arguments) const = 0;
};

/*
 * Public methods.
 */

inline logger::logger(size_t threshold):
  _threshold(threshold)
{
}

inline logger::~logger()
{
}

inline size_t logger::get_threshold(void)
{
  return _threshold;
}

inline void logger::set_threshold(size_t threshold)
{
  _threshold = threshold;
}

inline void logger::log_fatal(const char* format, ...) const
{
  std::va_list arguments;
  va_start(arguments, format);

  /*
   * We know this is going to trigger a catch because fatal messages throw
   * exceptions, so this is done so we can call va_end before passing on
   * the exception.
   */
  try
  {
    /*
     * We check for log::LEVEL_ERROR since we only want to report fatal
     * messages through exceptions when the logging threshold is 0.
     */
    if (_threshold >= log::LEVEL_ERROR)
      _log_message(log::LEVEL_FATAL, format, arguments);
    else
      _set_fatal_message(format, arguments);
  }
  catch (std::exception&)
  {
    va_end(arguments);
    throw;
  }

  va_end(arguments);
}

inline void logger::log_error(const char* format, ...) const
{
  if (_threshold >= log::LEVEL_ERROR)
  {
    std::va_list arguments;
    va_start(arguments, format);
    _log_message(log::LEVEL_ERROR, format, arguments);
    va_end(arguments);
  }
}

inline void logger::log_notice(const char* format, ...) const
{
  if (_threshold >= log::LEVEL_NOTICE)
  {
    std::va_list arguments;
    va_start(arguments, format);
    _log_message(log::LEVEL_NOTICE, format, arguments);
    va_end(arguments);
  }
}

inline void logger::log_info(const char* format, ...) const
{
  if (_threshold >= log::LEVEL_INFO)
  {
    std::va_list arguments;
    va_start(arguments, format);
    _log_message(log::LEVEL_INFO, format, arguments);
    va_end(arguments);
  }
}

inline void logger::log_debug(const char* format, ...) const
{
  if (_threshold >= log::LEVEL_DEBUG)
  {
    std::va_list arguments;
    va_start(arguments, format);
    _log_message(log::LEVEL_DEBUG, format, arguments);
    va_end(arguments);
  }
}

} /* namespace kernel */
} /* namespace scalestack */

#endif /* SCALESTACK_KERNEL_LOGGER_H */

---