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/MDH/String.h>
#include <OnixS/CME/MDH/Integral.h>
#include <OnixS/CME/MDH/FileLogger.h>
#include <OnixS/CME/MDH/SettingGroup.h>

ONIXS_CMEMDH_NAMESPACE_BEGIN

/// Defines how SBE messages are traced.
struct ONIXS_CMEMDH_LTWT 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_CMEMDH_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_CMEMDH_EXPORTED
bool fromStr(MessageTracing::Enum&, const Char*, size_t);

/// Parameters affecting what's logged at a debug level.
class ONIXS_CMEMDH_LTWT DebugLoggingSettings
{
public:
    /// Initializes default settings.
    DebugLoggingSettings(const SettingGroup* group = ONIXS_CMEMDH_NULLPTR)
        : 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.
    DebugLoggingSettings& traceFeeds(bool status)
    {
        group_.controlAssignment("Trace Feeds", traceFeeds_, status);

        return *this;
    }

    /// 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.
    DebugLoggingSettings& traceMessages(MessageTracing::Enum tracing)
    {
        group_.controlAssignment("Trace Messages", traceMessages_, tracing);

        return *this;
    }

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

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

        return *this;
    }

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

        return *this;
    }

protected:
    // To let assignment be controlled
    // by the master container.
    friend ONIXS_CMEMDH_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_;
    }

private:
    const SettingGroup& group_;

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

#if !defined(ONIXS_CMEMDH_NO_DEPRECATED)

typedef DebugLoggingSettings HandlerDebugLoggingSettings;

#endif // ONIXS_CMEMDH_NO_DEPRECATED

/// Serializes Handler debug logging settings into a string.
ONIXS_CMEMDH_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.
struct ONIXS_CMEMDH_EXPORTED LoggingDefaults
{
    /// Returns an instance of the default logger.
    static Logger& logger();

    static const char* fileName()
    {
        return "OnixS.CmeMdpPremiumCppHandlers.log";
    }

private:
    static FileLoggerSettings createSettings()
    {
        FileLoggerSettings fileLoggerSettings;
        fileLoggerSettings.filename(fileName());

        return fileLoggerSettings;
    }
};

/// The collection of settings affecting
/// use of logging subsystem by the Handler.
class ONIXS_CMEMDH_LTWT LoggingSettings : public SettingGroup
{
public:
    /// Initializes the instance with the default values.
    LoggingSettings(SettingChangeController* controller = ONIXS_CMEMDH_NULLPTR)
        : 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_ : ONIXS_CMEMDH_NULLPTR);
    }

    /// 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.
    LoggingSettings& logger(Logger* logger)
    {
        group().controlAssignment("Logger", logger_, logger ? logger : &LoggingDefaults::logger());

        return *this;
    }

    /// 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().controlChange("Logging Settings", &LoggingSettings::assignNoControl, *this, other);

        return *this;
    }

private:
    friend ONIXS_CMEMDH_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_);
    }
};

/// Serializes Handler debug logging settings into a string.
ONIXS_CMEMDH_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_CMEMDH_NAMESPACE_END