LoggingSettings.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is 
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable 
// OnixS Software Services Agreement (the Agreement) and Customer end user license 
// agreements granting a non-assignable, non-transferable and non-exclusive license 
// to use the software for it's own data processing purposes under the terms defined 
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or 
// reproduction of any part of this source code or associated reference material 
// to any other location for further reproduction or redistribution, and any 
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in 
// accordance with the terms of the Agreement is a violation of copyright law.
//

#pragma once

#include <OnixS/CME/ConflatedUDP/String.h>
#include <OnixS/CME/ConflatedUDP/Integral.h>

#include <OnixS/CME/ConflatedUDP/NullLogger.h>
#include <OnixS/CME/ConflatedUDP/SettingGroup.h>

ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

/// Defines how SBE messages are traced. 
ONIXS_CONFLATEDUDP_LTWT_STRUCT MessageTracing
{
    /// Integral type used as basement for constants. 
    typedef UInt32 Base;

    /// Defines how SBE messages are traced. 
    enum Enum
    {
        /// Message tracing is disabled. 
        Disabled,

        /// Messages are traced using SBE naming from 
        /// coding templates for fields and their values. 
        SbeFormat,

        /// Messages are traced in FIX tag=value format. 
        FixFormat
    };
};

/// Serializes message tracing constant into a string. 
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&,
    MessageTracing::Enum);

/// Serializes message tracing constant into a string. 
inline
std::string
toStr(
    MessageTracing::Enum tracing)
{
    std::string str;

    toStr(str, tracing);

    return str;
}

/// Deserializes message tracing constant from a string. 
ONIXS_CONFLATEDUDP_EXPORTED
bool
fromStr(
    MessageTracing::Enum&,
    const Char*,
    size_t);

/// Parameters affecting what's logged at a debug level. 
ONIXS_CONFLATEDUDP_LTWT_CLASS 
DebugLoggingSettings
{
    const SettingGroup& group_;

    bool traceFeeds_;
    MessageTracing::Enum traceMessages_;
    bool traceBooks_;

protected:
    // To let assignment be controlled 
    // by the master container. 
    friend 
    ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL
    (
        LoggingSettings
    );

    // Re-initializes the given instance
    // as a copy of the other one without
    // involving assignment control service. 
    void
    assignNoControl(
        const 
        DebugLoggingSettings& other)
    {
        traceFeeds_ = 
            other.traceFeeds_;

        traceMessages_ = 
            other.traceMessages_;
        
        traceBooks_ = 
            other.traceBooks_;
    }

public:
    /// Initializes default settings. 
    DebugLoggingSettings(
        const SettingGroup* group = NULL)
        : group_(
            group 
                ? *group 
                : SettingGroup::null())
        , traceFeeds_(false)
        , traceMessages_(
            MessageTracing::Disabled)
        , traceBooks_(false)
    {
    }

    /// Initializes as a copy. 
    DebugLoggingSettings(
        const DebugLoggingSettings& other)
        : group_(
            SettingGroup::null())
        , traceFeeds_(
            other.traceFeeds_)
        , traceMessages_(
            other.traceMessages_)
        , traceBooks_(
            other.traceBooks_)
    {
    }

    /// Cleans everything up (if necessary). 
    ~DebugLoggingSettings()
    {
    }

    /// Defines whether feeds are to be traced. 
    /// @note By default, feeds are not traced.
    bool 
    traceFeeds() const
    {
        return traceFeeds_;
    }

    /// Defines whether feeds are to be traced. 
    void 
    traceFeeds(
        bool status)
    {
        group_.
            controlAssignment
            (
                "Trace Feeds", 
                traceFeeds_,
                status
            );
    }

    /// Defines the way SBE messages are traced. 
    /// @note By default, messages are not traced.
    MessageTracing::
    Enum 
    traceMessages() const
    {
        return traceMessages_;
    }

    /// Defines the way SBE messages are traced. 
    void
    traceMessages(
        MessageTracing::Enum tracing)
    {
        group_.
            controlAssignment
            (
                "Trace Messages", 
                traceMessages_,
                tracing
            );
    }

    /// Indicates whether books are traced. 
    /// @note By default, books are not traced.
    bool 
    traceBooks() const
    {
        return traceBooks_;
    }

    /// Indicates whether books are traced. 
    void
    traceBooks(
        bool status)
    {
        group_.
            controlAssignment
            (
                "TraceBooks", 
                traceBooks_,
                status
            );
    }

    /// Re-initializes as a copy. 
    DebugLoggingSettings&
    operator =(
        const 
        DebugLoggingSettings& other)
    {
        group_.
            controlAssignment
            (
                "Debug Logging Settings",
                &DebugLoggingSettings::assignNoControl,
                *this,
                other
            );
    
        return *this;
    }
};

#if !defined (ONIXS_CONFLATEDUDP_NO_DEPRECATED)

typedef 
DebugLoggingSettings 
HandlerDebugLoggingSettings;

#endif // ONIXS_CONFLATEDUDP_NO_DEPRECATED

/// Serializes Handler debug logging settings into a string. 
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&,
    const DebugLoggingSettings&);

/// Serializes Handler debug logging settings into a string. 
inline
std::string
toStr(
    const 
    DebugLoggingSettings& settings)
{
    std::string str;

    toStr(str, settings);

    return str;
}

/// Provides default functionality 
/// for the logging-related services. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT LoggingDefaults
{
    /// Returns instance of the default logger. 
    static Logger& logger()
    {
        static NullLogger nullLogger;

        return nullLogger;
    }
};

/// The collection of settings affecting 
/// use of logging subsystem by the Handler. 
ONIXS_CONFLATEDUDP_LTWT_CLASS
LoggingSettings 
    : public SettingGroup
{
    friend 
    ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL
    (
        HandlerSettings
    );

    Logger* logger_;

    DebugLoggingSettings debug_;

    const 
    SettingGroup& 
    group() const
    {
        return *this;
    }

    void
    assignNoControl(
        const LoggingSettings& other)
    {
        logger_ = 
            other.logger_;

        debug_.
            assignNoControl(
                other.debug_);
    }

public:
    /// Initializes the instance with the default values. 
    LoggingSettings(
        SettingAssignController* 
        controller = NULL)
        : SettingGroup(controller)
        , logger_(&LoggingDefaults::logger())
        , debug_(&group())
    {
    }

    /// Initializes as a copy of the other instance. 
    LoggingSettings(
        const LoggingSettings& other)
        : SettingGroup()
        , logger_(other.logger_)
        , debug_(other.debug_)
    {
    }

    /// The Logger instance to be used by the 
    /// Handler while logging various events. 
    /// 
    /// No instance may be returned identifying
    /// no logger is associated and thus nothing
    /// is to be logged by the Handler. 
    Logger* logger() const
    {
        return 
        (
            &LoggingDefaults::
            logger() != logger_
            ? logger_
            : NULL
        );
    }

    /// The Logger instance to be used by the 
    /// Handler while logging various events. 
    /// 
    /// If no instance was assigned by the user,
    /// the default logger is provided. 
    Logger& loggerOrDefault() const
    {
        return *logger_;
    }

    /// Assigns the given logger to the Handler. 
    /// 
    /// Null instance tells the Handler to do not log 
    /// any data and thus reduces general processing time. 
    void
    logger(
        Logger* logger)
    {
        group().
            controlAssignment
            (
                "Logger",
                logger_,
                logger 
                    ? logger 
                    : &LoggingDefaults::logger()
            );
    }

    /// The collection of settings 
    /// affecting debug-level logging. 
    /// 
    /// The Handler may log a lot of data at 
    /// debug level. The given collection allows 
    /// to filter debug information being logged. 
    const 
    DebugLoggingSettings& 
    debug() const
    {
        return debug_;
    }

    /// The collection of settings 
    /// affecting debug-level logging. 
    /// 
    /// The Handler may log a lot of data at 
    /// debug level. The given collection allows 
    /// to filter debug information being logged. 
    DebugLoggingSettings&
    debug()
    {
        return debug_;
    }

    /// Re-initializes the instance 
    /// as a copy of the other one. 
    LoggingSettings&
    operator =(
        const LoggingSettings& other)
    {
        group().
            controlAssignment
            (
                "Logging Settings",
                &LoggingSettings::assignNoControl,
                *this,
                other
            );

        return *this;
    }
};

/// Serializes Handler debug logging settings into a string. 
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&,
    const LoggingSettings&);

/// Serializes Handler debug logging settings into a string. 
inline
std::string
toStr(
    const 
    LoggingSettings& settings)
{
    std::string str;

    toStr(str, settings);

    return str;
}

ONIXS_CONFLATEDUDP_NAMESPACE_END