---

lTrace.cpp

Go to the documentation of this file.

/******************************************************************************/
/*                                                                            */
/* POLiTe - Persistent Object Library Test                                    */
/*                                        Ph.D. Thesis by Mgr. Michal Kopecky */
/*                                                                            */
/* Charles University Prague                                                  */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* File name: ...                                                             */
/* Module: ......                                                             */
/*                                                                            */
/******************************************************************************/

// Common POLiTe Header(s)
#include <lDefs.h>

// INCLUDE OWN HEADER
#include <lTrace.h>

#ifdef POLITE_TRACE

class LogWriter POLiTeLogWriter;

int LogWriter::count = 0;
FILE *LogWriter::stdlog = NULL;

LogWriter::LogWriter()
// opens standard log file
{
        TraceMask = POLITE_TRACE_MASK;
        TraceMaskTTY = POLITE_TRACE_MASK_TTY;
        if (stdlog == NULL) {
                if ((stdlog = fopen(POLITE_TRACE_FILE, "w")) != NULL)
                {
                        logmsg("POLiTe Tracing enabled");
                        return;
                };
        }
        count++;
};

LogWriter::~LogWriter()
// closes standard log file
{
        if (!--count)
        {
                logmsg("POLiTe Tracing disabled");
                if (stdlog)
                        (void)fclose(stdlog);
                stdlog = NULL;
        };
};

int logmsg(const int mask, const char *message)
// writes to a standard log file
{
        if (mask & POLiTeLogWriter.TraceMaskTTY)
                fprintf(stdout, "log message: %s\n", message);
        if ((mask & POLiTeLogWriter.TraceMask) && (LogWriter::stdlog != NULL))
                return(fprintf(LogWriter::stdlog, "log message: %s\n", message));
        else
                return(0);
};

int logmsg(const char *message)
// writes to a standard log file
{
        return logmsg(TL_INFO,message);
 };

int logmsg(const int mask, const char *format, const char *message)
// writes to a standard log file
{
        if (mask & POLiTeLogWriter.TraceMaskTTY) {
                fprintf(stdout, "log message: ", message);
                fprintf(stdout, format, message);
                fprintf(stdout, "\n");
                };
        if ((mask & POLiTeLogWriter.TraceMask) && (LogWriter::stdlog != NULL))
                return(
                        fprintf(LogWriter::stdlog, "log message: ", message)
                        + fprintf(LogWriter::stdlog, format, message)
                        + fprintf(LogWriter::stdlog, "\n")
                        );
        else
                return(0);
};

int logmsg(const char *format, const char *message)
// writes to a standard log file
{
        return logmsg(TL_INFO,format,message);
};

int logmsg(const int mask, const char *format, const long int message)
// writes to a standard log file
{
        if (mask & POLiTeLogWriter.TraceMaskTTY) {
                fprintf(stdout, "log message: ");
                fprintf(stdout, format, message);
                fprintf(stdout, "\n");
        };
        if ((mask & POLiTeLogWriter.TraceMask) && (LogWriter::stdlog != NULL))
                return(
                        fprintf(LogWriter::stdlog, "log message: ")
                        + fprintf(LogWriter::stdlog, format, message)
                        + fprintf(LogWriter::stdlog, "\n")
                        );
        else
                return(0);
};

int logmsg(const char *format, const long int message)
// writes to a standard log file
{
        return logmsg(TL_INFO,format,message);
};

char *msg(const enum UpdatingStrategy anUpdatingStrategy)
// convertst enum UpdatingStrategy to a string
{
        switch (anUpdatingStrategy) {
                case US_OnDemand:    return("US_OnDemand");
                case US_Immediately: return("US_Immediately");
                default:             return("unknown");
        };
};

char *msg(const enum LockingStrategy aLockingStrategy)
// convertst enum LockingStrategy to a string
{
        switch (aLockingStrategy) {
                case LS_None: return ("LS_None");
                case LS_Shared: return ("LS_Shared");
                case LS_Exclusive: return ("LS_Exclusive");
                default:           return ("LS_unknown");
        };
};

char *msg(const enum WaitingStrategy aWaitingStrategy)
// convertst enum WaitingStrategy to a string
{
        switch (aWaitingStrategy) {
                case WS_Nowait:  return("WS_Nowait");
                case WS_Wait:   return("WS_Wait");
                default:        return("WS_unknown");
        };
}

char *msg(const enum ReadingStrategy anUpdatingStrategy)
// convertst enum ReadingStrategy to a string
{
        switch (anUpdatingStrategy) {
                case RS_Cache:    return("RS_Cache");
                case RS_Database: return("RS_Database");
                case RS_Timestamp: return("RS_Timestamp");
                default:             return("unknown");
        };
};

#endif //POLITE_TRACE

---