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

ONIXS_CONFLATEDUDP_LTWT_STRUCT MessageTracing
{
    typedef UInt32 Base;

    enum Enum
    {
        Disabled,

        SbeFormat,

        FixFormat
    };
};

ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&,
    MessageTracing::Enum);

inline
std::string
toStr(
    MessageTracing::Enum tracing)
{
    std::string str;
 
    toStr(str, tracing);
 
    return str;
}

ONIXS_CONFLATEDUDP_EXPORTED
bool
fromStr(
    MessageTracing::Enum&,
    const Char*,
    size_t);

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:
    DebugLoggingSettings(
        const SettingGroup* group = NULL)
        : group_(
            group 
                ? *group 
                : SettingGroup::null())
        , traceFeeds_(false)
        , traceMessages_(
            MessageTracing::Disabled)
        , traceBooks_(false)
    {
    }

    DebugLoggingSettings(
        const DebugLoggingSettings& other)
        : group_(
            SettingGroup::null())
        , traceFeeds_(
            other.traceFeeds_)
        , traceMessages_(
            other.traceMessages_)
        , traceBooks_(
            other.traceBooks_)
    {
    }

    ~DebugLoggingSettings()
    {
    }

    bool 
    traceFeeds() const
    {
        return traceFeeds_;
    }

    void 
    traceFeeds(
        bool status)
    {
        group_.
            controlAssignment
            (
                "Trace Feeds", 
                traceFeeds_,
                status
            );
    }

    MessageTracing::
    Enum 
    traceMessages() const
    {
        return traceMessages_;
    }

    void
    traceMessages(
        MessageTracing::Enum tracing)
    {
        group_.
            controlAssignment
            (
                "Trace Messages", 
                traceMessages_,
                tracing
            );
    }

    bool 
    traceBooks() const
    {
        return traceBooks_;
    }

    void
    traceBooks(
        bool status)
    {
        group_.
            controlAssignment
            (
                "TraceBooks", 
                traceBooks_,
                status
            );
    }

    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

ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&,
    const DebugLoggingSettings&);

inline
std::string
toStr(
    const 
    DebugLoggingSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT LoggingDefaults
{
    static Logger& logger()
    {
        static NullLogger nullLogger;
 
        return nullLogger;
    }
};

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:
    LoggingSettings(
        SettingAssignController* 
        controller = NULL)
        : SettingGroup(controller)
        , logger_(&LoggingDefaults::logger())
        , debug_(&group())
    {
    }

    LoggingSettings(
        const LoggingSettings& other)
        : SettingGroup()
        , logger_(other.logger_)
        , debug_(other.debug_)
    {
    }

    Logger* logger() const
    {
        return 
        (
            &LoggingDefaults::
            logger() != logger_
            ? logger_
            : NULL
        );
    }

    Logger& loggerOrDefault() const
    {
        return *logger_;
    }

    void
    logger(
        Logger* logger)
    {
        group().
            controlAssignment
            (
                "Logger",
                logger_,
                logger 
                    ? logger 
                    : &LoggingDefaults::logger()
            );
    }

    const 
    DebugLoggingSettings& 
    debug() const
    {
        return debug_;
    }

    DebugLoggingSettings&
    debug()
    {
        return debug_;
    }

    LoggingSettings&
    operator =(
        const LoggingSettings& other)
    {
        group().
            controlAssignment
            (
                "Logging Settings",
                &LoggingSettings::assignNoControl,
                *this,
                other
            );
 
        return *this;
    }
};

ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&,
    const LoggingSettings&);

inline
std::string
toStr(
    const 
    LoggingSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}
 
ONIXS_CONFLATEDUDP_NAMESPACE_END