// Copyright (c) 2014-2018, MyMonero.com // // All rights reserved. // // Redistribution and use in source and binary forms, with or without modification, are // permitted provided that the following conditions are met: // // 1. Redistributions of source code must retain the above copyright notice, this list of // conditions and the following disclaimer. // // 2. Redistributions in binary form must reproduce the above copyright notice, this list // of conditions and the following disclaimer in the documentation and/or other // materials provided with the distribution. // // 3. Neither the name of the copyright holder nor the names of its contributors may be // used to endorse or promote products derived from this software without specific // prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // #pragma once #include #include #include //! \return True iff if copying `T` requires only memmove ASM. template constexpr bool is_cheap_copy() noexcept { return std::is_copy_constructible() && std::is_trivially_copyable() && std::is_trivially_destructible(); } //! \return True iff if there is no runtime penalty in passing `T` by value. template constexpr bool is_by_value_cheap() noexcept { return is_cheap_copy() && sizeof(T) <= sizeof(void*); } /*! A basic and fast logging implementation. Disables C++ I/O stream synchronization with C counterparts, and initializes a signal handler for SIGUSR1 to toggle debug logging. So be aware of the consequences of each if using this implementation. \note `init` must be called before any logging occurs, or the provided log level will be ignored. */ class logger { static std::atomic current_level_; static void do_init(); public: /* String literals are converted to a pointer, and cheap to copy types are taken by value. Otherwise, the value is taken by const reference. */ template using decay = typename std::conditional< std::is_array::value, const typename std::remove_extent::type *, typename std::conditional(), T, const T&>::type >::type; //! Associated level for the message and logger instance. enum level : unsigned char { kDebug = 0, //!< Maybe write to std::cerr (std::clog) with buffering kInfo, //!< Maybe write to std::cerr (std::clog) with buffering kWarning, //!< Maybe write to std::cerr (std::clog) with buffering kError // class format { public: constexpr format() noexcept = default; constexpr format(const format&) noexcept = default; format& operator=(const format&) = delete; void write(std::ostream&) const noexcept {} }; //! Specific argument(s) for a log message (1+ arguments case) template class format : protected format { static_assert( is_by_value_cheap() || std::is_lvalue_reference(), "invalid format setup" ); const Head arg_; public: // Copies all format arguments constexpr format(const format& args, const Head& arg) noexcept : format(args), arg_(arg) {} constexpr format() noexcept = default; constexpr format(const format&) noexcept = default; format& operator=(const format&) = delete; //! Writes base class to `out`, then `arg` to `out`. void write(std::ostream& out) const { format::write(out); out << arg_; } }; //! General information needed to log a message struct info { const char* const file_; const unsigned short line_; const level level_; }; static_assert( sizeof(info) <= sizeof(void*) * 2, "unlikely to be passed via registers" ); static_assert(is_cheap_copy(), "info needs to be cheap to copy"); //! Log `args` from `src` if it meets or exceeds current log level. template static bool log(const info& src, const format& args) { if (current_level_ <= unsigned(src.level_)) { static_assert( is_cheap_copy>(), "format arguments should be cheap to copy" ); static_assert( std::is_trivially_destructible>(), "unexpected destructor call required for formatter" ); return formatter{args}.log(src); } return true; } private: //! Provides type-erasure for logging arguments. class formatter_base { virtual void do_log(std::ostream& out) const = 0; public: formatter_base() noexcept = default; formatter_base(const formatter_base&) = delete; formatter_base& operator=(const formatter_base&) = delete; bool log(const info src) const; }; //! Type-erased log arguments template class formatter final : public formatter_base { const format args_; virtual void do_log(std::ostream& out) const override final { args_.write(out); } public: explicit formatter(const format& args) noexcept : args_(args) {} formatter(const formatter&) = delete; formatter& operator=(const formatter&) = delete; }; }; template void operator&(const logger::info& info, const logger::format& args) { logger::log(info, args); } template constexpr logger::format, Tail...> operator<<(const logger::format& args, const Head& arg) noexcept { return {args, arg}; } template constexpr logger::format operator<<(const logger::format& args, std::ostream& (*arg)(std::ostream&) ) noexcept { return {args, arg}; } #ifdef LOGGER_LOG # error already defined #endif #define LOGGER_LOG(level) \ logger::info{__FILE__, __LINE__, level} & logger::format<>{} #ifdef LOGGER_ERROR # error already defined #endif #define LOGGER_ERROR() LOGGER_LOG( logger::kError ) #ifdef LOGGER_WARNING # error already defined #endif #define LOGGER_WARNING() LOGGER_LOG( logger::kWarning ) #ifdef LOGGER_INFO # error already defined #endif #define LOGGER_INFO() LOGGER_LOG( logger::kInfo ) #ifdef LOGGER_DEBUG # error already defined #endif #define LOGGER_DEBUG() LOGGER_LOG( logger::kDebug )