Logger.h

Go to the documentation of this file.

// Copyright 2016 Sensics, Inc.
//
// 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.

#ifndef INCLUDED_Logger_h_GUID_D8ADC0E7_A358_4FF2_960F_10F098A22F4E
#define INCLUDED_Logger_h_GUID_D8ADC0E7_A358_4FF2_960F_10F098A22F4E

// Internal Includes
#include <osvr/Util/Export.h>
#include <osvr/Util/Log.h> // for LoggerPtr
#include <osvr/Util/LogLevel.h>

// Library/third-party includes
// - none

// Standard includes
#include <initializer_list>
#include <memory>  // for std::shared_ptr
#include <sstream> // for std::ostringstream
#include <string>  // for std::string

// Forward declarations

namespace spdlog {
class logger;
namespace sinks {
    class sink;
} // namespace sinks

using sink_ptr = std::shared_ptr<spdlog::sinks::sink>;
using sinks_init_list = std::initializer_list<sink_ptr>;
} // namespace spdlog

namespace osvr {
namespace util {
    namespace log {

        class Logger {
          private:
            struct PrivateConstructor;

          public:
            Logger(std::string const &name,
                   std::shared_ptr<spdlog::logger> logger,
                   PrivateConstructor *);

            OSVR_UTIL_EXPORT static LoggerPtr makeFromExistingImplementation(
                std::string const &name,
                std::shared_ptr<spdlog::logger> logger);

            OSVR_UTIL_EXPORT static LoggerPtr
            makeWithSink(std::string const &name, spdlog::sink_ptr sink);

            OSVR_UTIL_EXPORT static LoggerPtr
            makeWithSinks(std::string const &name,
                          spdlog::sinks_init_list sinks);

            Logger(const Logger &) = delete;

            Logger &operator=(const Logger &) = delete;

            OSVR_UTIL_EXPORT ~Logger();

            OSVR_UTIL_EXPORT LogLevel getLogLevel() const;

            OSVR_UTIL_EXPORT void setLogLevel(LogLevel level);

            OSVR_UTIL_EXPORT void flushOn(LogLevel level);

            class StreamProxy {
              public:
                StreamProxy(Logger &logger, LogLevel level)
                    : logger_(logger), level_(level),
                      os_(new std::ostringstream) {}

                StreamProxy(Logger &logger, LogLevel level,
                            const std::string &msg)
                    : logger_(logger), level_(level),
                      os_(new std::ostringstream) {
                    (*os_) << msg;
                }

                ~StreamProxy() {
                    if (active_ && os_) {
                        logger_.write(level_, os_->str().c_str());
                    }
                }

                StreamProxy(StreamProxy &&other)
                    : logger_(other.logger_), level_(other.level_),
                      os_(std::move(other.os_)), active_(other.active_) {
                    other.active_ = false;
                }

                StreamProxy(StreamProxy const &) = delete;
                StreamProxy &operator=(StreamProxy const &) = delete;

                operator std::ostream &() { return (*os_); }

                template <typename T> std::ostream &operator<<(T &&what) {
                    (*os_) << std::forward<T>(what);
                    return (*os_);
                }

              private:
                Logger &logger_;
                LogLevel level_;
                std::unique_ptr<std::ostringstream> os_;
                bool active_ = true;
            };

            OSVR_UTIL_EXPORT StreamProxy trace(const char *msg);
            OSVR_UTIL_EXPORT StreamProxy debug(const char *msg);
            OSVR_UTIL_EXPORT StreamProxy info(const char *msg);
            OSVR_UTIL_EXPORT StreamProxy notice(const char *msg);
            OSVR_UTIL_EXPORT StreamProxy warn(const char *msg);
            OSVR_UTIL_EXPORT StreamProxy error(const char *msg);
            OSVR_UTIL_EXPORT StreamProxy critical(const char *msg);

            OSVR_UTIL_EXPORT StreamProxy trace();
            OSVR_UTIL_EXPORT StreamProxy debug();
            OSVR_UTIL_EXPORT StreamProxy info();
            OSVR_UTIL_EXPORT StreamProxy notice();
            OSVR_UTIL_EXPORT StreamProxy warn();
            OSVR_UTIL_EXPORT StreamProxy error();
            OSVR_UTIL_EXPORT StreamProxy critical();

            OSVR_UTIL_EXPORT StreamProxy log(LogLevel level, const char *msg);

            OSVR_UTIL_EXPORT StreamProxy log(LogLevel level);

            OSVR_UTIL_EXPORT void flush();

            std::string const &getName() const {
                return name_;
            }

          private:
            static LoggerPtr
            makeLogger(std::string const &name,
                       std::shared_ptr<spdlog::logger> const &logger);

            static LoggerPtr makeFallback(std::string const &name);

            OSVR_UTIL_EXPORT void write(LogLevel level, const char* msg);

            const std::string name_;
            std::shared_ptr<spdlog::logger> logger_;
        };

    } // namespace log
} // namespace util
} // namespace osvr

#endif // INCLUDED_Logger_h_GUID_D8ADC0E7_A358_4FF2_960F_10F098A22F4E