TLoggerCompWrap.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// ACF includes
#include <icomp/CComponentBase.h>
#include <ilog/CLoggerBase.h>
#include <ilog/ITracingConfiguration.h>
 
 
namespace ilog
{
 
 
template <class Base>
class TLoggerCompWrap:
                     public Base,
                     virtual public ilog::CLoggerBase
{
public:
       typedef Base BaseClass;
       
       typedef ilog::CLoggerBase BaseClass2;
 
       I_BEGIN_BASE_COMPONENT(TLoggerCompWrap);
              I_ASSIGN(m_logCompPtr, "Log", "Consumer log messages", false, "Log");
              I_ASSIGN(m_verboseEnabledAttrPtr, "EnableVerbose", "If enabled, verbose messages can be produced", true, false);
              I_ASSIGN(m_tracingConfigurationCompPtr, "TracingConfiguration", "If enabled, verbose messages can be produced with tracing level", false, "TracingConfiguration");
              I_ASSIGN(m_showComponentIdAttrPtr, "ShowComponentId", "If enabled the component ID will be shown as a part of the message source", true, true);
       I_END_COMPONENT;
 
protected:
       bool IsVerboseEnabled(int tracingLevel = 0) const;
 
       void SendVerboseMessage(const QString& message, const QString& messageSource = QString(), int tracingLevel = 0) const;
 
       // reimplemented (istd::ILogger)
       
       virtual void DecorateMessage(
                            istd::IInformationProvider::InformationCategory category,
                            int id,
                            int flags,
                            QString& message,
                            QString& messageSource) const override;
 
       // reimplemented (icomp::CComponentBase)
       
       virtual void OnComponentCreated() override;
       
       virtual void OnComponentDestroyed() override;
 
private:
       I_REF(ilog::IMessageConsumer, m_logCompPtr);
       I_ATTR(bool, m_verboseEnabledAttrPtr);
       I_REF(ilog::ITracingConfiguration, m_tracingConfigurationCompPtr);
       I_ATTR(bool, m_showComponentIdAttrPtr);
};
 
 
// protected methods
       
template <class Base>
bool TLoggerCompWrap<Base>::IsVerboseEnabled(int tracingLevel) const
{
       static const istd::IInformationProvider::InformationCategory categoryNone = istd::IInformationProvider::IC_NONE;
 
       bool retVal = *m_verboseEnabledAttrPtr;;
 
       if (m_tracingConfigurationCompPtr.IsValid()){
              retVal = m_tracingConfigurationCompPtr->GetTracingLevel() >= tracingLevel;
       }
 
       retVal = retVal && BaseClass2::IsLogConsumed(&categoryNone);
 
       return retVal;
}
 
 
template <class Base>
void TLoggerCompWrap<Base>::SendVerboseMessage(const QString& message, const QString& messageSource, int tracingLevel) const
{
       if (IsVerboseEnabled(tracingLevel)){
              BaseClass2::SendLogMessage(istd::IInformationProvider::IC_NONE, 0, message, messageSource);
       }
}
 
 
// reimplemented (istd::ILogger)
 
template <class Base>
void TLoggerCompWrap<Base>::DecorateMessage(
                     istd::IInformationProvider::InformationCategory category,
                     int id,
                     int flags,
                     QString& message,
                     QString& messageSource) const
{
       BaseClass2::DecorateMessage(category, id, flags, message, messageSource);
 
       if (*m_showComponentIdAttrPtr){
              const icomp::IComponentContext* contextPtr = BaseClass::GetComponentContext().get();
              if (contextPtr != NULL){
                     if (messageSource.isEmpty()){
                            messageSource = contextPtr->GetContextId();
                     }
                     else{
                            messageSource = QString(contextPtr->GetContextId()) + " (" + messageSource + ")";
                     }
              }
       }
}
 
 
// reimplemented (icomp::CComponentBase)
 
template <class Base>
void TLoggerCompWrap<Base>::OnComponentCreated()
{
       if (m_logCompPtr.IsValid()){
              this->SetLogPtr(m_logCompPtr.GetPtr());
       }
 
       BaseClass::OnComponentCreated();
}
 
 
template <class Base>
void TLoggerCompWrap<Base>::OnComponentDestroyed()
{
       this->SetLogPtr(NULL);
 
       BaseClass::OnComponentDestroyed();
}
 
 
typedef TLoggerCompWrap<icomp::CComponentBase> CLoggerComponentBase;
 
 
} // namespace ilog