def fatal()

in log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala [67:441]


  def fatal(marker: Marker, message: Message): Unit =
  macro LoggerMacro.fatalMarkerMsg

  def fatal(marker: Marker, message: CharSequence): Unit =
  macro LoggerMacro.fatalMarkerCseq

  def fatal(marker: Marker, message: AnyRef): Unit =
  macro LoggerMacro.fatalMarkerObject

  def fatal(marker: Marker, message: Message, cause: Throwable): Unit =
  macro LoggerMacro.fatalMarkerMsgThrowable

  def fatal(marker: Marker, message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.fatalMarkerCseqThrowable

  def fatal(marker: Marker, message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.fatalMarkerObjectThrowable

  def fatal(message: Message): Unit =
  macro LoggerMacro.fatalMsg

  def fatal(message: CharSequence): Unit =
  macro LoggerMacro.fatalCseq

  def fatal(message: AnyRef): Unit =
  macro LoggerMacro.fatalObject

  def fatal(message: Message, cause: Throwable): Unit =
  macro LoggerMacro.fatalMsgThrowable

  def fatal(message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.fatalCseqThrowable

  def fatal(message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.fatalObjectThrowable


  def error(marker: Marker, message: Message): Unit =
  macro LoggerMacro.errorMarkerMsg

  def error(marker: Marker, message: CharSequence): Unit =
  macro LoggerMacro.errorMarkerCseq

  def error(marker: Marker, message: AnyRef): Unit =
  macro LoggerMacro.errorMarkerObject

  def error(marker: Marker, message: Message, cause: Throwable): Unit =
  macro LoggerMacro.errorMarkerMsgThrowable

  def error(marker: Marker, message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.errorMarkerCseqThrowable

  def error(marker: Marker, message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.errorMarkerObjectThrowable

  def error(message: Message): Unit =
  macro LoggerMacro.errorMsg

  def error(message: CharSequence): Unit =
  macro LoggerMacro.errorCseq

  def error(message: AnyRef): Unit =
  macro LoggerMacro.errorObject

  def error(message: Message, cause: Throwable): Unit =
  macro LoggerMacro.errorMsgThrowable

  def error(message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.errorCseqThrowable

  def error(message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.errorObjectThrowable


  def warn(marker: Marker, message: Message): Unit =
  macro LoggerMacro.warnMarkerMsg

  def warn(marker: Marker, message: CharSequence): Unit =
  macro LoggerMacro.warnMarkerCseq

  def warn(marker: Marker, message: AnyRef): Unit =
  macro LoggerMacro.warnMarkerObject

  def warn(marker: Marker, message: Message, cause: Throwable): Unit =
  macro LoggerMacro.warnMarkerMsgThrowable

  def warn(marker: Marker, message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.warnMarkerCseqThrowable

  def warn(marker: Marker, message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.warnMarkerObjectThrowable

  def warn(message: Message): Unit =
  macro LoggerMacro.warnMsg

  def warn(message: CharSequence): Unit =
  macro LoggerMacro.warnCseq

  def warn(message: AnyRef): Unit =
  macro LoggerMacro.warnObject

  def warn(message: Message, cause: Throwable): Unit =
  macro LoggerMacro.warnMsgThrowable

  def warn(message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.warnCseqThrowable

  def warn(message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.warnObjectThrowable


  def info(marker: Marker, message: Message): Unit =
  macro LoggerMacro.infoMarkerMsg

  def info(marker: Marker, message: CharSequence): Unit =
  macro LoggerMacro.infoMarkerCseq

  def info(marker: Marker, message: AnyRef): Unit =
  macro LoggerMacro.infoMarkerObject

  def info(marker: Marker, message: Message, cause: Throwable): Unit =
  macro LoggerMacro.infoMarkerMsgThrowable

  def info(marker: Marker, message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.infoMarkerCseqThrowable

  def info(marker: Marker, message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.infoMarkerObjectThrowable

  def info(message: Message): Unit =
  macro LoggerMacro.infoMsg

  def info(message: CharSequence): Unit =
  macro LoggerMacro.infoCseq

  def info(message: AnyRef): Unit =
  macro LoggerMacro.infoObject

  def info(message: Message, cause: Throwable): Unit =
  macro LoggerMacro.infoMsgThrowable

  def info(message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.infoCseqThrowable

  def info(message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.infoObjectThrowable


  def debug(marker: Marker, message: Message): Unit =
  macro LoggerMacro.debugMarkerMsg

  def debug(marker: Marker, message: CharSequence): Unit =
  macro LoggerMacro.debugMarkerCseq

  def debug(marker: Marker, message: AnyRef): Unit =
  macro LoggerMacro.debugMarkerObject

  def debug(marker: Marker, message: Message, cause: Throwable): Unit =
  macro LoggerMacro.debugMarkerMsgThrowable

  def debug(marker: Marker, message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.debugMarkerCseqThrowable

  def debug(marker: Marker, message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.debugMarkerObjectThrowable

  def debug(message: Message): Unit =
  macro LoggerMacro.debugMsg

  def debug(message: CharSequence): Unit =
  macro LoggerMacro.debugCseq

  def debug(message: AnyRef): Unit =
  macro LoggerMacro.debugObject

  def debug(message: Message, cause: Throwable): Unit =
  macro LoggerMacro.debugMsgThrowable

  def debug(message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.debugCseqThrowable

  def debug(message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.debugObjectThrowable


  def trace(marker: Marker, message: Message): Unit =
  macro LoggerMacro.traceMarkerMsg

  def trace(marker: Marker, message: CharSequence): Unit =
  macro LoggerMacro.traceMarkerCseq

  def trace(marker: Marker, message: AnyRef): Unit =
  macro LoggerMacro.traceMarkerObject

  def trace(marker: Marker, message: Message, cause: Throwable): Unit =
  macro LoggerMacro.traceMarkerMsgThrowable

  def trace(marker: Marker, message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.traceMarkerCseqThrowable

  def trace(marker: Marker, message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.traceMarkerObjectThrowable

  def trace(message: Message): Unit =
  macro LoggerMacro.traceMsg

  def trace(message: CharSequence): Unit =
  macro LoggerMacro.traceCseq

  def trace(message: AnyRef): Unit =
  macro LoggerMacro.traceObject

  def trace(message: Message, cause: Throwable): Unit =
  macro LoggerMacro.traceMsgThrowable

  def trace(message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.traceCseqThrowable

  def trace(message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.traceObjectThrowable


  /**
    * Logs a `Message` with the specific `Marker` at the given `Level`.
    *
    * @param level   the logging level
    * @param marker  the marker data specific to this log statement
    * @param message the message to be logged
    */
  def apply(level: Level, marker: Marker, message: Message): Unit =
  macro LoggerMacro.logMarkerMsg

  /**
    * Logs a string with the specific `Marker` at the given `Level`.
    *
    * @param level   the logging level
    * @param marker  the marker data specific to this log statement
    * @param message the message to be logged
    */
  def apply(level: Level, marker: Marker, message: CharSequence): Unit =
  macro LoggerMacro.logMarkerCseq

  /**
    * Logs an object with the specific `Marker` at the given `Level`.
    *
    * @param level   the logging level
    * @param marker  the marker data specific to this log statement
    * @param message the message to be logged
    */
  def apply(level: Level, marker: Marker, message: AnyRef): Unit =
  macro LoggerMacro.logMarkerObject

  /**
    * Logs a `Message` with the specific `Marker` at the given `Level` including the stack trace
    * of the given `Throwable`.
    *
    * @param level   the logging level
    * @param marker  the marker data specific to this log statement
    * @param message the message to be logged
    * @param cause   the cause
    */
  def apply(level: Level, marker: Marker, message: Message, cause: Throwable): Unit =
  macro LoggerMacro.logMarkerMsgThrowable

  /**
    * Logs a string with the specific `Marker` at the given `Level` including the stack trace
    * of the given `Throwable`.
    *
    * @param level   the logging level
    * @param marker  the marker data specific to this log statement
    * @param message the message to be logged
    * @param cause   the cause
    */
  def apply(level: Level, marker: Marker, message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.logMarkerCseqThrowable

  /**
    * Logs an object with the specific `Marker` at the given `Level` including the stack trace
    * of the given `Throwable`.
    *
    * @param level   the logging level
    * @param marker  the marker data specific to this log statement
    * @param message the message to be logged
    * @param cause   the cause
    */
  def apply(level: Level, marker: Marker, message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.logMarkerObjectThrowable

  /**
    * Logs a `Message` at the given `Level`.
    *
    * @param level   the logging level
    * @param message the message to be logged
    */
  def apply(level: Level, message: Message): Unit =
  macro LoggerMacro.logMsg

  /**
    * Logs a string at the given `Level`.
    *
    * @param level   the logging level
    * @param message the message to be logged
    */
  def apply(level: Level, message: CharSequence): Unit =
  macro LoggerMacro.logCseq

  /**
    * Logs an object at the given `Level`.
    *
    * @param level   the logging level
    * @param message the message to be logged
    */
  def apply(level: Level, message: AnyRef): Unit =
  macro LoggerMacro.logObject

  /**
    * Logs a `Message` at the given `Level` including the stack trace of the given `Throwable`.
    *
    * @param level   the logging level
    * @param message the message to be logged
    * @param cause   a `Throwable`
    */
  def apply(level: Level, message: Message, cause: Throwable): Unit =
  macro LoggerMacro.logMsgThrowable

  /**
    * Logs a string at the given `Level` including the stack trace of the given `Throwable`.
    *
    * @param level   the logging level
    * @param message the message to be logged
    * @param cause   a `Throwable`
    */
  def apply(level: Level, message: CharSequence, cause: Throwable): Unit =
  macro LoggerMacro.logCseqThrowable

  /**
    * Logs an object at the given `Level` including the stack trace of the given `Throwable`.
    *
    * @param level   the logging level
    * @param message the message to be logged
    * @param cause   a `Throwable`
    */
  def apply(level: Level, message: AnyRef, cause: Throwable): Unit =
  macro LoggerMacro.logObjectThrowable


  /**
    * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not be
    * logged.
    *
    * @return The built `EntryMessage`
    */
  def traceEntry(): EntryMessage =
    delegate.traceEntry()

  /**
    * Logs entry to a method along with its parameters.
    *
    * {{{
    * def doSomething(foo: String, bar: Int): Unit = {
    *   logger.traceEntry(foo, bar)
    *   // do something
    * }
    * }}}
    *
    * @param params the parameters to the method.
    * @return The built `EntryMessage`
    */
  def traceEntry(params: AnyRef*): EntryMessage = {
    if (params.isEmpty) {
      delegate.traceEntry()
    } else {
      delegate.traceEntry(params.head.toString, params.tail:_*)
    }
  }