bsls_logseverity.h

Go to the documentation of this file.

/// @file bsls_logseverity.h
///
/// The content of this file has been pre-processed for Doxygen.
///
 
 
// bsls_logseverity.h                                                 -*-C++-*-
#ifndef INCLUDED_BSLS_LOGSEVERITY
#define INCLUDED_BSLS_LOGSEVERITY
 
#include <bsls_ident.h>
BSLS_IDENT("$Id: $")
 
/// @defgroup bsls_logseverity bsls_logseverity
/// @brief  Enumerate a set of logging severity levels.
/// @addtogroup bsl
/// @{
/// @addtogroup bsls
/// @{
/// @addtogroup bsls_logseverity
/// @{
///
/// <h1> Outline </h1>
/// * <a href="#bsls_logseverity-purpose"> Purpose</a>
/// * <a href="#bsls_logseverity-classes"> Classes </a>
/// * <a href="#bsls_logseverity-description"> Description </a>
///   * <a href="#bsls_logseverity-enumerators"> Enumerators </a>
///   * <a href="#bsls_logseverity-usage"> Usage </a>
///     * <a href="#bsls_logseverity-example-1-basic-syntax"> Example 1: Basic Syntax </a>
///
/// # Purpose {#bsls_logseverity-purpose}
/// Enumerate a set of logging severity levels.
///
/// # Classes {#bsls_logseverity-classes}
///
/// -  bsls::LogSeverity: namespace for enumerating logging severity levels
///
/// @see  bsls_log
///
/// # Description {#bsls_logseverity-description}
/// This component provides a namespace for the `enum` type
/// `bsls::LogSeverity::Enum`, which enumerates a set of severity levels used
/// for logging with `bsls_log`.
///
/// ## Enumerators {#bsls_logseverity-enumerators}
///
///
/// @code
/// Name          Description
/// -----------   -------------------------------------------------------------
/// e_FATAL       A severity appropriate for log messages accompanying a fatal
///               event (i.e., one that will cause a *crash*).
///
/// e_ERROR       A severity appropriate for log messages accompanying an
///               unexpected error (i.e., one that will cause incorrect
///               behavior).
///
/// e_WARN        A severity appropriate for log messages accompanying an
///               event that may indicate a problem.
///
/// e_INFO        A severity appropriate for log messages providing informative
///               status about the running process.
///
/// e_DEBUG       A severity appropriate for log messages providing information
///               useful for debugging.
///
/// e_TRACE       A severity appropriate for log messages providing detailed
///               trace information.
/// @endcode
///
/// ## Usage {#bsls_logseverity-usage}
///
///
/// This section illustrates intended use of this component.
///
/// ### Example 1: Basic Syntax {#bsls_logseverity-example-1-basic-syntax}
///
///
/// The following snippets of code provide a simple illustration of using
/// `bsls::LogSeverity`.
///
/// First, we create a variable `value` of type `bsls::LogSeverity::Enum`
/// and initialize it with the enumerator value
/// `bsls::LogSeverity::e_DEBUG`:
/// @code
/// bsls::LogSeverity::Enum value = bsls::LogSeverity::e_DEBUG;
/// @endcode
/// Now, we store the address of its ASCII representation in a pointer variable,
/// `asciiValue`, of type `const char *`:
/// @code
/// const char *asciiValue = bsls::LogSeverity::toAscii(value);
/// @endcode
/// Finally, we verify the value of `asciiValue`:
/// @code
/// assert(0 == strcmp(asciiValue, "DEBUG"));
/// @endcode
/// @}
/** @} */
/** @} */
 
/** @addtogroup bsl
 * @{
 */
/** @addtogroup bsls
 * @{
 */
/** @addtogroup bsls_logseverity
 * @{
 */
 
 
namespace bsls {
 
                         // ==================
                         // struct LogSeverity
                         // ==================
 
/// This `struct` provides a namespace for enumerating the set of logging
/// severity levels used in the `bsls` logging framework (see `bsls_log`).
/// See `Enum` in the TYPES sub-section for details.
struct LogSeverity {
 
  public:
    // TYPES
    enum Enum {
        // Enumeration of logging severity levels.
 
        e_FATAL = 0,  // a condition that will (likely) cause a *crash*
        e_ERROR = 1,  // a condition that *will* cause incorrect behavior
        e_WARN  = 2,  // a *potentially* problematic condition
        e_INFO  = 3,  // data about the running process
        e_DEBUG = 4,  // information useful while debugging
        e_TRACE = 5   // execution trace data
    };
 
  public:
    /// Return the non-modifiable string representation corresponding to the
    /// specified enumeration `value`, if it exists, and a unique (error)
    /// string otherwise.  The string representation of `value` matches its
    /// corresponding enumerator name with the "e_" prefix elided.  For
    /// example:
    /// @code
    /// bsl::cout << LogSeverity::toAscii(LogSeverity::e_DEBUG);
    /// @endcode
    /// will print the following on standard output:
    /// @code
    /// DEBUG
    /// @endcode
    /// Note that specifying a `value` that does not match any of the
    /// enumerators will result in a string representation that is distinct
    /// from any of those corresponding to the enumerators, but is otherwise
    /// unspecified.
    static const char *toAscii(LogSeverity::Enum value);
};
 
}  // close package namespace
 
 
#endif
 
// ----------------------------------------------------------------------------
// Copyright 2016 Bloomberg Finance L.P.
//
// 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.
// ----------------------------- END-OF-FILE ----------------------------------
 
/** @} */
/** @} */
/** @} */