vcl::LoggerConcept Concept Reference

The LoggerConcept is satisfied if the type T is a valid Logger type. More...

#include <vclib/concepts/logger.h>

Concept definition

template<typename T>
concept vcl::LoggerConcept =  requires (
    T&&                             obj,
    std::string                     str,
    uint                            n,
    typename RemoveRef<T>::LogLevel lvl) {
    
    typename RemoveRef<T>::LogLevel;
 
    { obj.time() } -> std::same_as<double>;
    { obj.percentage() } -> std::same_as<double>;
 
    { obj.log(str) } -> std::same_as<void>;
    { obj.log(str, lvl) } -> std::same_as<void>;
 
    
    requires IsConst<T> || requires {
        { obj.enableIndentation() } -> std::same_as<void>;
        { obj.disableIndentation() } -> std::same_as<void>;
        { obj.enablePrintPercentage() } -> std::same_as<void>;
        { obj.disablePrintPercentage() } -> std::same_as<void>;
        { obj.setPrintLevel(lvl) } -> std::same_as<void>;
        { obj.enablePrintMessageDuringProgress() } -> std::same_as<void>;
        { obj.disablePrintMessageDuringProgress() } -> std::same_as<void>;
        { obj.enablePrintTimer() } -> std::same_as<void>;
        { obj.disablePrintTimer() } -> std::same_as<void>;
 
        { obj.reset() } -> std::same_as<void>;
 
        { obj.setMaxLineWidth(n) } -> std::same_as<void>;
        { obj.startTimer() } -> std::same_as<void>;
        { obj.stopTimer() } -> std::same_as<void>;
 
        { obj.startNewTask(double(), double(), str) } -> std::same_as<void>;
        { obj.endTask(str) } -> std::same_as<void>;
 
        { obj.setPercentage(n) } -> std::same_as<void>;
 
        { obj.log(n, str) } -> std::same_as<void>;
        { obj.log(n, str, lvl) } -> std::same_as<void>;
 
        { obj.startProgress(str, n) } -> std::same_as<void>;
        { obj.startProgress(str, n, n) } -> std::same_as<void>;
        { obj.startProgress(str, n, n, n) } -> std::same_as<void>;
        { obj.startProgress(str, n, n, n, n) } -> std::same_as<void>;
        { obj.endProgress() } -> std::same_as<void>;
        { obj.progress(n) } -> std::same_as<void>;
    };
}

Detailed Description

The LoggerConcept is satisfied if the type T is a valid Logger type.

A valid Logger type must provide a set of member functions to control the logging behavior, that are checked by this concept.

Note

The NullLogger class does satisfy this concept, by providing all the required member functions as no-op.