utilities.hpp

Go to the documentation of this file.

#ifndef __UTILITIES_HPP__
#define __UTILITIES_HPP__

#include <unistd.h>
#include <sstream>


// Undefine macro assert, it clobbers the class member function assert
#undef assert


/*********************************************************/
/* */
/* Function Declarations */
/* */
/*********************************************************/


class Utilities {

 static bool is_multi_thread_or_proccess;

 static int log_fd;

 static const int stdout_fd;

 static const int error_fd;

 public:
 static constexpr const int invalid_fd = -2;

 static void setup( const bool clear_log );

 static pid_t get_tid();

 struct Unused {
 template<typename ...unused> Unused(unused const & ... ) {}
 };


 /*********************************************************/
 /* */
 /* Error checking */
 /* */
 /*********************************************************/


 [[noreturn]] static void err( const char *const s );

 static void assert( const bool b, const char *const s );


 /*********************************************************/
 /* */
 /* Logging */
 /* */
 /*********************************************************/


 template <typename... Args> static void log( Args &&... args ) {
 write_log( log_fd, std::forward<Args>( args )... );
 }

 template <typename... Args> static void verbose_log( Args &&... args ) {
#ifdef DEBUG_MODE
# ifdef VERBOSE
 log( std::forward<Args>( args )... );
# endif
#endif
 Unused { args... };
 }

 template <typename... Args> static void message( Args &&... args ) {
 write_log( log_fd, std::forward<Args>( args )... );
 write_log( stdout_fd, std::forward<Args>( args )... );
 }

 template <typename... Args> static void log_error( Args &&... args ) {
 write_log( log_fd, std::forward<Args>( args )... );
 write_log( error_fd, std::forward<Args>( args )... );
 }

#ifdef DEBUG_MODE

 template <typename... Args> static void debug( Args &&... args ) {
 log_error( std::forward<Args>( args )... );
 }
#endif

 static void enable_multi_thread_or_process_mode();

 private:
 template <typename... Args> static void write_log( const int fd, Args &&... args );

 template <typename... Args>
 static void write_log_helper( std::stringstream &stream, Args &&... args );


 /*********************************************************/
 /* */
 /* Template specialization implementations */
 /* */
 /*********************************************************/


 template <typename T>
 static void write_log_helper( std::stringstream &stream, T &&val ) {
 stream << val;
 }

 template <typename Head, typename... Tail>
 static void write_log_helper( std::stringstream &stream, Head &&head,
 Tail &&... tail ) {
 stream << head;
 write_log_helper( stream, std::forward<Tail>( tail )... );
 }
};

/*********************************************************/
/* */
/* Template non-specialization implementations */
/* */
/*********************************************************/


// Write the arguments to f if f is not null
// On failure, silently fails (since it cannot write out)
template <typename... Args> void Utilities::write_log( const int fd, Args &&... args ) {
 if ( fd != invalid_fd ) {

 // Create the stream and note the tid if is_multi_thread_or_proccess
 std::stringstream stream;
 if ( is_multi_thread_or_proccess ) {
 stream << get_tid() << ": ";
 }

 write_log_helper( stream, std::forward<Args>( args )... );
 stream << '\n';

 // Write the string then flush the buffer
 // Assert message errors must be nullptr to prevent a loop
 const std::string str = stream.str();
 const ssize_t len = str.size();
 Utilities::assert( write( fd, str.c_str(), len ) == (ssize_t) len, nullptr );
 }
}


#endif /* utilities_h */