logger_type Derived Type

  1. stdlib_logger.f90
  2. stdlib_logger
  3. logger_type

type, public :: logger_type

Public derived type (Specification)


Contents

Finalization Procedures

Type-Bound Procedures

Source Code

logger_type

Finalization Procedures

final :: final_logger

  • private subroutine final_logger(self)

    Finalizes the logger_type entity self by flushing the units

    Arguments

    TypeIntentOptionalAttributesName
    type(logger_type), intent(in) :: self

Type-Bound Procedures

procedure, public, pass(self) :: add_log_file

  • private subroutine add_log_file(self, filename, unit, action, position, status, stat)

    Opens a formatted sequential access output file, filename using newunit and adds the resulting unit number to self's log_units array. action, if present, is the action specifier of the open statement, and has the default value of "write". position, if present, is the position specifier, and has the default value of "REWIND". status, if present, is the status specifier of the open statement, and has the default value of "REPLACE". stat, if present, has the value success if filename could be opened, read_only_error if action is "read", and open_failure otherwise. (Specification)

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(inout) :: self

    The logger variable to which the file is to be added
    character, intent(in) :: filename

    The name of the file to be added to the logger
    integer, intent(out), optional :: unit

    The resulting I/O unit number
    character, intent(in), optional :: action

    The action specifier for the `open`` statement
    character, intent(in), optional :: position

    The position specifier for the open statement
    character, intent(in), optional :: status

    The status specifier for the open statement
    integer, intent(out), optional :: stat

    The error status on exit with the possible values * success - no errors found * read_only_error - file unopened as action1 was"read"for an output file *open_failure- theopen` statement failed

    Example
     program main
     use stdlib_logger
     ...
     integer :: unit, stat
     ...
     call global_logger % add_log_file( 'error_log.txt', unit,      &
                                        position='asis', stat=stat )
     if ( stat /= success ) then
         error stop 'Unable to open "error_log.txt".'
     end if
     ...
 end program main

procedure, public, pass(self) :: add_log_unit

  • private subroutine add_log_unit(self, unit, stat)

    Adds unit to the log file units in log_units. unit must be an open file, of form "formatted", with "sequential" access, and an action of "write" or "readwrite", otherwise either stat, if present, has a value other than success and unit is not entered into log_units, or, if stat is not presecn, processing stops. (Specification)

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(inout) :: self

    The logger variable to which the I/O unit is to be added
    integer, intent(in) :: unit

    The input logical unit number
    integer, intent(out), optional :: stat

    An error code with the possible values * success - no problems were found * non_sequential_error - unit did not have sequential access * read_only_error - unit was not writeable * unformatted_in_error - unit was an 'unformatted' file * unopened_in_error - unit was not opened

    Example
     program main
     use stdlib_logger
     ...
     character(256) :: iomsg
     integer :: iostat, unit, stat
     ...
     open( newunit=unit, 'error_log.txt', form='formatted', &
           status='replace', position='rewind', err=999,    &
           action='read', iostat=iostat, iomsg=iomsg )
     ...
     call global_logger % add_log_unit( unit, stat )
     select case ( stat )
     ...
     case ( read_only_error )
         error stop 'Unable to write to "error_log.txt".'
     ...
     end select
     ...
 999 error stop 'Unable to open "error_log.txt".
     ...
 end program main

procedure, public, pass(self) :: configuration

  • private pure subroutine configuration(self, add_blank_line, indent, level, max_width, time_stamp, log_units)

    Reports the logging configuration of self. The following attributes are reported: 1. add_blank_line is a logical flag with .true. implying that output starts with a blank line, and .false. implying no blank line. 2. indent is a logical flag with .true. implying that subsequent columns will be indented 4 spaces and .false. implying no indentation. 3. level is the lowest level for printing a message 4. max_width is the maximum number of columns of output text with max_width == 0 => no bounds on output width. 5. time_stamp is a logical flag with .true. implying that the output will have a time stamp, and .false. implying that there will be no time stamp. 6. log_units is an array of the I/O unit numbers to which log output will be written. (Specification)

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(in) :: self

    The logger variable whose configuration is being reported
    logical, intent(out), optional :: add_blank_line

    A logical flag to add a preceding blank line
    logical, intent(out), optional :: indent

    A logical flag to indent subsequent lines
    integer, intent(out), optional :: level

    The minimum level for printing a message
    integer, intent(out), optional :: max_width

    The maximum number of columns for most outputs
    logical, intent(out), optional :: time_stamp

    A logical flag to add a time stamp
    integer, intent(out), optional allocatable:: log_units(:)

    The I/O units used in output

    Example
     module example_mod
   use stdlib_logger
   ...
 contains
   ...
   subroutine example_sub(unit, ...)
     integer, intent(in) :: unit
     ...
     integer, allocatable :: log_units(:)
     ...
     call global_logger % configuration( log_units=log_units )
     if ( size(log_units) == 0 ) then
        call add_logger_unit( unit )
     end if
     ..
   end subroutine example_sub
   ...
 end module example_mod

procedure, public, pass(self) :: configure

  • private pure subroutine configure(self, add_blank_line, indent, level, max_width, time_stamp)

    Configures the logging process for SELF. The following attributes are configured: 1. add_blank_line is a logical flag with .true. implying that output starts with a blank line, and .false. implying no blank line. add_blank_line has a startup value of .false.. 2. indent is a logical flag with .true. implying that subsequent lines will be indented 4 spaces and .false. implying no indentation. indent has a startup value of .true.. 3. level is the lowest level for printing a message 4. max_width is the maximum number of columns of output text with max_width == 0 => no bounds on output width. max_width has a startup value of 0. 5. time_stamp is a logical flag with .true. implying that the output will have a time stamp, and .false. implying that there will be no time stamp. time_stamp has a startup value of .true.. (Specification)

    Read more…

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(inout) :: self
    logical, intent(in), optional :: add_blank_line
    logical, intent(in), optional :: indent
    integer, intent(in), optional :: level
    integer, intent(in), optional :: max_width
    logical, intent(in), optional :: time_stamp

procedure, public, pass(self) :: log_debug

  • private subroutine log_debug(self, message, module, procedure)

    Writes the string message to self % log_units with optional additional text. (Specification)

    Read more…

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(in) :: self

    The logger used to send the message
    character(len=*), intent(in) :: message

    A string to be written to log_unit
    character(len=*), intent(in), optional :: module

    The name of the module containing the current invocation of log_information
    character(len=*), intent(in), optional :: procedure

    The name of the procedure containing the current invocation of log_information

procedure, public, pass(self) :: log_error

  • private subroutine log_error(self, message, module, procedure, stat, errmsg)

    Writes the string message to self % log_units with optional additional text. (Specification)

    Read more…

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(in) :: self

    The logger to be used in logging the message
    character(len=*), intent(in) :: message

    A string to be written to log_unit
    character(len=*), intent(in), optional :: module

    The name of the module containing the current invocation of log_error
    character(len=*), intent(in), optional :: procedure

    The name of the procedure containing the current invocation of log_error
    integer, intent(in), optional :: stat

    The value of the stat specifier returned by a Fortran statement
    character(len=*), intent(in), optional :: errmsg

    The value of the errmsg specifier returned by a Fortran statement

procedure, public, pass(self) :: log_information

  • private subroutine log_information(self, message, module, procedure)

    Writes the string message to self % log_units with optional additional text. (Specification)

    Read more…

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(in) :: self

    The logger used to send the message
    character(len=*), intent(in) :: message

    A string to be written to log_unit
    character(len=*), intent(in), optional :: module

    The name of the module containing the current invocation of log_information
    character(len=*), intent(in), optional :: procedure

    The name of the procedure containing the current invocation of log_information

procedure, public, pass(self) :: log_io_error

  • private subroutine log_io_error(self, message, module, procedure, iostat, iomsg)

    Writes the string message to the self % log_units with optional additional text. (Specification)

    Read more…

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(in) :: self

    The logger variable to receivee the message
    character(len=*), intent(in) :: message

    A string to be written to LOG_UNIT
    character(len=*), intent(in), optional :: module

    The name of the module containing the current invocation of REPORT_ERROR
    character(len=*), intent(in), optional :: procedure

    The name of the procedure containing the current invocation of REPORT_ERROR
    integer, intent(in), optional :: iostat

    The value of the IOSTAT specifier returned by a Fortran I/O statement
    character(len=*), intent(in), optional :: iomsg

    The value of the IOMSG specifier returned by a Fortran I/O statement

procedure, public, pass(self) :: log_message

  • private subroutine log_message(self, message, module, procedure, prefix)

    Writes the string message to the self % log_units with optional additional text. (Specification)

    Read more…

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(in) :: self

    The logger variable to receive the message
    character(len=*), intent(in) :: message

    A string to be written to log_unit
    character(len=*), intent(in), optional :: module

    The name of the module containing the current invocation of log_message
    character(len=*), intent(in), optional :: procedure

    The name of the procedure containing the current invocation of log_message
    character(len=*), intent(in), optional :: prefix

    To be prepended to message as prefix // ': ' // message.

procedure, public, pass(self) :: log_text_error

  • private subroutine log_text_error(self, line, column, summary, filename, line_number, caret, stat)

    Sends a message to self % log_units describing an error found in a line of text. (Specification)

    Read more…

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(in) :: self

    The logger variable to receive the message
    character, intent(in) :: line

    The line of text in which the error was found.
    integer, intent(in) :: column

    The one's based column in LINE at which the error starts.
    character, intent(in) :: summary

    A brief description of the error.
    character, intent(in), optional :: filename

    The name of the file, if any, in which the error was found.
    integer, intent(in), optional :: line_number

    The one's based line number in the file where line was found.
    character(len=1), intent(in), optional :: caret

    The symbol used to mark the column wher the error was first detected
    integer, intent(out), optional :: stat

    Integer flag that an error has occurred. Has the value success if no error hass occurred, index_invalid_error if column is less than zero or greater than len(line), and write_failure if any of the write statements has failed.

procedure, public, pass(self) :: log_units_assigned

  • private elemental function log_units_assigned(self)

    Returns the number of units assigned to self % log_units (Specification)

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(in) :: self

    The logger subject to the inquiry

    Return Value integer

    Read more…

procedure, public, pass(self) :: log_warning

  • private subroutine log_warning(self, message, module, procedure)

    Writes the string message to self % log_units with optional additional text. (Specification)

    Read more…

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(in) :: self

    The logger to which the message is written
    character(len=*), intent(in) :: message

    A string to be written to LOG_UNIT
    character(len=*), intent(in), optional :: module

    The name of the module containing the current invocation of log_warning
    character(len=*), intent(in), optional :: procedure

    The name of the procedure containing the current invocation of log_warning

procedure, public, pass(self) :: remove_log_unit

  • private subroutine remove_log_unit(self, unit, close_unit, stat)

    Remove the I/O unit from the self % log_units list. If close_unit is present and .true. then the corresponding file is closed. If unit is not in log_units then nothing is done. If stat is present it, by default, has the value success. If closing the unit fails, then if stat is present it has the value close_failure, otherwise processing stops with an informative message. (Specification)

    Arguments

    TypeIntentOptionalAttributesName
    class(logger_type), intent(inout) :: self

    The logger variable whose unit is to be removed
    integer, intent(in) :: unit

    The I/O unit to be removed from self
    logical, intent(in), optional :: close_unit

    A logical flag to close the unit while removing it from the SELF list
    integer, intent(out), optional :: stat

    An error status with the values * success - no problems found * close_failure - the close statement for unit failed

    Example
     module  example_mod
   use stdlib_logger
   ...
   type(logger_type) ::  alogger
 contains
   ...
   subroutine example_sub(unit, ...)
     integer, intent(in) :: unit
     ...
     call alogger % remove_log_unit( unit )
     ...
   end subroutine example_sub
   ...
 end module example_mod

Source Code

    type :: logger_type
        !! version: experimental
        
        !! Public derived type ([Specification](../page/specs/stdlib_logger.html#the-derived-type-logger_type))
        private

        logical                   :: add_blank_line = .false.
        logical                   :: indent_lines = .true.
        integer                   :: level = information_level
        integer, allocatable      :: log_units(:)
        integer                   :: max_width = 0
        logical                   :: time_stamp = .true.
        integer                   :: units = 0

    contains

        private

        procedure, public, pass(self) :: add_log_file
        procedure, public, pass(self) :: add_log_unit
        procedure, public, pass(self) :: configuration
        procedure, public, pass(self) :: configure
        procedure, public, pass(self) :: log_debug
        procedure, public, pass(self) :: log_error
        procedure, public, pass(self) :: log_information
        procedure, public, pass(self) :: log_io_error
        procedure, public, pass(self) :: log_message
        procedure, public, pass(self) :: log_text_error
        procedure, public, pass(self) :: log_units_assigned
        procedure, public, pass(self) :: log_warning
        procedure, public, pass(self) :: remove_log_unit

        final :: final_logger

    end type logger_type