Log.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2022, Matt Hall
 *
 * 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 "MoorDynAPI.h"
#include <iostream>
#include <fstream>
 
namespace moordyn {
 
std::string
log_level_name(int level);
 
#define LOGGER(level)                                                          \
    _log->Cout(level) << log_level_name(level) << " " << __FILE__ << ":"       \
                      << __LINE__ << " " << __FUNC_NAME__ << "(): "
 
#define LOGDBG _log->Cout(MOORDYN_DBG_LEVEL)
#define LOGMSG _log->Cout(MOORDYN_MSG_LEVEL)
#define LOGWRN LOGGER(MOORDYN_WRN_LEVEL)
#define LOGERR LOGGER(MOORDYN_ERR_LEVEL)
 
class MultiStream;
 
class MultiStream
{
  public:
    MultiStream();
    ~MultiStream();
 
    inline const char* GetFile() const { return _fpath.c_str(); }
 
    void SetFile(const char* file_path);
 
    inline void SetFile(bool enable = true) { _fout_enabled = enable; };
 
    inline void SetTerminal(std::ostream& stream) { _terminal = &stream; };
 
    MultiStream& operator<<(std::ostream& (*pfun)(std::ostream&))
    {
        if (_fout_enabled && _fout.is_open())
            pfun(_fout);
        pfun(*_terminal);
        return *this;
    }
 
    std::string _fpath;
    std::ofstream _fout;
    bool _fout_enabled;
    std::ostream* _terminal;
};
 
template<class T>
MultiStream&
operator<<(MultiStream& st, T val)
{
    if (st._fout_enabled && st._fout.is_open())
        st._fout << val;
    *(st._terminal) << val;
    return st;
};
 
class DECLDIR Log
{
  public:
    Log(const int verbosity = MOORDYN_MSG_LEVEL,
        const int log_file_level = MOORDYN_DBG_LEVEL);
 
    ~Log();
 
    MultiStream& Cout(const int level = MOORDYN_MSG_LEVEL) const;
 
    inline int GetVerbosity() const { return _verbosity; }
 
    inline void SetVerbosity(const int verbosity) { _verbosity = verbosity; }
 
    inline int GetLogLevel() const { return _file_verbosity; }
 
    inline void SetLogLevel(const int level) { _file_verbosity = level; }
 
    const char* GetFile() const;
 
    void SetFile(const char* file_path);
 
  private:
    int _verbosity;
    int _file_verbosity;
    MultiStream* _streamer;
};
 
class DECLDIR LogUser
{
  public:
    LogUser(Log* log = NULL)
      : _log(log)
    {
    }
 
    ~LogUser() {}
 
    inline void SetLogger(Log* log) { _log = log; }
 
    inline Log* GetLogger() const { return _log; }
 
  protected:
    Log* _log;
};
 
} // ::moordyn