Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package opalj

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode.

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode. OPAL is designed with performance, scalability and adaptability in mind.

    Its main components are:

    • a library (Common) which provides generally useful data-structures and algorithms for static analyses.
    • a framework for implementing lattice based static analyses (Static Analysis Infrastructure)
    • a framework for parsing Java bytecode (Bytecode Infrastructure) that can be used to create arbitrary representations.
    • a library to create a one-to-one in-memory representation of Java bytecode (Bytecode Disassembler).
    • a library to create a representation of Java bytecode that facilitates writing simple static analyses (Bytecode Representation - org.opalj.br).
    • a scalable, easily customizable framework for the abstract interpretation of Java bytecode (Abstract Interpretation Framework - org.opalj.ai).
    • a library to extract dependencies between code elements and to facilitate checking architecture definitions.
    • a library for the lightweight manipulation and creation of Java bytecode (Bytecode Assembler).

    General Design Decisions

    Thread Safety

    Unless explicitly noted, OPAL is thread safe. I.e., the classes defined by OPAL can be considered to be thread safe unless otherwise stated. (For example, it is possible to read and process class files concurrently without explicit synchronization on the client side.)

    No null Values

    Unless explicitly noted, OPAL does not null values I.e., fields that are accessible will never contain null values and methods will never return null. If a method accepts null as a value for a parameter or returns a null value it is always explicitly documented. In general, the behavior of methods that are passed null values is undefined unless explicitly documented.

    No Typecasts for Collections

    For efficiency reasons, OPAL sometimes uses mutable data-structures internally. After construction time, these data-structures are generally represented using their generic interfaces (e.g., scala.collection.{Set,Map}). However, a downcast (e.g., to add/remove elements) is always forbidden as it would effectively prevent thread-safety.

    Assertions

    OPAL makes heavy use of Scala's Assertion Facility to facilitate writing correct code. Hence, for production builds (after thorough testing(!)) it is highly recommend to build OPAL again using -Xdisable-assertions.

    Definition Classes
    org
  • package log
    Definition Classes
    opalj
  • BasicLogMessage
  • ConsoleOPALLogger
  • DevNullLogger
  • Error
  • ExceptionLogMessage
  • Fatal
  • GlobalLogContext
  • Info
  • Level
  • LogContext
  • LogMessage
  • OPALLogger
  • StandardLogContext
  • StandardLogMessage
  • Warn

object OPALLogger extends OPALLogger

OPAL's logging facility.

Usage

Basic

E.g., using the global context and the convenience methods.

implicit val logContext : LogContext = org.opalj.log.GlobalContext
OPALLogger.info("project", "the project is garbage collected")

or

OPALLogger.info("project", "the project is garbage collected")(org.opalj.log.GlobalContext)
Advanced

Logging a message only once.

implicit val logContext : LogContext = org.opalj.log.GlobalContext
OPALLogger.logOnce(Warn("project configuration", "the method cannot be resolved"))

Initialization

If the GlobalLogContext should not use the default ConsoleOPALLogger then the logger can be changed using updateLogger.

Thread Safety

Thread safe.

Source
OPALLogger.scala
Linear Supertypes
OPALLogger, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. OPALLogger
  2. OPALLogger
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def debug(p: => Boolean, category: String, message: => String)(implicit ctx: LogContext): Unit

    Debug message are only included in the code if assertions are turned on and the predicate p evaluates to true.

    Debug message are only included in the code if assertions are turned on and the predicate p evaluates to true. If debug message are logged, then they are logged as Info-level messages.

    Annotations
    @elidable()
  2. final def debug(category: String, message: String)(implicit ctx: LogContext): Unit

    Debug message are only included in the code if assertions are turned on.

    Debug message are only included in the code if assertions are turned on. If debug message are logged, then they are logged as Info-level messages.

    Annotations
    @elidable()
  3. final def error(category: String, message: String, t: Throwable)(implicit ctx: LogContext): Unit

    Log an error message.

    Log an error message. Error message should either be related to internal errors or to project configurations that are so badly broken that a meaningful analysis is not possible.

    This method is primarily a convenience method that creates an Error message which is the logged.

  4. final def error(category: String, message: String)(implicit ctx: LogContext): Unit

    Log an error message.

    Log an error message. Error message should either be related to internal errors or to project configurations that are so badly broken that a meaningful analysis is not possible.

    This method is primarily a convenience method that creates an Error message which is the logged.

  5. def globalLogger(): OPALLogger
  6. final def info(category: String, message: String)(implicit ctx: LogContext): Unit

    Log some general information.

    Log some general information. General information may be related, e.g., to the overall progress of the analysis, the results of an analysis, the major configuration settings.

    This method is primarily a convenience method that creates an Info message which is the logged.

    Note

    Do not use this method if the analysis may create the same message multiple times. In this case use logOnce.

  7. def isUnregistered(ctx: LogContext): Boolean
  8. def log(message: LogMessage)(implicit ctx: LogContext): Unit

    The given message is logged.

    The given message is logged.

    Definition Classes
    OPALLogger → OPALLogger
  9. final def logOnce(message: LogMessage)(implicit ctx: LogContext): Unit

    The given message is only logged once.

    The given message is only logged once. This is particularly useful if an analysis may hit a specific problem multiple times, but it is sufficient/meaningful to log it only once.

    This method should not be used if the message may only be generated at most once. The respective message will be cached in the log context.

    Definition Classes
    OPALLogger
  10. def logger(ctx: LogContext): OPALLogger
  11. final def progress(message: String)(implicit ctx: LogContext): Unit

    Logs a message in the category "progress".

  12. def register(ctx: LogContext, logger: OPALLogger = new ConsoleOPALLogger(true)): Unit

    Registers the given context with the OPAL logging facility and associates the specified logger with the context.

  13. def unregister(ctx: LogContext): Unit
  14. def updateLogger(ctx: LogContext, logger: OPALLogger): Unit
  15. final def warn(category: String, message: String)(implicit ctx: LogContext): Unit

    Log a warning.

    Log a warning. Warnings are typically related to incomplete project configurations that may affect the overall precision of the analysis, but which are not rendering the analysis meaningless.

    This method is primarily a convenience method that creates an Warn message which is the logged.

    Note

    Do not use this method if the analysis may create the same message multiple times. In this case use logOnce.