AdvLogContext.hpp

/* 
 (c) Copyright, Real-Time Innovations, 2017-
 All rights reserved.
 
 No duplications, whole or partial, manual or electronic, may be made
 without express written permission.  Any such copies, or
 revisions thereof, must display this notice unaltered.
 This code contains trade secrets of Real-Time Innovations, Inc.
*/

#ifndef HPP_SERVICE_LOG_ADVLOG_CONTEXT_CONTEXT_HPP_
#define HPP_SERVICE_LOG_ADVLOG_CONTEXT_CONTEXT_HPP_

#include <cstdio>
#include <cstdarg>

#include "advlog/advlog_context.h"
#include "dds_c/dds_c_domain_impl.h"
#include "routingservice/routingservice_log.h"
    
#include <rti/service/log/LogConfig.hpp>

namespace rti { namespace service { namespace log {

class AdvLogContextGuard {

public:
    AdvLogContextGuard(
            const struct ADVLOGContext *context,
            int32_t intParam,
            const void *pointerParam) : 
        context_(context),
        worker_(DDS_DomainParticipantFactory_get_workerI(DDS_TheParticipantFactory))        
    {
        ADVLOGContext_enter(
                worker_,
                context,
                intParam,
                pointerParam);       
    }

    AdvLogContextGuard(
            const struct ADVLOGContext *context,
            const void *pointerParam = NULL) : 
        context_(context),
        worker_(DDS_DomainParticipantFactory_get_workerI(DDS_TheParticipantFactory))
    {
        ADVLOGContext_enter(
                worker_,
                context,
                0,
                pointerParam);
    }   
            
    void leave()
    {
        if (context_ != NULL) {
            ADVLOGContext_leave(worker_, context_);
            context_ = NULL;
        }
    }
    
    
    ~AdvLogContextGuard()
    {       
        leave();
    }
    
private:
    const struct ADVLOGContext *context_;
    struct REDAWorker *worker_;
};

class AdvLogContextStackGuard {
public:    
    
    AdvLogContextStackGuard(
            const struct ADVLOGContext *context,
            const char *string_param) 
        : worker_(DDS_DomainParticipantFactory_get_workerI(DDS_TheParticipantFactory))
    {
        push(context, string_param);
    }
    
    virtual ~AdvLogContextStackGuard()
    {        
        leave();
    }
    
    AdvLogContextStackGuard& push(
            const struct ADVLOGContext *context,
            const char *string_param = NULL) 
    {
        ADVLOGContext_enter(
                    worker_,
                    context,
                    0,
                    string_param);
        context_stack_.push_back(context);
                
        return *this;
    }
    
    AdvLogContextStackGuard& pop()
    {
        if (!context_stack_.empty()) {
            ADVLOGContext_leave(worker_, context_stack_.back());
            context_stack_.pop_back();
        }

        return *this;
    }
    
    void leave()
    {
        std::vector<const ADVLOGContext*>::reverse_iterator it = context_stack_.rbegin();
        for (; it != context_stack_.rend(); ++it) {
            ADVLOGContext_leave(worker_, *it);
        }
    }
    
private:
    std::vector<const ADVLOGContext*> context_stack_;
    struct REDAWorker *worker_;
};

class AdvlogContextStackLeaveGuard
{
public:
    AdvlogContextStackLeaveGuard(const ADVLOGContext *context)
    {
        push(context);
    }
    
    ~AdvlogContextStackLeaveGuard()
    {
        std::vector<const ADVLOGContext*>::iterator it = context_stack_.begin();
        for (; it != context_stack_.end(); ++it) {
            ADVLOGContext_leave(NULL, *it);
        }
    }
    
    void push(const struct ADVLOGContext *context)
    {
        context_stack_.push_back(context);
    }
    
    void leave()
    {
        if (!context_stack_.empty()) {
            ADVLOGContext_leave(NULL, context_stack_.front());
        }
    }
    
private:
    std::vector<const ADVLOGContext*> context_stack_;
};

#define RTI_ACTIVITY_CONTEXT_LEAVE() \
    context_guard.leave() 

#define RTI_ACTIVITY_CONTEXT_ENTER(...) \
    rti::service::log::AdvLogContextStackGuard context_guard(__VA_ARGS__);

#define RTI_LOG_ACTIVITY_CONTEXT_ENTER(...) \
        RTI_ACTIVITY_CONTEXT_ENTER(__VA_ARGS__); \
        SERVICELog_flushActivityContext(RTI_LOG_BIT_LOCAL)

#define RTI_ACTIVITY_CONTEXT_RESOURCE_ENTER(CONTEXT, RESOURCE_ID) \
    rti::service::log::AdvLogContextStackGuard context_guard(\
            (CONTEXT), \
            (RESOURCE_ID))

#define RTI_ACTIVITY_CONTEXT_RESOURCE_METHOD_ENTER(\
        RESOURCE_ID, \
        ...) \
    rti::service::log::AdvLogContextStackGuard context_guard(\
            (&RTI_ADVLOG_CONTEXT_RESOURCE_ID_s), \
            (RESOURCE_ID)); \
    context_guard.push(__VA_ARGS__)


#define RTI_LOG_ACTIVITY_CONTEXT_RESOURCE_METHOD_ENTER(\
        RESOURCE_ID, \
        ...) \
    RTI_ACTIVITY_CONTEXT_RESOURCE_METHOD_ENTER(\
            RESOURCE_ID, \
            __VA_ARGS__);\
    SERVICELog_flushActivityContext(RTI_LOG_BIT_LOCAL)

#define RTI_LOG_ACTIVITY_RESOURCE_SCOPED_LEAVE(CONTEXT) \
    rti::service::log::AdvlogContextStackLeaveGuard leave_guard((CONTEXT)); \
    leave_guard.push((&RTI_ADVLOG_CONTEXT_RESOURCE_ID_s))

} } } // rti::service::log

#endif /* HPP_SERVICE_LOG_ADVLOG_CONTEXT_CONTEXT_HPP_ */