logger.hpp

/*
 * Copyright 2017 ONERA
 *
 * This file is part of the MAUVE Runtime project.
 *
 * MAUVE Runtime is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3 as
 * published by the Free Software Foundation.
 *
 * MAUVE Runtime is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with MAUVE.  If not, see <https://www.gnu.org/licenses/lgpl-3.0>.
 */
#ifndef MAUVE_RUNTIME_LOGGER_HPP
#define MAUVE_RUNTIME_LOGGER_HPP

#include <iostream>

#include "spdlog/spdlog.h"
#include "spdlog/fmt/bundled/ostream.h"

namespace YAML {
  class Node;
}

namespace mauve {
  namespace runtime {

  class AbstractComponent;
  class AbstractResource;

  class AbstractLogger {
  public:
    AbstractLogger();

    virtual ~AbstractLogger();

    static void initialize();

    static void initialize(std::istream& is);

    static void initialize(const std::string& s);

    static void initialize(const YAML::Node& n);

    static void clear();

    static AbstractLogger* get_logger(const std::string& name);

    template <typename... Args>
    void trace(const char* fmt, const Args&... args);

    template <typename... Args>
    void debug(const char* fmt, const Args&... args);

    template <typename... Args>
    void info(const char* fmt, const Args&... args);

    template <typename... Args>
    void warn(const char* fmt, const Args&... args);

    template <typename... Args>
    void error(const char* fmt, const Args&... args);

    template <typename... Args>
    void critical(const char* fmt, const Args&... args);

  protected:
    static std::map<std::string,
      std::vector< std::shared_ptr<spdlog::logger> > > loggers;
    static std::shared_ptr<spdlog::logger> default_logger_;
    virtual std::string prepend(const char* fmt) = 0;
    virtual std::string name() = 0;
    static spdlog::level::level_enum level_enum(const std::string& lvl);

  };

  class CategoryLogger final : public AbstractLogger {
  public:
    CategoryLogger(const std::string& name);
  protected:
    std::string prepend(const char* fmt) override;
    std::string name() override;
  private:
    std::string name_;
  };

  class ComponentLogger final : public AbstractLogger {
  public:
    ComponentLogger(AbstractComponent* component);
  protected:
    std::string prepend(const char* fmt) override;
    std::string name() override;
  private:
    AbstractComponent* component_;
    std::string status();
  };

  class ResourceLogger final : public AbstractLogger {
  public:
    ResourceLogger(AbstractResource* resource);
  protected:
    std::string prepend(const char* fmt) override;
    std::string name() override;
  private:
    AbstractResource* resource_;
    std::string status();
  };

  class DeployerLogger final : public AbstractLogger {
  public:
    DeployerLogger();
  protected:
    std::string name() override;
    std::string prepend(const char* fmt) override;

  };

}}

#include "ipp/logger.ipp"

#endif