MessageFormatter.h

/*
 * Copyright (C) 2019-2024 HERE Europe B.V.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */
 
#pragma once
 
#include <array>
#include <string>
#include <utility>
#include <vector>
 
#include <olp/core/CoreApi.h>
 
#include <olp/core/logging/Format.h>
#include <olp/core/logging/Level.h>
#include <olp/core/logging/LogMessage.h>
 
namespace olp {
namespace logging {
class CORE_API MessageFormatter {
 public:
  using LevelNameMap = std::array<std::string, levelCount>;
 
  enum class ElementType {
    String,   
    Level,    
    Tag,      
    Message,  
    File,     
    Line,     
    Function,  
    FullFunction,  
    Time,    
    TimeMs,  
    ThreadId, 
    ContextValue,  
  };
 
  struct CORE_API Element {
    explicit Element(ElementType type_);
 
    inline Element(ElementType type_, std::string format_, int limit_ = 0);
 
    Element(const Element&) = default;
 
    Element& operator=(const Element&) = default;
 
    inline Element(Element&& other) noexcept;
 
    inline Element& operator=(Element&& other) noexcept;
 
    inline bool operator==(const Element& other) const;
 
    inline bool operator!=(const Element& other) const;
 
    ElementType type;
 
    std::string format;
 
    int limit;
  };
 
  enum class Timezone {
    Local,  
    Utc     
  };
 
  static const LevelNameMap& defaultLevelNameMap();
 
  static MessageFormatter createDefault();
 
  inline MessageFormatter();
 
  explicit inline MessageFormatter(
      std::vector<Element> elements,
      LevelNameMap levelNameMap = defaultLevelNameMap(),
      Timezone timezone = Timezone::Local);
 
  MessageFormatter(const MessageFormatter&) = default;
 
  MessageFormatter& operator=(const MessageFormatter&) = default;
 
  inline MessageFormatter(MessageFormatter&& other) noexcept;
 
  inline MessageFormatter& operator=(MessageFormatter&& other) noexcept;
 
  inline const std::vector<Element>& getElements() const;
 
  inline MessageFormatter& setElements(std::vector<Element> elements);
 
  inline const LevelNameMap& getLevelNameMap() const;
 
  inline MessageFormatter& setLevelNameMap(LevelNameMap map);
 
  inline Timezone getTimezone() const;
 
  inline MessageFormatter& setTimezone(Timezone timezone);
 
  std::string format(const LogMessage& message) const;
 
 private:
  std::vector<Element> m_elements;
  LevelNameMap m_levelNameMap;
  Timezone m_timezone;
};
 
inline MessageFormatter::Element::Element(ElementType type_,
                                          std::string format_, int limit_)
    : type(type_), format(std::move(format_)), limit(limit_) {}
 
inline MessageFormatter::Element::Element(Element&& other) noexcept
    : type(other.type), format(std::move(other.format)), limit(other.limit) {}
 
inline MessageFormatter::Element& MessageFormatter::Element::operator=(
    Element&& other) noexcept {
  type = other.type;
  format = std::move(other.format);
  limit = other.limit;
  return *this;
}
 
inline bool MessageFormatter::Element::operator==(const Element& other) const {
  return type == other.type && format == other.format && limit == other.limit;
}
 
inline bool MessageFormatter::Element::operator!=(const Element& other) const {
  return !(*this == other);
}
 
inline MessageFormatter::MessageFormatter()
    : m_levelNameMap(defaultLevelNameMap()), m_timezone(Timezone::Local) {}
 
inline MessageFormatter::MessageFormatter(std::vector<Element> elements,
                                          LevelNameMap levelNameMap,
                                          Timezone timezone)
    : m_elements(std::move(elements)),
      m_levelNameMap(std::move(levelNameMap)),
      m_timezone(timezone) {}
 
inline MessageFormatter::MessageFormatter(MessageFormatter&& other) noexcept
    : m_elements(std::move(other.m_elements)),
      m_levelNameMap(std::move(other.m_levelNameMap)),
      m_timezone(other.m_timezone) {}
 
inline MessageFormatter& MessageFormatter::operator=(
    MessageFormatter&& other) noexcept {
  m_elements = std::move(other.m_elements);
  m_levelNameMap = std::move(other.m_levelNameMap);
  m_timezone = other.m_timezone;
  return *this;
}
 
inline const std::vector<MessageFormatter::Element>&
MessageFormatter::getElements() const {
  return m_elements;
}
 
inline MessageFormatter& MessageFormatter::setElements(
    std::vector<Element> elements) {
  m_elements = std::move(elements);
  return *this;
}
 
inline const MessageFormatter::LevelNameMap& MessageFormatter::getLevelNameMap()
    const {
  return m_levelNameMap;
}
 
inline MessageFormatter& MessageFormatter::setLevelNameMap(LevelNameMap map) {
  m_levelNameMap = std::move(map);
  return *this;
}
 
inline MessageFormatter::Timezone MessageFormatter::getTimezone() const {
  return m_timezone;
}
 
inline MessageFormatter& MessageFormatter::setTimezone(Timezone timezone) {
  m_timezone = timezone;
  return *this;
}
 
}  // namespace logging
}  // namespace olp