HandlerLogger.h

Go to the documentation of this file.

#pragma once

/*
* 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. 
*/

#include <OnixS/SgxTitan/MarketData/Itch/LogSettings.h>
#include <OnixS/SgxTitan/MarketData/Itch/Defines.h>

#include <OnixS/HandlerCore/HandlerLogger.h>

#include <logging/FileOutput.h>

#include "NamespaceHelper.h"

//////////////////////////////////////////////////////////////////////////
// Source info defines

#ifdef _MSC_VER
#define FUNCTION_NAME __FUNCTION__
#else
#define FUNCTION_NAME __PRETTY_FUNCTION__
#endif

#define DIRECTEDGE_SOURCE_INFO ::OnixS::Logging::SourceInfo(__FILE__, __LINE__, FUNCTION_NAME)
#define DIRECTEDGE_SOURCE_FUNC ::OnixS::Logging::SourceInfo(nullptr, 0, FUNCTION_NAME)
#define DIRECTEDGE_SOURCE_LINE ::OnixS::Logging::SourceInfo(__FILE__, __LINE__, nullptr)


#ifdef _DEBUG
#define EXCEPTION_SOURCE_INFO DIRECTEDGE_SOURCE_INFO
#define LOG_SOURCE_INFO DIRECTEDGE_SOURCE_INFO
#else
#ifdef _TRACE
#define EXCEPTION_SOURCE_INFO DIRECTEDGE_SOURCE_FUNC
#define LOG_SOURCE_INFO DIRECTEDGE_SOURCE_FUNC
#else
#define EXCEPTION_SOURCE_INFO DIRECTEDGE_SOURCE_FUNC
#define LOG_SOURCE_INFO OnixS::Logging::SourceInfo()
#endif
#endif

//////////////////////////////////////////////////////////////////////////
// format macros

// declaration of formatting signature for types by const ref
#define DECL_FORMAT(ftype) \
TextBuilder & operator<<(TextBuilder & o, const ftype & obj)

// declaration of formatting signature for types by value
#define DECL_FORMAT_BYVAL(ftype) \
TextBuilder & operator<<(TextBuilder & o, ftype obj)

// definition of formatting for types by const ref
#define STRUCT_FORMAT(ftype, fformat)\
TextBuilder & operator<<(TextBuilder & o, const ftype & obj) {\
return o << Util::indent(4) fformat << Util::indent(-4);\
}

#define STRUCT_FORMAT_T(ftype, fformat)\
TextBuilder & operator<<(TextBuilder & o, const ftype & obj) {\
return o << '[' << #ftype << "]\n" << indent(4) fformat << indent(-4);\
}

// definition of formatting for enums
#define ENUM_FORMAT(fenumbox, fformat)\
TextBuilder & operator<<(TextBuilder & o, fenumbox::Enum obj) {\
typedef fenumbox __FENUM_BOX__;\
switch(obj) { fformat default: if(obj ) o << int(obj) << " (?)";\
                else format_null_value(o); } return o; }
// single enum value formatting
#define FENUM(fenum) case __FENUM_BOX__::fenum: o << int(__FENUM_BOX__::fenum) << " ("#fenum")"; break;

// definition of API formatting for enums
#define API_ENUM_FORMAT(fenumbox, fformat)\
const char ONIXS_API * enumToString(fenumbox::Enum value) {\
typedef fenumbox __FENUM_BOX__;\
switch(value) { fformat default: return "#Invalid enumeration value"; } }

// single API enum value formatting
#define ENUM_STR(fenum) case __FENUM_BOX__::fenum: return #fenum; 

#define VAR(var) create_var_format(", "#var, var)
#define VARLN(var) '\n' << create_var_format(#var, var)
#define COMPLEX_FIELD(s) '\n' << indent(4) << create_var_format(#s, obj.s) << indent(-4)
#define FIELD(var) '\n' << create_var_format(#var, obj.var)
#define FIELD_AS(var, ftype) '\n' << create_var_format(#var, ftype(obj.var))
#define DATE_FIELD(var) FIELD_AS(var, SDateWrapper)
#define TIME_FIELD(var) FIELD_AS(var, STimeWrapper)
#define BOOL_FIELD(var) FIELD_AS(var, OMexBool::Enum)

ONIXS_HANDLER_NAMESPACE_BEGIN

#define ASSERT_ARG(arg, cond) if(arg cond) {} else \
throw ArgumentExceptionImpl("Argument value does not meet condition: "#arg" "#cond, #arg, EXCEPTION_SOURCE_INFO)

#ifdef _DEBUG
#define DEBUG_ASSERT_ARG(arg, cond) ASSERT_ARG(arg, cond)
#else
#define DEBUG_ASSERT_ARG(arg, cond) ((void)0)
#endif

#define ASSERT_COND(cond) if(cond) {} else \
throw OperationExceptionImpl("Object state does not meet condition: "#cond, EXCEPTION_SOURCE_INFO)

#ifdef _DEBUG
#define DEBUG_ASSERT_COND(cond) ASSERT_COND(cond)
#else
#define DEBUG_ASSERT_COND(cond) ((void)0)
#endif

#if (defined(_TRACE) || defined(_DEBUG))
#ifdef _DEBUG
#define DEFAULT_LOG_LEVEL Logging::LOG_LEVEL_DEBUG
#else
#define DEFAULT_LOG_LEVEL Logging::LOG_LEVEL_TRACE
#endif
#else
#define DEFAULT_LOG_LEVEL Logging::LOG_LEVEL_INFO
#endif


#ifdef _TRACE
/// Use this macro as first line of traced function
#define TRACE_STATE(state, logger) if(state.changed()) logger.log(ONIXS_LOG_TRACE << "|===> " __FUNCTION__)
#else
#define TRACE_STATE(state, logger) do {} while(false)
#endif


#ifdef _TRACE
/// Use this macro as first line of traced function
#define TRACE_FUNC_MINI(logger) logger.log(ONIXS_LOG_TRACE << ">>> " __FUNCTION__ " >>>")
#else
#define TRACE_FUNC_MINI(logger) do {} while(false)
#endif

typedef boost::scoped_ptr<HandlerCore::Common::HandlerLogger> LoggerPtr;

using namespace Util;

template<typename T>
struct VarFormatHelper 
{
    const Util::ValuePtr name;
    const T value;

    // construct from literal
    template<size_t NLen>
    VarFormatHelper(const char( & name_)[NLen], const T & value_)
        : name(name_, NLen - 1 /* !!! do not include terminator */), value(value_) {}

    VarFormatHelper(const VarFormatHelper& other) :
        name(other.name.duplicate()), 
        value(other.value)
    {}

private:
    VarFormatHelper& operator=(const VarFormatHelper&);
};

// helper function-dispatcher
template<size_t NLen, typename T>
VarFormatHelper<T> create_var_format(const char( & name)[NLen], const T & value)
{
    return VarFormatHelper<T>(name, value);
};

// dispatch unsigned char as unsigned int
template<size_t NLen>
VarFormatHelper<unsigned> create_var_format(const char( & name)[NLen], unsigned char value)
{
    return VarFormatHelper<unsigned>(name, value);
};

// to do not inference with unsigned char explicit declaration
template<size_t NLen>
VarFormatHelper<char> create_var_format(const char( & name)[NLen], char value)
{
    return VarFormatHelper<char>(name, value);
};

// dispatch char[NVal] field value as literal without zero terminator
// trims spaces at the end
template<size_t NLen, size_t NVal>
VarFormatHelper<ValuePtr> create_var_format(const char( & name)[NLen], const char( & value)[NVal])
{
    // do trim
    int last = -1;
    const char * src = value;
    char c;

    for (int i = 0; (i < NVal) && (c = *src++); i++)
        if (c != ' ')
            last = i;

    return VarFormatHelper<OnixS::Util::ValuePtr>(name, OnixS::Util::ValuePtr(value, last+1));
};

TextBuilder & format_var_name(TextBuilder & o, ValuePtr name);
TextBuilder & format_null_value(TextBuilder & o);

template<typename T>
inline TextBuilder & operator<<(TextBuilder & o, const VarFormatHelper<T> & var)
{
    return format_var_name(o, var.name) << var.value;
}

//DECL_FORMAT(SDateWrapper);
//DECL_FORMAT(STimeWrapper);
DECL_FORMAT(VarFormatHelper<ValuePtr>);
DECL_FORMAT(VarFormatHelper<char>);

void userExceptionHandler(
    HandlerCore::Common::HandlerLogger*, OnixS::Logging::LogFacility *, const char *contextName) ONIXS_NOEXCEPT;


#define ONIXS_EXCEPTION_TRACED_CALLBACK_EX(callback, logger, logFacility, contextName) \
try { callback;\
logger->log( ONIXS_LOG_DEBUG[logFacility] << "Callback " << contextName << " called successfully");\
} catch(...) { HANDLER_NAMESPACE::userExceptionHandler(logger, logFacility, contextName); } \

#define ONIXS_EXCEPTION_TRACED_CALLBACK(callback, contextName) ONIXS_EXCEPTION_TRACED_CALLBACK_EX(callback, logger_, this, contextName)

Logging::FileOutput::PermissionOption getOutputPermission(LogFilePermission::Enum value);

ONIXS_HANDLER_NAMESPACE_END