Trace.h

Go to the documentation of this file.

// -*- lsst-c++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 
#if !defined(LSST_PEX_LOGGING_TRACE_H)     
#define LSST_PEX_LOGGING_TRACE_H 1

#include <iostream>
#include <string>
#include <sstream>
#include <cstdarg>
#include <cstdio>
#include <boost/format.hpp>

#include "lsst/pex/logging/Debug.h"

namespace lsst {
namespace pex {
namespace logging {

#ifndef LSST_DEBUGGING_ON
#define LSST_NO_TRACE 1
#endif

#if !defined(LSST_NO_TRACE)
#  define LSST_NO_TRACE 0    
#endif

#if !defined(LSST_MAX_TRACE)
#  define LSST_MAX_TRACE -1  
#endif

class Trace {
public:
#if !LSST_NO_TRACE

    Trace(const std::string& name,      
          const int verbosity,          
          const std::string fmt,       
          ...
          ) 
    {
        if (-1*verbosity >= Log::getDefaultLog().getThresholdFor(name)) {
            va_list ap;
            va_start(ap, fmt);
            const int len = vsnprintf(NULL, 0, fmt.c_str(), ap) + 1; // "+ 1" for the '\0'
            va_end(ap);

            char msg[len];
            va_start(ap, fmt);
            (void)vsnprintf(msg, len, fmt.c_str(), ap);
            va_end(ap);
            
            Debug out(name);
            out.debug(verbosity, msg);
        }
    }

    Trace(const std::string& name,      
          const int verbosity,          
          const char *msg               
          ) 
    {
        if (-1*verbosity >= Log::getDefaultLog().getThresholdFor(name)) {
            Debug out(name);
            out.debug(verbosity, msg);
        }
    }

    Trace(const std::string& name,      
          const int verbosity,          
          const boost::format& msg      
          )
    {
        if (-1*verbosity >= Log::getDefaultLog().getThresholdFor(name)) {
            Debug out(name);
            out.debug(verbosity, msg.str());
        }
    }

#else
/*
    Trace(const std::string& name, const int verbosity) {}
*/
    Trace(const std::string& name, const int verbosity,
          const std::string& msg, ...) {}
    Trace(const std::string& name, const int verbosity,
          const boost::format& msg) {}

#endif

    static void setDestination(std::ostream &) {
    }

    static void setVerbosity(const std::string &name) {
        if (name.length() == 0 || name == ".") 
            Log::getDefaultLog().setThreshold(Log::INHERIT_THRESHOLD);
        else
            Log::getDefaultLog().setThresholdFor(name, Log::INHERIT_THRESHOLD);
    }
    static void setVerbosity(const std::string &name, const int verbosity) {
        if (name.length() == 0 || name == ".") 
            Log::getDefaultLog().setThreshold(-1*verbosity);
        else
            Log::getDefaultLog().setThresholdFor(name, -1*verbosity);
    }
    static int getVerbosity(const std::string &name) {
        if (name.length() == 0 || name == ".") 
            return -1*Log::getDefaultLog().getThreshold();
        else 
            return -1*Log::getDefaultLog().getThresholdFor(name);
    }
    static void printVerbosity(std::ostream& out) {
        Log::getDefaultLog().printThresholds(out);
    }
    static void reset() {
        Log::getDefaultLog().reset();
    }
};

template<int VERBOSITY>
void TTrace(const char *name,           
            const char *fmt,            
            ...
           ) {
    if (LSST_MAX_TRACE < 0 || VERBOSITY <= LSST_MAX_TRACE) {
        va_list ap;

        // first determine the length of the message
        va_start(ap, fmt);
        const int len = vsnprintf(NULL, 0, fmt, ap) + 1; // "+ 1" for the '\0'
        va_end(ap);

        char msg[len];
        va_start(ap, fmt);
        (void)vsnprintf(msg, len, fmt, ap);
        va_end(ap);

        Trace(name, VERBOSITY, msg);
    }
}

template<int VERBOSITY>
void TTrace(const std::string name,      
            const std::string fmt,       
            ...
           ) {
    if (LSST_MAX_TRACE < 0 || VERBOSITY <= LSST_MAX_TRACE) {
        va_list ap;
        va_start(ap, fmt);
        Trace(name, VERBOSITY, fmt, ap);
        va_end(ap);
    }
}


} // namespace logging
} // namespace pex
} // namespace lsst
#endif    // end LSST_PEX_LOGGING_TRACE_H