vpDebug.h

/****************************************************************************
 *
 * $Id: vpDebug.h 4056 2013-01-05 13:04:42Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2013 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://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * 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 <visp/vpConfig.h>
#include <stdio.h>
#include <stdarg.h>
#include <iostream>


#ifdef 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 niv, const char* format, ...)
    {
    //if the niv level is inferior to VP_DEBUG_MODE
    if(VP_DEBUG_MODE >= niv)
    {
        //gets the variable list of arguments
        va_list args;
        va_start(args, format);
        
        if (err)
        std::cerr << "(N" << niv << ") " ;
        else
        std::cout << "(N" << niv << ") " ;

        //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<<"(N0) ";
#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 --------------------------------------------- */
/* ------------------------------------------------------------------------- */

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


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



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

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


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

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

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


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

#ifdef VP_DEBUG

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

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

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

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

#else

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

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

#endif

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


#endif /* #ifdef __DEBUG_HH */

/*
 * Local variables:
 * c-basic-offset: 4
 * End:
 */