CAmDltWrapper.h

Go to the documentation of this file.

#ifndef DLTWRAPPER_H_
#define DLTWRAPPER_H_

#include <string>
#include <pthread.h>
#include <sstream>
#include <iostream>
#include <fstream>
#include <map>
#include <vector>
#include <audiomanagerconfig.h>
#include "audiomanagertypes.h"

#ifdef WITH_DLT
    #include <dlt.h>
#else
    #include <stdint.h>
    #include <sstream>

    #define DLT_USER_BUF_MAX_SIZE 2048

    typedef struct
    {
        char contextID[4]; 
        int32_t log_level_pos; 
        int32_t log_level_user; 
    } DltContext;

    typedef enum
    {
        DLT_TRACE_STATUS_DEFAULT =   -1,    
        DLT_TRACE_STATUS_OFF     = 0x00,    
        DLT_TRACE_STATUS_ON      = 0x01     
    } DltTraceStatusType;

    typedef struct
    {
        DltContext *handle; 
        std::stringstream buffer; 
        int32_t log_level; 
        int32_t trace_status; 
        int32_t args_num; 
        uint8_t mcnt; 
        char* context_description; 
    } DltContextData;

    typedef enum
    {
        DLT_LOG_DEFAULT = -1, 
        DLT_LOG_OFF = 0x00, 
        DLT_LOG_FATAL = 0x01, 
        DLT_LOG_ERROR = 0x02, 
        DLT_LOG_WARN = 0x03, 
        DLT_LOG_INFO = 0x04, 
        DLT_LOG_DEBUG = 0x05, 
        DLT_LOG_VERBOSE = 0x06 
    } DltLogLevelType;

    #define DLT_DEFAULT_LOG_LEVEL DLT_LOG_INFO
    #define DLT_DECLARE_CONTEXT(CONTEXT)                               \
    DltContext CONTEXT;

    #define DLT_IMPORT_CONTEXT(CONTEXT)                                \
    extern DltContext CONTEXT;

#endif // WITH_DLT

namespace am
{

class CAmDltWrapper
{
public:

    typedef struct
    {
        DltContext *handle; 
        std::stringstream buffer; 
        int32_t log_level; 
        int32_t trace_status; 
        int32_t args_num; 
        uint8_t mcnt; 
        char* context_description; 
    } NoDltContextData;

    /*
     * The eunum gives the logtype
     */
    enum logDestination
    {
        DAEMON=0, 
        COMMAND_LINE=1, 
        FILE_OUT =2 
    };

    static CAmDltWrapper* instanctiateOnce(const char *appid, const char * description, const bool debugEnabled = true, const logDestination logDest = logDestination::DAEMON, const std::string Filename="",bool onlyError=false);
    
    static CAmDltWrapper* instance();

    void registerContext(DltContext& handle, const char *contextid, const char * description);
    void registerContext(DltContext& handle, const char *contextid, const char * description, const DltLogLevelType level, const DltTraceStatusType status);
    void unregisterContext(DltContext& handle);
    bool getEnabled();
    ~CAmDltWrapper();

    bool init(DltLogLevelType loglevel, DltContext* context = NULL);
    bool checkLogLevel(DltLogLevelType logLevel)
    {
#ifdef WITH_DLT
    #ifdef DLT_IS_LOG_LEVEL_ENABLED
        if (mlogDestination == logDestination::DAEMON)
        {
            return (dlt_user_is_logLevel_enabled(&mDltContext, logLevel) == DLT_RETURN_TRUE);
        }
    #else
        (void)logLevel;
    #endif
        return true;
#else
        return (logLevel <= mDltContext.log_level_user);
#endif
    }
    void deinit();
    void send();
    void append(const int8_t value);
    void append(const uint8_t value);
    void append(const int16_t value);
    void append(const uint16_t value);
    void append(const int32_t value);
    void append(const uint32_t value);
    void append(const uint64_t value);
    void append(const int64_t value);
    void append(const std::string& value);
    void append(const bool value);
    void append(const std::vector<uint8_t> & data);
        
    template<class T> void appendNoDLT(T value)
    {
        mNoDltContextData.buffer << value <<" ";
    }

    // specialization for const char*
    template<typename T = const char*> void append(const char* value)
    {
        #ifdef WITH_DLT
            if (mlogDestination == logDestination::DAEMON)
            {
                dlt_user_log_write_string(&mDltContextData, value);
            }
            else
            {
                mNoDltContextData.buffer << std::string(value);
            }
        #else
            mNoDltContextData.buffer << std::string(value);
        #endif //WITH_DLT

    }

private:
    static const std::vector<const char*> mStr_error;
    static const std::vector<const char*> mStr_sourceState;
    static const std::vector<const char*> mStr_MuteState;
    static const std::vector<const char*> mStr_DomainState;
    static const std::vector<const char*> mStr_ConnectionState;
    static const std::vector<const char*> mStr_Availability;
    static const std::vector<const char*> mStr_Interrupt;
    static const std::vector<const char*> mStr_Handle;
    static const std::vector<const char*> mStr_NotificationStatus;

public:

    // specialization for const am_Error_e
    template<typename T = const am_Error_e> void append(const am_Error_e value)
    {
        if (static_cast<std::size_t>(value) >= mStr_error.size())
        {
            append("value for am_Error_e out of bounds!");
            append(static_cast<uint16_t>(value));
            return;
        }
        append(mStr_error[value]);
    }

    // specialization for const am_Error_e
    template<typename T = const am_SourceState_e> void append(const am_SourceState_e value)
    {
        if (static_cast<std::size_t>(value) >= mStr_sourceState.size())
        {
            append("value for am_SourceState_e out of bounds!");
            append(static_cast<uint16_t>(value));
            return;
        }
        append(mStr_sourceState[value]);
    }


    template<typename T = const am_MuteState_e> void append(const am_MuteState_e value)
    {
        if (static_cast<std::size_t>(value) >= mStr_MuteState.size())
        {
            append("value for am_MuteState_e out of bounds!");
            append(static_cast<uint16_t>(value));
            return;
        }
        append(mStr_MuteState[value]);
    }

    template<typename T = const am_DomainState_e> void append(const am_DomainState_e value)
    {
        if (static_cast<std::size_t>(value) >= mStr_DomainState.size())
        {
            append("value for am_DomainState_e out of bounds!");
            append(static_cast<uint16_t>(value));
            return;
        }
        append(mStr_DomainState[value]);
    }

    template<typename T = const am_ConnectionState_e> void append(const am_ConnectionState_e value)
    {
        if (static_cast<std::size_t>(value) >= mStr_ConnectionState.size())
        {
            append("value for am_ConnectionState_e out of bounds!");
            append(static_cast<uint16_t>(value));
            return;
        }
        append(mStr_ConnectionState[value]);
    }

    template<typename T = const am_Availability_e> void append(const am_Availability_e value)
    {
        if (static_cast<std::size_t>(value) >= mStr_Availability.size())
        {
            append("value for am_Availability_e out of bounds!");
            append(static_cast<uint16_t>(value));
            return;
        }
        append(mStr_Availability[value]);
    }

    template<typename T = const am_InterruptState_e> void append(const am_InterruptState_e value)
    {
        if (static_cast<std::size_t>(value) >= mStr_Interrupt.size())
        {
            append("value for am_InterruptState_e out of bounds!");
            append(static_cast<uint16_t>(value));
            return;
        }
        append(mStr_Interrupt[value]);
    }

    template<typename T = const am_Handle_e> void append(const am_Handle_e value)
    {
        if (static_cast<std::size_t>(value) >= mStr_Handle.size())
        {
            append("value for am_Handle_e out of bounds!");
            append(static_cast<uint16_t>(value));
            return;
        }
        append(mStr_Handle[value]);
    }
    
    template<typename T = const am_Handle_s> void append(const am_Handle_s value)
    {
        append (value.handleType);
        append (value.handle);
    }

    template<typename T = const am_NotificationStatus_e> void append(const am_NotificationStatus_e value)
    {
        if (static_cast<std::size_t>(value) >= mStr_NotificationStatus.size())
        {
            append("value for am_NotificationStatus_e out of bounds!");
            append(static_cast<uint16_t>(value));
            return;
        }
        append(mStr_NotificationStatus[value]);
    }

    // Template to print unknown pointer types with their address
    template<typename T> void append(T* value)
    {
        std::ostringstream ss;
        ss << "0x" << std::hex << (uint64_t)value;
        append(ss.str().c_str());
    }

    // Template to print unknown types
    template<typename T> void append(T value)
    {
        std::ostringstream ss;
        ss << std::dec << value;
        append(ss.str().c_str());
    }

    // Template parameter pack to generate recursive code
    void append(void) {}
    template<typename T, typename... TArgs> void append(T value, TArgs... args)
    {
        this->append(value);
        this->append(args...);
    }

private:
    CAmDltWrapper(const char *appid, const char * description, const bool debugEnabled = true, const logDestination logDest = logDestination::DAEMON, const std::string Filename="",bool onlyError=false); //is private because of singleton pattern
    bool initNoDlt(DltLogLevelType loglevel, DltContext* context);
    std::string now();
    DltContext mDltContext; 
    DltContextData mDltContextData; 
    NoDltContextData mNoDltContextData; 
    std::map<DltContext*,std::string> mMapContext; 
    bool mDebugEnabled;    
    logDestination mlogDestination; 
    std::ofstream mFilename; 
    bool mOnlyError; 
    bool mLogOn; 
    static CAmDltWrapper* mpDLTWrapper; 
    static pthread_mutex_t mMutex;

};

template<typename T, typename... TArgs>
void log(DltContext* const context, DltLogLevelType loglevel, T value, TArgs... args)
{
    CAmDltWrapper* inst(CAmDltWrapper::instance());
    if (!inst->getEnabled())
    {
        return;
    }
    if (!inst->init(loglevel, context))
    {
        return;
    }
    inst->append(value);
    inst->append(args...);
    inst->send();
}

template<typename T, typename... TArgs>
void logDebug(T value, TArgs... args)
{
    log(NULL, DLT_LOG_DEBUG, value, args...);
}

template<typename T, typename... TArgs>
void logInfo(T value, TArgs... args)
{
    log(NULL, DLT_LOG_INFO, value, args...);
}

template<typename T, typename... TArgs>
void logError(T value, TArgs... args)
{
    log(NULL, DLT_LOG_ERROR,value,args...);
}

template<typename T, typename... TArgs>
void logWarning(T value, TArgs... args)
{
    log(NULL, DLT_LOG_WARN,value,args...);
}

template<typename T, typename... TArgs>
void logVerbose(T value, TArgs... args)
{
    log(NULL, DLT_LOG_VERBOSE,value,args...);
}

}

#endif /* DLTWRAPPER_H_ */