Log.h

#pragma once

#include "atlas/library/config.h"

#include "eckit/log/Log.h"

namespace atlas {

class Log : public eckit::Log {
public:
    using Channel = eckit::Channel;  // derives from std::ostream

    static Channel& info();
    static Channel& warning();
    static Channel& trace();
    static Channel& debug();

    // Same as what fckit::Log provides
    enum Style
    {
        SIMPLE    = 0,
        PREFIX    = 1,
        TIMESTAMP = 2
    };
    static void addFortranUnit( int unit, Style = PREFIX, const char* prefix = "" );
    static void setFortranUnit( int unit, Style = PREFIX, const char* prefix = "" );

    // Fortran unit numbers
    static int output_unit() { return 6; }
    static int error_unit() { return 0; }
};

std::string backtrace();

}  // namespace atlas

#include <sstream>
#include "atlas/util/detail/BlackMagic.h"
#include "eckit/log/CodeLocation.h"

namespace atlas {
namespace detail {
void debug_parallel_here( const eckit::CodeLocation& );
void debug_parallel_what( const eckit::CodeLocation&, const std::string& );
}  // namespace detail
}  // namespace atlas

#define ATLAS_DEBUG_HERE()                                           \
    do {                                                             \
        ::atlas::Log::info() << "DEBUG() @ " << Here() << std::endl; \
    } while ( 0 )
#define ATLAS_DEBUG_WHAT( WHAT )                                                   \
    do {                                                                           \
        ::atlas::Log::info() << "DEBUG(" << WHAT << ") @ " << Here() << std::endl; \
    } while ( 0 )
#define ATLAS_DEBUG_VAR( VAR )                                                                       \
    do {                                                                                             \
        ::atlas::Log::info() << "DEBUG( " << #VAR << " : " << VAR << " ) @ " << Here() << std::endl; \
    } while ( 0 )

#define ATLAS_DEBUG( ... ) __ATLAS_SPLICE( __ATLAS_DEBUG_, __ATLAS_NARG( __VA_ARGS__ ) )( __VA_ARGS__ )
#define __ATLAS_DEBUG_0 ATLAS_DEBUG_HERE
#define __ATLAS_DEBUG_1 ATLAS_DEBUG_WHAT

#define ATLAS_DEBUG_BACKTRACE()                                                                                \
    do {                                                                                                       \
        ::atlas::Log::info() << "DEBUG() @ " << Here() << "Backtrace:\n" << ::atlas::backtrace() << std::endl; \
    } while ( 0 )

#define ATLAS_DEBUG_PARALLEL_HERE()                     \
    do {                                                \
        ::atlas::detail::debug_parallel_here( Here() ); \
    } while ( 0 )
#define ATLAS_DEBUG_PARALLEL_WHAT( WHAT )                        \
    do {                                                         \
        std::stringstream w;                                     \
        w << WHAT;                                               \
        ::atlas::detail::debug_parallel_what( Here(), w.str() ); \
    } while ( 0 )

#define ATLAS_DEBUG_PARALLEL( ... )                                        \
    __ATLAS_SPLICE( __ATLAS_DEBUG_PARALLEL_, __ATLAS_NARG( __VA_ARGS__ ) ) \
    ( __VA_ARGS__ )
#define __ATLAS_DEBUG_PARALLEL_0 ATLAS_DEBUG_PARALLEL_HERE
#define __ATLAS_DEBUG_PARALLEL_1 ATLAS_DEBUG_PARALLEL_WHAT