inline def traceEntry()

in src/main/scala-3/org/apache/logging/log4j/scala/Logger.scala [456:567]

• 23 lines of code
• 1 McCabe index (conditional complexity)

  inline def traceEntry(inline message: Message): EntryMessage =
    delegate.traceEntry(message)

  /**
    * Logs exit from a method with no result.
    */
  inline def traceExit(): Unit =
    delegate.traceExit()

  /**
    * Logs exiting from a method with result.
    *
    * @param result The result being returned from the method call
    * @return `result`
    */
  inline def traceExit[R](inline result: R): R =
    delegate.traceExit(result)

  /**
    * Logs exiting from a method with no result.
    *
    * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods
    */
  inline def traceExit(inline entryMessage: EntryMessage): Unit =
    delegate.traceExit(entryMessage)

  /**
    * Logs exiting from a method with result.
    *
    * {{{
    * def doSomething(foo: String, bar: Int): Int = {
    *   val entryMessage = logger.traceEntry(foo, bar)
    *   // do something
    *   traceExit(entryMessage, value)
    * }
    * }}}
    *
    * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods
    * @param result       The result being returned from the method call
    * @return `result`
    */
  inline def traceExit[R](inline entryMessage: EntryMessage, result: R): R =
    delegate.traceExit(entryMessage, result)

  /**
    * Logs exiting from a method with result. Allows custom formatting of the result.
    *
    * @param message the Message containing the formatted result
    * @param result  The result being returned from the method call.
    * @return `result`
    */
  inline def traceExit[R](inline message: Message, result: R): R =
    delegate.traceExit(message, result)

  /**
    * Logs an exception or error to be thrown.
    *
    * {{{
    *   throw logger.throwing(myException)
    * }}}
    *
    * @param t the Throwable
    * @return `t`
    */
  inline def throwing[T <: Throwable](inline t: T): T =
    delegate.throwing(t)

  /**
    * Logs an exception or error to be thrown to a specific logging level.
    *
    * {{{
    *   throw logger.throwing(Level.DEBUG, myException)
    * }}}
    *
    * @param level the logging Level.
    * @param t     the Throwable
    * @return `t`
    */
  inline def throwing[T <: Throwable](inline level: Level, inline t: T): T =
    delegate.throwing(level, t)

  /**
    * Logs an exception or error that has been caught.
    *
    * @param t the Throwable.
    */
  inline def catching(inline t: Throwable): Unit =
    delegate.catching(t)

  /**
    * Logs an exception or error that has been caught to a specific logging level.
    *
    * @param level The logging Level.
    * @param t     The Throwable.
    */
  inline def catching(inline level: Level, inline t: Throwable): Unit =
    delegate.catching(level, t)


  /** Always logs a message at the specified level. It is the responsibility of the caller to ensure the specified
    * level is enabled.
    *
    * Should normally not be used directly from application code, but needs to be public for access by macros.
    *
    * @param level   log level
    * @param marker  marker or `null`
    * @param message message
    * @param cause   cause or `null`
    */
  def logMessage(level: Level, marker: Marker, message: Message, cause: Throwable): Unit = {
    delegate.logMessage(Logger.FQCN, level, marker, message, cause)
  }