vpDebug.h

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2015 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Debug and trace macro.
 *
 *   - TRACING:    vpTRACE and vpERROR_TRACE work like printf with carreer return at the end of the string.
 *                 vpCERROR et vpCTRACE work like the C++ output streams std::cout and std::cerr.
 *   - DEBUGING:   vpDEBUG_TRACE(niv) and vpDERROR_TRACE(niv), work like printf, but print only if the
 *                 tracing level niv is greater than the debug level VP_DEBUG_MODE.
 *                 vpCDEBUG(niv) work like the C++ output stream std::cout.
 *                 vpDEBUG_ENABLE(niv) is equal to 1 if the debug level niv is greater than the debug mode
 *                 VP_DEBUG_MODE, 0 else.
 *   - PROG DEFENSIVE: DEFENSIF(a) is equal to a if defensive mode is active, 0 else.
 *
 * Authors:
 * Nicolas Mansard, Bruno Renier
 *
 *****************************************************************************/

#ifndef __VP_DEBUG_HH
#define __VP_DEBUG_HH

#include <visp3/core/vpConfig.h>
#include <stdio.h>
#include <stdarg.h>
#include <iostream>


#if defined(_WIN32)
#  ifndef __FUNCTION__
#    define __FUNCTION__ " "
#  endif
#endif

#ifndef VP_DEBUG_MODE
#  define VP_DEBUG_MODE 0
#endif


class vpTraceOutput
{
  private:
    const char* currentFile; //Name of the file to use in the displays
    const char* currentFunc; //Name of the function to use in the displays
    int currentLine;         //Line to use in the displays

    //if true, output to std::cerr/stderr else std::cout/stdout
    bool err;
    //string to display before anything else
    const char* header;

  public:
    vpTraceOutput(const char* file, int line, const char* func, bool error=false, const char * s=NULL) :
      currentFile(file),
      currentFunc(func),
      currentLine(line),
      err(error),
      header(s)
    {}

    void operator()(int level, const char* format, ...)
    {
      //if the level is inferior to VP_DEBUG_MODE
      if(VP_DEBUG_MODE >= level)
      {
        //gets the variable list of arguments
        va_list args;
        va_start(args, format);

        if (err)
          std::cerr << "(L" << level << ") " ;
        else
          std::cout << "(L" << level << ") " ;

        //calls display with it
        display(format, args);

        va_end(args);
      }
    }

    void operator()(const char* format, ...)
    {
      //gets the variable list of arguments
      va_list args;
      va_start(args, format);

#ifdef VP_DEBUG
      std::cout<<"(L0) ";
#endif

      //calls display with it
      display(format, args);

      va_end(args);
    }

    void display(const char* format, va_list args)
    {
      //if we want to write to std::cerr/stderr
      if(err)
      {
        //first writes the header if there is one
        if(header != NULL) std::cerr<<header;
        //then writes the recorded namefile, function and line
        std::cerr << "!!\t" << currentFile << ": " <<currentFunc << "(#" << currentLine << ") : " ;
        //and finally writes the message passed to () operator.
        vfprintf (stderr, format, args);
        fprintf (stderr, "\n");
        //flushes the buffer
        fflush (stderr);
      }
      else
      {
        //first writes the header if there is one
        if(header != NULL) std::cout<<header;
        //then writes the recorded namefile, function and line
        std::cout <<currentFile << ": " << currentFunc << "(#" << currentLine << ") : " ;
        //and finally writes the message passed to () operator.
        vprintf (format, args);
        printf ("\n");
        //flushes the buffer
        fflush (stdout);
      }
    }

};


/* ------------------------------------------------------------------------- */
/* --- vpTRACE IN/OUT FONCTION --------------------------------------------- */
/* ------------------------------------------------------------------------- */

#ifdef VP_TRACE        // Activate the trace mode

#define vpIN_FCT (vpTraceOutput(__FILE__,__LINE__, __FUNCTION__, false, "begin "))


#define vpOUT_FCT (vpTraceOutput(__FILE__,__LINE__, __FUNCTION__, false, "end "))

#else // #ifdef VP_TRACE

inline void vpIN_FCT (const char * /* a */, ...){}
inline void vpOUT_FCT (const char * /* a */, ...){}

#endif // #ifdef VP_TRACE

/* -------------------------------------------------------------------------- */
/* --- vpTRACE -------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

#ifdef VP_TRACE

#define vpCTRACE std::cout << "(L0) " << __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") : "


#define vpCERROR std::cerr << "(L0) " << "!!\t" << __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") : "

#define vpERROR_TRACE (vpTraceOutput( __FILE__,__LINE__, __FUNCTION__, true))

#define vpTRACE (vpTraceOutput( __FILE__,__LINE__, __FUNCTION__, false))

#else // #ifdef VP_TRACE

#define vpCTRACE if(false) std::cout // Warning C4127
#define vpCERROR if(false) std::cerr // Warning C4127

inline void vpERROR_TRACE (const char * /* a */, ...){}
inline void vpERROR_TRACE (int /* level */, const char * /* a */, ...){}
inline void vpTRACE (const char * /* a */, ...){}
inline void vpTRACE (int /* level */, const char * /* a */, ...){}

#endif // #ifdef VP_TRACE

/* ------------------------------------------------------------------------- */
/* --- VP_DEBUG ------------------------------------------------------------ */
/* ------------------------------------------------------------------------- */

#ifdef VP_DEBUG

#define vpDERROR_TRACE (vpTraceOutput( __FILE__,__LINE__, __FUNCTION__, true))

#define vpDEBUG_TRACE (vpTraceOutput( __FILE__,__LINE__, __FUNCTION__, false))

#define vpCDEBUG(level) if (VP_DEBUG_MODE < level) ; else \
    std::cout << "(L" << level << ") "<<  __FILE__ << ": " << __FUNCTION__ << "(#" << __LINE__ << ") : "

#define vpDEBUG_ENABLE(level) (VP_DEBUG_MODE >= level)

#else // #ifdef VP_DEBUG

inline void vpDERROR_TRACE(const char * /* a */, ...){}
inline void vpDEBUG_TRACE(const char * /* a */, ...){}
inline void vpDERROR_TRACE(int /* level */, const char * /* a */, ...){}
inline void vpDEBUG_TRACE(int /* level */, const char * /* a */, ...){}

#define vpCDEBUG(level) if(false) std::cout // Warning C4127
#define vpDEBUG_ENABLE(level) (false)       // Warning C4127

#endif // #ifdef VP_DEBUG

/* -------------------------------------------------------------------------- */
/* --- DEFENSIF ------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
#ifdef VP_DEFENSIF
#define DEFENSIF(a)  (a)
#else
#define DEFENSIF(a)  (0)
#endif  /*#ifdef DEFENSIF*/


#endif /* #ifdef __DEBUG_HH */