FormattingLogger.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Image/Image.h"
#include "enrollment/Logger/Logger.h"
#include "enrollment/Serialization/Writer.h"
#include <array>
#include <charconv>
#include <cstring>
#include <functional>
#include <string>
#include <type_traits>
#include <utility>
 
namespace inno
{
     */
    class FormattingComposer : public LogMessage
    {
    public:
        template<typename... Args>
        // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward) - false positive
        explicit FormattingComposer(const char* format, Args&&... arguments)
          : compose(
              [this, format, capturedArgs = std::forward_as_tuple(arguments...)]() -> const char*
              {
                  message.clear();
                  try
                  {
                      std::apply(
                        [this, format](auto&&... args)
                        {
                            LogWriter writer(message);
                            Printf(message, writer, 0, format, std::forward<Args>(args)...);
                        },
                        std::move(capturedArgs));
                  }
                  catch (const std::exception& e)
                  {
                      message += "<exception during logging: ";
                      message += e.what();
                      message += ">";
                  }
                  return message.c_str();
              })
        {
        }

         */
        const char* Compose() final
        {
            return compose();
        }
 
        FormattingComposer() = delete;
        FormattingComposer(const FormattingComposer&) = delete;
        FormattingComposer(FormattingComposer&&) = delete;
        FormattingComposer& operator=(const FormattingComposer&) = delete;
        FormattingComposer& operator=(FormattingComposer&&) = delete;
        ~FormattingComposer() = default;
 
    private:
        std::string message;
        std::function<const char*()> compose;
 
        class LogWriter : public Writer
        {
        public:
            void Write(const char* n, const Serializable& s) final
            {
                if (arrayIndex > 0 && objectIndex == 0)
                {
                    arraySize[arrayIndex - 1]++;
 
                    if (arraySize[arrayIndex - 1] > actualMaxArraySize)
                    {
                        return;
                    }
 
                    isValueInObject[arrayIndex - 1] = true;
                }
                objectIndex++;
                auto name = std::string_view(n);
                text += name;
                if (!name.empty())
                {
                    text += ":";
                }
                text += "{";
                s.WriteTo(*this);
                objectIndex--;
                // remove last object member delimiter
                text.erase(text.end() - 1, text.end());
                text += "}";
                if (objectIndex > 0)
                {
                    text += ObjectValueDelimiter;
                }
                if (arrayIndex > 0 && objectIndex == 0)
                {
                    isValueInObject[arrayIndex - 1] = false;
                    text += ArrayValueDelimiter;
                }
            }
            void WriteRoot(Serializable& /*s*/) final
            {
                // not used
            }
            void Write(const char* name, const char* value) final
            {
                // if we are in array (or in array of array ...) then
                //  append ArrayDelimiter after each element
                //  reduce array size to actualMaxArraySize
                if (arrayIndex > 0)
                {
                    // Treat first object in array as one element, regardless how many other object it contains
                    // Treat value outside of object as one element
                    if (!isValueInObject[arrayIndex - 1])
                    {
                        arraySize[arrayIndex - 1]++;
                    }
                    // Do not write more than actualMaxArraySize elements
                    if (arraySize[arrayIndex - 1] <= actualMaxArraySize)
                    {
                        WriteString(name, value);
                        text += ArrayValueDelimiter;
                    }
                }
                else
                {
                    // Value is not array element
                    WriteString(name, value);
                    // if value is part of object, then append ObjectValueDelimiter
                    if (objectIndex > 0)
                    {
                        // add object member delimiter
                        text += ObjectValueDelimiter;
                    }
                }
            }
            void WriteNull(const char* name) final
            {
                Write(name, "null");
            }
            void Write(const char* name, int value) final
            {
                Write(name, std::to_string(value).c_str());
            }
            void Write(const char* name, unsigned int value) final
            {
                Write(name, std::to_string(value).c_str());
            }
            void Write(const char* name, double value) final
            {
                Write(name, std::to_string(value).c_str());
            }
            void Write(const char* name, int64_t value) final
            {
                Write(name, std::to_string(value).c_str());
            }
            void Write(const char* name, uint64_t value) final
            {
                Write(name, std::to_string(value).c_str());
            }
            void Write(const char* name, const std::shared_ptr<Image>& value) final
            {
                if (value != nullptr)
                {
                    const std::string imageDescription =
                      "[w:" + std::to_string(value->Width()) + " h:" + std::to_string(value->Height()) +
                      " d:" + std::to_string(static_cast<unsigned int>(value->Dpi())) + "]";
                    Write(name, imageDescription.c_str());
                }
                else
                {
                    WriteNull(name);
                }
            }
 
            LogWriter(const LogWriter&) = delete;
            LogWriter(LogWriter&&) = delete;
            LogWriter& operator=(const LogWriter&) = delete;
            LogWriter& operator=(LogWriter&&) = delete;
            LogWriter() = delete;
            explicit LogWriter(std::string& t)
              : actualMaxArraySize(MaxArraySize)
              , text(t)
              , arrayIndex(0)
              , objectIndex(0)
            {
            }
            virtual ~LogWriter() = default;
 
            static const unsigned int MaxArraySize = 10;
            // The LogWriter is private, helper class for FormattingComposer. The FormattingComposer is responsible to
            // write to this variable.
            // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes)
            unsigned int actualMaxArraySize;
 
        private:
            // The LogWriter is private, helper class for FormattingComposer. The FormattingComposer is responsible to
            // keep text reference valid for whole lifetime of LogWriter
            // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
            std::string& text;
            unsigned int arrayIndex;
            std::vector<unsigned int> arraySize;
            std::vector<bool> isValueInObject;
            unsigned int objectIndex;
            static const char ObjectValueDelimiter = ' ';
            static const char ArrayValueDelimiter = ',';
 
            void StartArray(const char* n) final
            {
                auto name = std::string_view(n);
 
                if (not name.empty())
                {
                    text += name;
                    text += ":";
                }
 
                arraySize.insert(arraySize.begin() + arrayIndex, 0);
                isValueInObject.insert(isValueInObject.begin() + arrayIndex, false);
                text += "[";
                arrayIndex++;
            }
            void EndArray() final
            {
                // remove last ArrayValueDelimiter if any
                if (text[text.length() - 1] == ',')
                {
                    text.erase(text.end() - 1, text.end());
                }
                arrayIndex--;
                // if arrays is not fully written, then write also array size
                if (arraySize[arrayIndex] > actualMaxArraySize)
                {
                    text += ArrayValueDelimiter;
                    text += "...(" + std::to_string(arraySize[arrayIndex]) + ")";
                }
                arraySize[arrayIndex] = 0;
                // close array
                text += "]";
                // if we are still in array (in case of array of array) then array element must be delimited
                if (arrayIndex > 0)
                {
                    text += ArrayValueDelimiter;
                }
                else
                {
                    if (objectIndex > 0)
                    {
                        // add object member delimiter
                        text += ObjectValueDelimiter;
                    }
                }
            }
 
            void WriteString(const char* n, const char* v)
            {
                auto name = std::string_view(n);
                auto value = std::string_view(v);
 
                if (not name.empty())
                {
                    text += name;
                    text += ":";
                }
                text += value;
            }
        };
 
        template<typename T>
            requires IsIterable<T>
        void WriteInWriter(Writer& writer, T& value) const
        {
            writer.WriteArray("", value);
        }
        template<typename T>
            requires(IsNotIterable<T> && !std::is_scalar_v<T>)
        void WriteInWriter(Writer& writer, T& value) const
        {
            writer.Write(static_cast<const char*>(""), value);
        }
 
        // Allow  call to writer for exact type that writer supports. To use various type in Formatting logger that can
        // produce Ambiguous function call, compiler error.
        template<typename T>
            requires(std::is_scalar_v<T> &&
                     (std::is_same_v<T, const char*> || std::is_same_v<T, int> || std::is_same_v<T, unsigned int> ||
                      std::is_same_v<T, double> || std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t>))
        void WriteInWriter(Writer& writer, T& value) const
        {
            writer.Write("", value);
        }
 
        // Ignore call to writer for not exact type to use various type in Formatting logger that can produce Ambiguous
        // function call, compiler error.
        template<typename T>
            requires(std::is_scalar_v<T> &&
                     !(std::is_same_v<T, const char*> || std::is_same_v<T, int> || std::is_same_v<T, unsigned int> ||
                       std::is_same_v<T, double> || std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t>))
        void WriteInWriter(Writer& writer, T& /*value*/) const
        {
            writer.Write("", "??");
        }
 
        // Even if it can be static, the function is used as overload for Printf function.
        // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
        void Printf(std::string& text, LogWriter& /*writer*/, int /*ignoreCount*/, const char* format) const
        {
            text += format;
        }
 
        template<typename T, typename... Args>
        // The clang-tidy generates false positive for value. The value is used in function body.
        // NOLINTNEXTLINE(misc-unused-parameters)
        void Printf(std::string& text,
                    LogWriter& writer,
                    int ignoreCount,
                    const char* format,
                    T&& value,
                    Args&&... args) const
        {
            if (ignoreCount > 0)
            {
                // Move to next argument. The value will be next argument.
                Printf(text, writer, ignoreCount - 1, format, args...);
                return;
            }
 
            int stars = 0;
 
            for (const auto* formatIt = format; *formatIt != '\0'; std::advance(formatIt, 1))
            {
                if (*formatIt == '%')
                {
                    auto sprintfFormatArray = GetFormatForOneValueAndMoveToNext(formatIt);
                    auto sprintfFormat = std::string_view(sprintfFormatArray.data());
 
                    if (!sprintfFormat.empty())
                    {
                        if (IsWriter(sprintfFormat.back()))
                        {
                            auto arrayLength = GetWriterArrayLength(sprintfFormat);
 
                            ComposeInWriter(writer, arrayLength, value);
                        }
                        else if (IsPercentage(sprintfFormat.at(1)))
                        {
                            text += "%";
                            continue;
                        }
                        else
                        {
                            // Add format specifier
                            stars = GetStarsInFormat(sprintfFormat);
                            auto sprintfText =
                              ComposeInPrintf(sprintfFormat, stars, value, std::forward<Args>(args)...);
                            text += sprintfText.data();
                        }
                    }
                    else
                    {
                        // error, too long format specifier, skip the value
                    }
 
                    Printf(text, writer, stars, std::next(formatIt, 1), args...);
                    return;
                }
                text += *formatIt;
            }
        }
 
        static constexpr int MaxSprintfFormatSize = 21;
        static std::array<char, MaxSprintfFormatSize> GetFormatForOneValueAndMoveToNext(const char*& formatIt)
        {
            std::advance(formatIt, 1);
            static constexpr int MaxSprintfFormatLength = MaxSprintfFormatSize - 1;
            std::array<char, MaxSprintfFormatLength + 1> sprintfFormat = {};
            sprintfFormat[0] = '%';
            int i = 1;
            for (; *formatIt != '\0' && !IsSpecifier(*formatIt); std::advance(formatIt, 1), i++)
            {
                if (i < MaxSprintfFormatLength)
                {
                    sprintfFormat.at(i) = *formatIt;
                }
            }
            // Append format specifier
            if (*formatIt != '\0' && i <= MaxSprintfFormatLength)
            {
                // save specifier
                sprintfFormat.at(i++) = *formatIt;
                sprintfFormat.at(i) = '\0';
            }
 
            if (i > MaxSprintfFormatLength)
            {
                // format specifier is too long
                // discard the value
                sprintfFormat.at(0) = '\0';
            }
 
            return sprintfFormat;
        }
 
        static unsigned int GetWriterArrayLength(std::string_view format)
        {
            // check if array element is given, not only format specifier '%v'
            if (format.length() <= 2)
            {
                return LogWriter::MaxArraySize;
            }
 
            int i = 0;
            static constexpr int Base = 10;
            const char* start = std::next(format.data(), 1);
            const char* end = std::next(format.data(), static_cast<ptrdiff_t>(format.length() - 1));
            std::from_chars(start, end, i, Base);
            return i;
        }
 
        template<typename T>
        void ComposeInWriter(LogWriter& writer, unsigned int arrayLength, T&& value) const
        {
            writer.actualMaxArraySize = arrayLength;
            WriteInWriter(writer, std::forward<T>(value));
        }
 
        static int GetStarsInFormat(std::string_view format)
        {
            int stars = 0;
 
            for (const auto c : format)
            {
                if (c == '*')
                {
                    stars++;
                }
            }
            return stars;
        }
 
        static constexpr int MaxSprintfTextSize = 101;
        template<typename T, typename... Args>
        std::array<char, MaxSprintfTextSize> ComposeInPrintf(
          std::string_view& format,
          int stars,
          T& value,
          Args&&... args) // NOLINT(cppcoreguidelines-missing-std-forward)
                          // It is unpacked and used as arguments in WriteInSprintf in case of
                          // width/precision is given as variable in variadic parameters
                          // e.g %*d
                          // When std::forward is used, then incorrect WriteInSprintf function is used
                          // and unit tests fails
          const
        {
            static constexpr int MaxSprintfTextLength = MaxSprintfTextSize - 1;
            auto sprintfText = std::array<char, MaxSprintfTextSize>{};
            int totalLength = 0;
 
            // It is not same
            // NOLINTNEXTLINE(bugprone-branch-clone)
            if (stars == 0)
            {
                totalLength = WriteInSprintf(sprintfText.data(), MaxSprintfTextLength, format.data(), value);
            }
            else
            {
                // It is false positive of clang-tidy
                // NOLINTNEXTLINE(readability-suspicious-call-argument)
                totalLength = WriteInSprintf(sprintfText.data(), MaxSprintfTextLength, format.data(), value, args...);
            }
 
            if (totalLength > MaxSprintfTextLength)
            {
                sprintfText[MaxSprintfTextLength - 1] = '.';
                sprintfText[MaxSprintfTextLength - 2] = '.';
                sprintfText[MaxSprintfTextLength - 3] = '.';
                sprintfText[MaxSprintfTextLength] = '\0';
            }
            else
            {
                sprintfText.at(totalLength) = '\0';
            }
 
            return sprintfText;
        }
 
        template<typename T, typename... Args>
            requires(std::is_trivially_copyable_v<T>)
        int WriteInSprintf(char* sprintfText,
                           int sprintfTextSize,
                           const char* sprintfFormat,
                           T& value,
                           Args&&... /*args*/) // NOLINT(cppcoreguidelines-missing-std-forward) false positive
          const
        {
            // We want to use all format specifiers.
            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
            return snprintf(sprintfText, sprintfTextSize, sprintfFormat, value);
        }
        template<typename W, typename T, typename... Args>
            requires(std::is_trivially_copyable_v<T> && std::is_integral_v<W>)
        int WriteInSprintf(char* sprintfText,
                           int sprintfTextSize,
                           const char* sprintfFormat,
                           W width,
                           T& value,
                           Args&&... /*args*/) // NOLINT(cppcoreguidelines-missing-std-forward) false positive
          const
        {
            // We want to use all format specifiers.
            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
            return snprintf(sprintfText, sprintfTextSize, sprintfFormat, width, value);
        }
        template<typename W, typename P, typename T, typename... Args>
            requires(std::is_trivially_copyable_v<T> && std::is_integral_v<W> && std::is_integral_v<P>)
        int WriteInSprintf(char* sprintfText,
                           int sprintfTextSize,
                           const char* sprintfFormat,
                           W width,
                           P precision,
                           T& value,
                           Args&&... /*args*/) // NOLINT(cppcoreguidelines-missing-std-forward) false positive
          const
        {
            // We want to use all format specifiers.
            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
            return snprintf(sprintfText, sprintfTextSize, sprintfFormat, width, precision, value);
        }
        template<typename T, typename... Args>
            requires(!std::is_trivially_copyable_v<T>)
        int WriteInSprintf(char* sprintfText,
                           int /*sprintfTextSize*/,
                           const char* /*sprintfFormat*/,
                           T& /*value*/,
                           Args&&... /*args*/) // NOLINT(cppcoreguidelines-missing-std-forward) false positive
          const
        {
            // ignore non trivial type passed to snprintf
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
            sprintfText[0] = '\0';
            return 0;
        }
 
        static constexpr bool IsSpecifier(char sign)
        {
            return sign == 'd' || sign == 'i' || sign == 'u' || sign == 'o' || sign == 'x' || sign == 'X' ||
                   sign == 'f' || sign == 'F' || sign == 'e' || sign == 'E' || sign == 'g' || sign == 'G' ||
                   sign == 'a' || sign == 'A' || sign == 'c' || sign == 's' || sign == 'p' || sign == 'n' ||
                   sign == '%' || sign == 'v';
        }
        static constexpr bool IsWriter(char sign)
        {
            return sign == 'v';
        }
        static constexpr bool IsPercentage(char sign)
        {
            return sign == '%';
        }
    };

     */
    class FormattingLogger
    {
    public:
        template<typename... Args>
        void LogInfo(const char* format, Args&&... args) const
        {
            if (log != nullptr)
            {
                FormattingComposer composer(format, std::forward<Args>(args)...);
                log->LogInfo(composer);
            }
        }
        template<typename... Args>
        void LogDebug(const char* format, Args&&... args) const
        {
            if (log != nullptr)
            {
                FormattingComposer composer(format, std::forward<Args>(args)...);
                log->LogDebug(composer);
            }
        }
        template<typename... Args>
        void LogError(const char* format, Args&&... args) const
        {
            if (log != nullptr)
            {
                FormattingComposer composer(format, std::forward<Args>(args)...);
                log->LogError(composer);
            }
        }

         */
        explicit FormattingLogger(std::shared_ptr<Logger> logger)
          : log(std::move(logger))
        {
        }

         */
        [[nodiscard]] std::shared_ptr<Logger> GetLogger() const
        {
            return log;
        }
 
        FormattingLogger() = delete;
        FormattingLogger(const FormattingLogger&) = delete;
        FormattingLogger(FormattingLogger&&) = delete;
        FormattingLogger& operator=(const FormattingLogger&) = delete;
        FormattingLogger& operator=(FormattingLogger&&) = delete;
        ~FormattingLogger() = default;
 
    private:
        std::shared_ptr<Logger> log;
    };
} // namespace inno