trace.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_TRACE_H
#define WT_TRACE_H

#include <stdio.h>
#include <stdarg.h>

#include <iostream>
#if DEBUG
#include <list>
#include <string>
#include <fstream>
#include <sstream>
#endif

#define SEPARATOR \
"----------------------------------------------------------------\n"
#define SEPARATOR2 \
"================================================================\n"
#define SEPARATOR3 \
"****************************************************************\n"

#define WARNPREFIX "Warning:[%s:%u]:"
#define ERRORPREFIX "ERROR:[%s:%u]:"

namespace Wt {

/* vararg wrapper around fprintf */
static inline int stderr_print(const char *msg, ...) {
    int ret;
    va_list ap;
    va_start(ap, msg);
    ret = vfprintf(stderr, msg, ap);
    va_end(ap);
    return ret;
}

#define __STDERR_PRINT(PREFIX) \
    ( ! fprintf(stderr, PREFIX, __FILE__, __LINE__) ) ? (0) : \
    Wt::stderr_print

#define Warn __STDERR_PRINT(WARNPREFIX)
#define Error __STDERR_PRINT(ERRORPREFIX)

#if DEBUG
extern std::list<std::string> debugRelay;

extern int enableTrace(const std::string &relay);
extern int disableTrace(const std::string &relay);

static inline bool isTrace(const std::string &relay) {
    std::list<std::string>::const_iterator channel, end;

    for (channel = debugRelay.begin(), end = debugRelay.end(); channel != end; ++channel) {
        if ((*channel == "all") || (*channel == relay)) {
            return true;
        }
    }

    return false;
}

class Trace {
private:
    class Stream {
    public:

        bool isActive() const {
            return active_;
        }

        void setActive(bool active = true) {
            active_ = active;
        }

        template<typename T>
        Stream& operator<<(const T& t) {
            if (isActive()) {
                std::cerr << t;
            }
            return *this;
        }

        // this is for endl
        Stream& operator<<(std::ostream& (*p)(std::ostream&)) {
            if (isActive()) {
                p(std::cerr);
            }
            return *this;
        }

    private:
        bool active_;
    };

public:
    void setInfo(const char* file, int line) {
        buffer.str("");
        buffer << "[" << file << ":" << line << "]:";
    }

    /* vararg wrapper around trace */
    inline int operator()(const char *relay, const char *msg, ...) {
        int ret = 0;
        va_list ap;
        va_start(ap, msg);
        if (isTrace(relay)) {
            fprintf(stderr, "[%s]:%s", relay, buffer.str().c_str());
            ret = vfprintf(stderr, msg, ap);
        }
        va_end(ap);
        return ret;
    }

    inline Stream& operator()(const char *relay) {
        trstr.setActive(isTrace(relay));
        trstr << "[" << relay << "]:" << buffer.str();
        return trstr;
    }

private:
    std::stringstream buffer;
    static Stream trstr;
};

#else // no DEBUG

#define enableTrace(RELAY)
#define disableTrace(RELAY)
#define isTrace(RELAY) 0

static inline void do_nothing(const char *relay, const char *msg, ...) {
    if (0 && relay && msg) {}
}

class Trace {
private:
    class Stream {
    public:
        template<typename T>
        Stream& operator<<(const T&) {
            return *this;
        }

        // this is for endl
        Stream& operator<<(std::ostream& (*)(std::ostream&)) {
            return *this;
        }
    };

public:
    void setInfo(const char*, int) {}

    /* vararg wrapper around trace */
    inline int operator()(const char *, const char *, ...) {
        return 0;
    }

    inline Stream& operator()(const char *) {
        return trstr;
    }

private:
    static Stream trstr;
};

#endif

static inline Trace& getTrace(const char* filename, int line) {
    static Trace trace_;
    trace_.setInfo(filename, line);
    return trace_;
}

#define trace getTrace(__FILE__, __LINE__)

}  // namespace

#endif /* _WT_TRACE_H */

---

Generated Fri Jul 28 19:23:01 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.