---

lobtracestream.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
/*
   $Id: lobtracestream.h,v 1.5 2002/12/10 23:56:39 lbayle Exp $

   This file is part of the LobTraceStream project
   Copyright (C) 2002 Louis BAYLE <lbayle@users.sourceforge.net>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
*/
//-----------------------------------------------------------------------------

#ifndef __LOBTRACESTREAM_H__
#define __LOBTRACESTREAM_H__

#if __GNUC__>2
#include <iostream>
#include <fstream>
#include <cstring>
#else
#include <iostream.h>
#include <fstream.h>
#include <string.h>   // for strncpy
#endif
#define FILE_PATH_LENGTH   255
#define BUFFERSTRING_SIZE 1024  // LobTraceStream buffer size
#define U_MAXTOKENSIZE      30  /* string length in lexer  */
#define PREFIX_PATH_LENGTH 255  // log file prefix max length (myAPP_)
#define EXT_PATH_LENGTH     30  // log file extension max length (.log)

class LobTraceStream;
class LobTraceException;
class LobTraceProvider;
class LobTraceStreamEnd;

extern LobTraceProvider    g_lobTraceProvider; // global, used by trace macros
extern LobTraceStreamEnd   lt_endl;            // global, flush trigger
extern LobTraceStream&     g_lobTraceStream;   // global, used by trace macros

#ifdef LOBTRACE_QT
class LobTraceStreamQt;
#define G_LTS_INSTANCE ((LobTraceStreamQt&)g_lobTraceStream)
#else
#define G_LTS_INSTANCE g_lobTraceStream
#endif

//========================================================================

/* CUSTO Defines module identification constants used for tracing */
#define U_MOD_GENERAL     0  // mandatory, used by LobTrace
#define U_MOD_UTILS       1  // mandatory, used by LobTrace

#define U_MOD_COUNT 2        /* CUSTO number of modules in current project */


/* Configuration parameters for the trace facility */

/* Severity of the traces constants */
#define U_TRA_EXCEPTION 0    /* for Exceptions*/
#define U_TRA_CRITICAL  1    /* for fatal errors */
#define U_TRA_ERROR     2    /* for other errors */
#define U_TRA_WARNING   3    /* for warning messages */
#define U_TRA_TRACE     4    /* for normal operating messages */
#define U_TRA_DEBUG     5    /* for debugging messages */
#define U_TRA_INOUT     6    /* use LOB_TRA_ENTRY and LOB_TRA_RETURN !
                                -> logs enter/exit from functions */

#define U_TRA_COUNT     7             /* number of trace levels */

// \todo find a better way, see LOB_EXCEPTION2 macro
#define LOBEX_BADVALUE LobTraceException::bad_value

//========================================================================
#define LOB_TRACE_INIT(confFilename, logPrefix)\
            g_lobTraceProvider.initialize(confFilename, logPrefix);

#define LOB_TRACE(module, level)\
            g_lobTraceStream.setContextInfo(U_MOD_##module, U_TRA_##level, __FILE__, __LINE__);\
            G_LTS_INSTANCE  // here, concat the msg << "toto" << 123 << lt_endl;

#define LOB_TRACE_ENTRY(module, funcname)\
            g_lobTraceStream.setContextInfo(U_MOD_##module, U_TRA_INOUT, __FILE__, __LINE__);\
            g_lobTraceStream  << "FUNCTION Enter : " << funcname << lt_endl;

#define LOB_TRACE_RETURN(module, funcname, retcode)\
            g_lobTraceStream.setContextInfo(U_MOD_##module, U_TRA_INOUT, __FILE__, __LINE__);\
            g_lobTraceStream  << "FUNCTION Exit  : " << funcname << " [RetCode = " << retcode << "]" << lt_endl;

#define LOB_EXCEPTION(type, msg) throw LobTraceException(g_lobTraceStream, __FILE__, __LINE__, type, msg);

#define LOB_EXCEPTION2(type, msg) throw LobTraceException(g_lobTraceStream, __FILE__, __LINE__, LobTraceException:##:##type, msg);

// \todo add assertion macro(s)
/*#define LOB_ASSERT(expression)\
            if (false == (expression)) {  }
*/

//========================================================================
// Macros to use non-default traceStream & provider
#define LOB_TRACE_INIT_MT(provider, confFilename, logPrefix)\
            provider.initialize(confFilename, logPrefix);

#define LOB_TRACE_MT(lobstream, module, level)\
            lobstream.setContextInfo(U_MOD_##module, U_TRA_##level, __FILE__, __LINE__);\
            lobstream  // here, concat the msg << "toto" << 123 << lt_endl;

#define LOB_TRACE_ENTRY_MT(lobstream, module, funcname)\
            lobstream.setContextInfo(U_MOD_##module, U_TRA_INOUT, __FILE__, __LINE__);\
            lobstream << "FUNCTION Enter : " << funcname << lt_endl;


#define LOB_TRACE_RETURN_MT(lobstream, module, funcname, retcode)\
            lobstream.setContextInfo(U_MOD_##module, U_TRA_INOUT, __FILE__, __LINE__);\
            lobstream << "FUNCTION Exit  : " << funcname << " [RetCode = " << retcode << "]" << lt_endl;

#define LOB_EXCEPTION_MT(lobstream, type, msg) throw LobTraceException(lobstream, __FILE__, __LINE__, type, msg);
#define LOB_EXCEPTION_MT2(lobstream, type, msg) throw LobTraceException(lobstream, __FILE__, __LINE__, LobTraceException:##:##type, msg);

//========================================================================
class LobTraceProvider
{
  public:
    enum traceLevels { InOut = 0, Debug, Trace, Warning, Error, Critical, Exception};

  private:
    bool      m_isInitialized;  
    ostream   *m_pOutputStream; 
    ofstream  m_traceFile;                         
    ifstream  m_confFile;                          
    char      m_logDir[FILE_PATH_LENGTH];     
    char      m_confFilename[FILE_PATH_LENGTH];    
    int       m_logFileMaxLines;                   
    int       m_logFileNbLines;              
    char      m_logFilePrefix[PREFIX_PATH_LENGTH]; 
    char      m_logFileExt[EXT_PATH_LENGTH]; 
    char      m_logFilename[FILE_PATH_LENGTH];   
    bool      m_isXmlTrace;     

    typedef struct
    {
       char modName[U_MAXTOKENSIZE];
       int  traceLevel;
    } modDef_t;

    static const char* m_levelLabels[7]; // initialization in .cpp
    static const char* LobTraceProvider::monthName[12];

    modDef_t m_moduleDefs[U_MOD_COUNT];

  public:
    LobTraceProvider();
    virtual ~LobTraceProvider();

    void initialize(const char * confFilename,
                    const char * logFilePrefix);

    virtual void onTrace( LobTraceStream& param );

    void setModuleTraceLevel(int moduleId, int level);

    bool isTraced(int module, int level);
    bool isTraced(int module, traceLevels level);

    const char * getLogFilename() { return m_logFilename; }
    const bool isXmlTrace()       { return m_isXmlTrace; }

    virtual void dump( );

    friend ostream & operator<< (ostream& os, LobTraceProvider& ltp)
    {
       os << "LobTraceProvider Instance (" << &ltp << ") tracing to : " << ltp.m_logFilename;
       return os;
    }

  private:

    typedef struct _v {
       char name[U_MAXTOKENSIZE];
       char value[U_MAXTOKENSIZE];
       struct _v *next;
    } variable_t;

    enum lexertokenType { lex_error = 0, lex_variable, lex_equal, lex_value };

    virtual void getFormatedTime(char *buffer);

    int  setVariables(variable_t *myVars);
    int  readConfFile(variable_t **tVarList);
    int  confFileLexer(char* szToken, lexertokenType *iType);

  private:
    // theese members are used by confFileLexer() when parsing the
    // configuration file. they are declared here for reentrance purpose.
    char m_nextChar;       /* char belong to the next token */
    bool m_isNextChar; /* true if next char has already been readen*/
    int  m_lexState;
};

//========================================================================
class  LobTraceStreamEnd {};

//========================================================================
class LobTraceStream
{
  protected:
    char  m_bufferString[BUFFERSTRING_SIZE];
    LobTraceProvider *m_pTraceProvider;

  private:
    char* m_pbuffer;

   struct {
      int  module;
      int  level;
      char file[FILE_PATH_LENGTH];
      int  line;
   } m_contextInfo;



  public:
    LobTraceStream(LobTraceProvider *tp = &g_lobTraceProvider);

    const char* getTraceOutput()   { return m_bufferString; }
    bool        getXmlTraceOutput(const char* srcString, char* xmlString, const int len);
    int         getContextModule() { return m_contextInfo.module; }
    int         getContextLevel()  { return m_contextInfo.level; }
    int         getContextLine()   { return m_contextInfo.line; }
    const char* getContextFile()   { return m_contextInfo.file; }
    LobTraceProvider * getTraceProvider() { return m_pTraceProvider; }

    // =====

    void        setContextInfo(int module, int level, const char* file, int line);
    void        setTraceProvider(LobTraceProvider *tp);

    LobTraceStream& operator<< ( const int&    param );
    LobTraceStream& operator<< ( const char*   param );
    LobTraceStream& operator<< ( const double& param );

    LobTraceStream& operator<< ( LobTraceStreamEnd& param );

    void traceException(int type = 0, const char* msg = NULL);

    virtual void dump( );

    friend ostream & operator<< (ostream& os, LobTraceStream& lts)
    {
       os << "LobTraceStream   Instance (" << &lts << ") sending to LobTraceProvider : " << lts.m_pTraceProvider;
       return os;
    }
};


//========================================================================
class LobTraceException
{
  protected:

    const char* m_msg;
    const char* m_file;
    int         m_line;
    int         m_type;

  public:

    enum lte_type { unknown =0, file_io, memory, bad_value, overflow};

    LobTraceException(LobTraceStream& lts = g_lobTraceStream,
                      const char* file = NULL, int line = -1,
                      lte_type type = unknown, const char* msg = NULL)
    {
       m_type = type;
       m_msg  = msg;
       m_file = file;
       m_line = line;

       lts.setContextInfo(U_MOD_GENERAL,U_TRA_EXCEPTION, file, line);
       lts.traceException(type, msg);
    }

    int         getLine()    { return m_line; }
    const char* getFile()    { return m_file; }
    int         getType()    { return m_type; }
    const char* getMessage() { return m_msg;  }
};




#endif // __LOBTRACE_H__


//========================================================================

---