TCOutput.h

Go to the documentation of this file.

//************************************************************
//
// *******   ***   ***               *
//    *     *     *                  *
//    *    *      *                *****
//    *    *       ***  *   *   **   *    **    ***
//    *    *          *  * *   *     *   ****  * * *
//    *     *         *   *      *   * * *     * * *
//    *      ***   ***    *     **   **   **   *   *
//                        *
// see http://sourceforge.net/projects/tcsystem/ for details.
// Copyright (C) 2003 - 2007 Thomas Goessler (the____tiger@hotmail.com)
//************************************************************
//
// TCSystem is the legal property of its developers.
// Please refer to the COPYRIGHT file distributed with this source distribution.
// 
// 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 2 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 GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//----------------------------------------------------------------------
//  $Id: TCOutput.h 883 2008-07-24 09:45:35Z the_____tiger $
//----------------------------------------------------------------------

#ifndef _TC_OUTPUT_H_
#define _TC_OUTPUT_H_

#include "TCFactory.h"

namespace TC
{
   namespace Output
   {
      class PrintTarget
      {
      public:
         virtual void Print(const char* text) = 0;

         virtual ~PrintTarget() {}
      };

          typedef SharedPtr<PrintTarget> PrintTargetPtr;

      TCBASE_API void SetTraceLevel(sint32 level);
      TCBASE_API sint32 GetTraceLevel();

      TCBASE_API void SetErrorTarget(PrintTargetPtr error_target);
      TCBASE_API void SetWarningTarget(PrintTargetPtr warning_target);
      TCBASE_API void SetInfoTarget(PrintTargetPtr info_target);
      TCBASE_API void SetTraceTarget(PrintTargetPtr trace_target);

      TCBASE_API void Error(const char* module, const char* function, 
         uint32 line_number, const char* format, ...);
      TCBASE_API void Warning(const char* module, const char* function, 
         uint32 line_number, const char* format, ...);
      TCBASE_API void Info(const char* module, const char* function, 
         uint32 line_number, const char* format, ...);
      TCBASE_API void Trace(const char* module, sint32 level, const char* function, 
         uint32 line_number, const char* format, ...);

   }// namespace Debug

} // namespace TC

#ifdef _MSC_VER
#  define _TC_FUNCTION_ __FUNCTION__
#else
#  define _TC_FUNCTION_ __PRETTY_FUNCTION__
#endif

#ifndef TCTRACE_ENABLE
#  ifdef DEBUG
#     define TCTRACE_ENABLE
#  endif
#endif

#ifdef TCTRACE_ENABLE
#   define TCTRACE(MODULE, LEVEL, FORMAT)                          TC::Output::Trace(MODULE, LEVEL, _TC_FUNCTION_, __LINE__, FORMAT)
#   define TCTRACE1(MODULE, LEVEL, FORMAT, ARG1)                   TC::Output::Trace(MODULE, LEVEL, _TC_FUNCTION_, __LINE__, FORMAT, ARG1)
#   define TCTRACE2(MODULE, LEVEL, FORMAT, ARG1, ARG2)             TC::Output::Trace(MODULE, LEVEL, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2)
#   define TCTRACE3(MODULE, LEVEL, FORMAT, ARG1, ARG2, ARG3)       TC::Output::Trace(MODULE, LEVEL, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2, ARG3)
#   define TCTRACE4(MODULE, LEVEL, FORMAT, ARG1, ARG2, ARG3, ARG4) TC::Output::Trace(MODULE, LEVEL, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2, ARG3, ARG4)
#   define TCTRACEF(MODULE, LEVEL)                                 TC::Output::Trace(MODULE, LEVEL, _TC_FUNCTION_, __LINE__, "")
#   define TCTRACES(MODULE, LEVEL, STREAM) \
    { \
        std::string val; \
        TC::StreamPtr stream(TC::Factory::CreateStringStream(val)); \
        stream << STREAM; \
        TC::Output::Trace(MODULE, LEVEL, _TC_FUNCTION_, __LINE__, "%s", val.c_str()); \
    }

#else
#   define TCTRACE(MODULE, LEVEL, FORMAT) ((void)0)
#   define TCTRACE1(MODULE, LEVEL, FORMAT, ARG1) ((void)0)
#   define TCTRACE2(MODULE, LEVEL, FORMAT, ARG1, ARG2) ((void)0)
#   define TCTRACE3(MODULE, LEVEL, FORMAT, ARG1, ARG2, ARG3) ((void)0)
#   define TCTRACE4(MODULE, LEVEL, FORMAT, ARG1, ARG2, ARG3, ARG4) ((void)0)
#   define TCTRACEF(MODULE, LEVEL)((void)0)
#   define TCTRACES(MODULE, LEVEL, STREAM) ((void)0)
#endif

#define TCINFO(MODULE, FORMAT)                          TC::Output::Info(MODULE, _TC_FUNCTION_, __LINE__, FORMAT)
#define TCINFO1(MODULE, FORMAT, ARG1)                   TC::Output::Info(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1)
#define TCINFO2(MODULE, FORMAT, ARG1, ARG2)             TC::Output::Info(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2)
#define TCINFO3(MODULE, FORMAT, ARG1, ARG2, ARG3)       TC::Output::Info(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2, ARG3)
#define TCINFO4(MODULE, FORMAT, ARG1, ARG2, ARG3, ARG4) TC::Output::Info(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2, ARG3, ARG4)
#define TCINFOS(MODULE, STREAM) \
    { \
    std::string val; \
    TC::StreamPtr stream(TC::Factory::CreateStringStream(val)); \
    stream << STREAM; \
    TC::Output::Info(MODULE, _TC_FUNCTION_, __LINE__, "%s", val.c_str()); \
}

#define TCWARNING(MODULE, FORMAT)                          TC::Output::Warning(MODULE, _TC_FUNCTION_, __LINE__, FORMAT)
#define TCWARNING1(MODULE, FORMAT, ARG1)                   TC::Output::Warning(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1)
#define TCWARNING2(MODULE, FORMAT, ARG1, ARG2)             TC::Output::Warning(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2)
#define TCWARNING3(MODULE, FORMAT, ARG1, ARG2, ARG3)       TC::Output::Warning(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2, ARG3)
#define TCWARNING4(MODULE, FORMAT, ARG1, ARG2, ARG3, ARG4) TC::Output::Warning(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2, ARG3, ARG4)
#define TCWARNINGS(MODULE, STREAM) \
    { \
    std::string val; \
    TC::StreamPtr stream(TC::Factory::CreateStringStream(val)); \
    stream << STREAM; \
    TC::Output::Warning(MODULE, _TC_FUNCTION_, __LINE__, "%s", val.c_str()); \
}

#define TCERROR(MODULE, FORMAT)                          TC::Output::Error(MODULE, _TC_FUNCTION_, __LINE__, FORMAT)
#define TCERROR1(MODULE, FORMAT, ARG1)                   TC::Output::Error(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1)
#define TCERROR2(MODULE, FORMAT, ARG1, ARG2)             TC::Output::Error(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2)
#define TCERROR3(MODULE, FORMAT, ARG1, ARG2, ARG3)       TC::Output::Error(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2, ARG3)
#define TCERROR4(MODULE, FORMAT, ARG1, ARG2, ARG3, ARG4) TC::Output::Error(MODULE, _TC_FUNCTION_, __LINE__, FORMAT, ARG1, ARG2, ARG3, ARG4)
#define TCERRORS(MODULE, STREAM) \
    { \
    std::string val; \
    TC::StreamPtr stream(TC::Factory::CreateStringStream(val)); \
    stream << STREAM; \
    TC::Output::Error(MODULE, _TC_FUNCTION_, __LINE__, "%s", val.c_str()); \
}

#endif // _TC_OUTPUT_H_