logger.h

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * 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.
 *  * Neither the name of the ALICE Project-Team 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.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_BASIC_LOGGER
#define GEOGRAM_BASIC_LOGGER
 
#ifdef __cplusplus
 
#include <geogram/basic/common.h>
#include <geogram/basic/environment.h>
#include <geogram/basic/process.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <set>
#include <stdlib.h>
 
namespace GEO {
 
    class Logger;
    class LoggerStream;
 
    class NO_GEOGRAM_API LoggerStreamBuf : public std::stringbuf {
    public:
        LoggerStreamBuf(LoggerStream* loggerStream) :
            loggerStream_(loggerStream) {
        }
 
    private:
        int sync() override;
 
    private:
        LoggerStream* loggerStream_;
    };
 
    /************************************************************************/
 
    class NO_GEOGRAM_API LoggerStream : public std::ostream {
    public:
        LoggerStream(Logger* logger);
 
        ~LoggerStream() override;
 
    protected:
        void notify(const std::string& str);
 
    private:
        Logger* logger_;
        friend class LoggerStreamBuf;
    };
 
    /************************************************************************/
 
    class GEOGRAM_API LoggerClient : public Counted {
    public:
        virtual void div(const std::string& title) = 0;
 
        virtual void out(const std::string& str) = 0;
 
        virtual void warn(const std::string& str) = 0;
 
        virtual void err(const std::string& str) = 0;
 
        virtual void status(const std::string& str) = 0;
 
        ~LoggerClient() override;
    };
 
    typedef SmartPointer<LoggerClient> LoggerClient_var;
 
    /************************************************************************/
 
    class GEOGRAM_API ConsoleLogger : public LoggerClient {
    public:
        ConsoleLogger();
 
        void div(const std::string& title) override;
 
        void out(const std::string& str) override;
 
        void warn(const std::string& str) override;
 
        void err(const std::string& str) override;
 
        void status(const std::string& str) override;
 
    protected:
        ~ConsoleLogger() override;
    };
 
    /************************************************************************/
 
    class GEOGRAM_API FileLogger : public LoggerClient {
    public:
        FileLogger();
 
        FileLogger(const std::string& file_name);
 
        void div(const std::string& title) override;
 
        void out(const std::string& str) override;
 
        void warn(const std::string& str) override;
 
        void err(const std::string& str) override;
 
        void status(const std::string& str) override;
 
    protected:
        ~FileLogger() override;
 
        void set_file_name(const std::string& file_name);
 
    private:
        std::string log_file_name_;
        std::ostream* log_file_;
    };
 
    /************************************************************************/
 
    class GEOGRAM_API Logger : public Environment {
    public:
        static void initialize();
 
        static void terminate();
 
        static Logger* instance();
 
 
        static bool is_initialized();
 
 
        static std::ostream& div(const std::string& title);
 
        static std::ostream& out(const std::string& feature);
 
        static std::ostream& err(const std::string& feature);
 
        static std::ostream& warn(const std::string& feature);
 
        static std::ostream& status();
 
        void register_client(LoggerClient* client);
 
        void unregister_client(LoggerClient* client);
 
        void unregister_all_clients();
 
        bool is_client(LoggerClient* client) const;
 
        void set_quiet(bool flag);
 
        bool is_quiet() const {
            return quiet_;
        }
 
 
        void set_minimal(bool flag);
 
        bool is_minimal() const {
            return minimal_;
        }
 
        void set_pretty(bool flag);
 
        bool is_pretty() const {
            return pretty_;
        }
 
    protected:
        Logger();
 
        ~Logger() override;
 
        std::ostream& div_stream(const std::string& title);
 
        std::ostream& out_stream(const std::string& feature);
 
        std::ostream& err_stream(const std::string& feature);
 
        std::ostream& warn_stream(const std::string& feature);
 
        std::ostream& status_stream();
 
        std::ostream& err_console();
 
        void notify(LoggerStream* sender, const std::string& message);
 
        void notify_out(const std::string& message);
 
        void notify_warn(const std::string& message);
 
        void notify_err(const std::string& message);
 
        void notify_status(const std::string& message);
 
        bool set_local_value(
            const std::string& name, const std::string& value
        ) override;
 
        bool get_local_value(
            const std::string& name, std::string& value
        ) const override;
 
 
        void indent() {
            ++indent_;
        }
 
        void unindent() {
            geo_debug_assert(indent_ != 0);
            --indent_;
        }
 
    private:
        static SmartPointer<Logger> instance_;
 
        LoggerStream out_;
        LoggerStream warn_;
        LoggerStream err_;
        LoggerStream status_;
 
        std::ostream* err_console_;
 
        // features we want or don't want to log (only applies to 'out').
 
        typedef std::set<std::string> FeatureSet;
        FeatureSet log_features_;
        FeatureSet log_features_exclude_;
        bool log_everything_;
        std::string log_file_name_;
 
        std::string current_feature_;
        bool current_feature_changed_;
 
        typedef std::set<LoggerClient_var> LoggerClients;
        LoggerClients clients_; // list of registered clients
 
        bool quiet_;
        bool pretty_;
        bool minimal_;
        bool notifying_error_;
 
        index_t indent_;
 
        friend class LoggerStream;
        friend class LoggerStreamBuf;
        friend class Stopwatch;
    };
 
    /************************************************************************/
 
}
 
extern "C" {
    int GEOGRAM_API geogram_printf(const char* format, ...);
 
    int GEOGRAM_API geogram_fprintf(FILE* out, const char* format, ...);
}
 
#else
 
#include <stdlib.h>
 
#ifndef GEOGRAM_API
#define GEOGRAM_API
#endif
 
extern int GEOGRAM_API geogram_printf(const char* format, ...);
 
extern int GEOGRAM_API geogram_fprintf(FILE* out, const char* format, ...);
 
#endif
 
#endif