Logger.h

Go to the documentation of this file.

/*
        Logger
        Copyright (C) 2002, 2010  Eric Wing <ewing . public @ playcontrol.net>

        Permission is hereby granted, free of charge, to any person obtaining a copy
        of this software and associated documentation files (the "Software"), to deal
        in the Software without restriction, including without limitation the rights
        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        copies of the Software, and to permit persons to whom the Software is
        furnished to do so, subject to the following conditions:

        The above copyright notice and this permission notice shall be included in
        all copies or substantial portions of the Software.

        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        THE SOFTWARE.

*/

#ifndef LOGGER_H
#define LOGGER_H

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h> /* For FILE* */
#include <stdarg.h> /* for va_list */

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

/* Note: For Doxygen to produce clean output, you should set the 
 * PREDEFINED option to remove DECLSPEC, CALLCONVENTION, and
 * the DOXYGEN_SHOULD_IGNORE_THIS blocks.
 * PREDEFINED = DOXYGEN_SHOULD_IGNORE_THIS=1 DECLSPEC= CALLCONVENTION=
 */

#ifdef WIN32
        #define DECLSPEC __declspec(dllexport)
#else
        #define DECLSPEC
#endif

/* For Windows, by default, use the C calling convention */
#ifndef CALLCONVENTION
        #ifdef WIN32
                #define CALLCONVENTION __cdecl
        #else
                #define CALLCONVENTION
        #endif
#endif /* CALLCONVENTION */
        
/* Version number is set here.
 * Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
 */
#define LOGGER_MAJOR_VERSION            0
#define LOGGER_MINOR_VERSION            1
#define LOGGER_PATCH_VERSION            0

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

typedef struct
{
        int major; 
        int minor; 
        int patch; 
} LoggerVersion;


#define LOGGER_GET_COMPILED_VERSION(X)          \
{                                                                                       \
        if(NULL != (X))                                                 \
        {                                                                               \
                (X)->major = LOGGER_MAJOR_VERSION;      \
                (X)->minor = LOGGER_MINOR_VERSION;      \
                (X)->patch = LOGGER_PATCH_VERSION;      \
        }                                                                               \
}

extern DECLSPEC void CALLCONVENTION Logger_GetLinkedVersion(LoggerVersion* ver);

extern DECLSPEC int CALLCONVENTION Logger_IsCompiledWithLocking();

typedef struct
{
        char* baseName; 
        size_t baseNameMaxSize; 
        FILE* fileHandle; 
        FILE* echoHandle; 
        unsigned int thresholdPriority; 
        unsigned int defaultPriority; 
        int echoOn; 
        int loggingEnabled; 
        int autoFlushEnabled; 
        unsigned int preNewLines; 
        unsigned int postNewLines; 
        unsigned int segmentNumber; 
        unsigned int currentByteCount; 
        unsigned int minSegmentBytes; 
        char* segmentFormatString; 
        size_t segmentFormatStringMaxSize; 
        void* opaqueLoggerData; 
        
} Logger;

extern DECLSPEC Logger* CALLCONVENTION Logger_Create();

extern DECLSPEC Logger* CALLCONVENTION Logger_CreateWithName(const char* base_name);

extern DECLSPEC Logger* CALLCONVENTION Logger_CreateWithHandle(
        FILE* file_handle,
        const char* base_name);

extern DECLSPEC void CALLCONVENTION Logger_Free(Logger* logger);


extern DECLSPEC int CALLCONVENTION Logger_SetHandle(
        Logger* logger,
        FILE* file_handle,
        const char* base_name);
        
extern DECLSPEC int CALLCONVENTION Logger_LogEvent(
        Logger* logger,
        unsigned int priority,
        const char* keyword, const char* subkeyword,
        const char* text, ...);

extern DECLSPEC int CALLCONVENTION Logger_LogEventv(
        Logger* logger, 
        unsigned int priority,
        const char* keyword, const char* subkeyword,
        const char* text, va_list argp); 

extern DECLSPEC int CALLCONVENTION Logger_LogEventNoFormat(
        Logger* logger,
        unsigned int priority,
        const char* keyword, const char* subkeyword,
        const char* text);

extern DECLSPEC void CALLCONVENTION Logger_Enable(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_Disable(Logger* logger);

extern DECLSPEC int CALLCONVENTION Logger_IsEnabled(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_Flush(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_EnableAutoFlush(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_DisableAutoFlush(Logger* logger);

extern DECLSPEC int CALLCONVENTION Logger_IsAutoFlushEnabled(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_SetThresholdPriority(Logger* logger, unsigned int thresh_val);

extern DECLSPEC unsigned int CALLCONVENTION Logger_GetThresholdPriority(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_SetDefaultPriority(Logger* logger, unsigned int pri_level);

extern DECLSPEC unsigned int CALLCONVENTION Logger_GetDefaultPriority(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_SetMinSegmentSize(Logger* logger, unsigned int num_bytes);

extern DECLSPEC unsigned int CALLCONVENTION Logger_GetMinSegmentSize(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_EchoOn(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_EchoOff(Logger* logger);

extern DECLSPEC int CALLCONVENTION Logger_IsEchoOn(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_SetEchoToStdout(Logger* logger);

extern DECLSPEC void CALLCONVENTION Logger_SetEchoToStderr(Logger* logger);

/* Note: Future enhancements might include a customizable
 * echo handle. For now, this can be achieved through the backdoor
 * by altering the Logger struct echo handle directly, but 
 * this is unsupported. Keep in mind that echo handles will not
 * be segmented.
 */
   
extern DECLSPEC void CALLCONVENTION Logger_SetPreLines(Logger* logger, unsigned int pre_lines);

extern DECLSPEC void CALLCONVENTION Logger_SetPostLines(Logger* logger, unsigned int post_lines);

extern DECLSPEC void CALLCONVENTION Logger_SetNewLines(Logger* logger, unsigned int pre_lines, unsigned int post_lines);

extern DECLSPEC unsigned int CALLCONVENTION Logger_GetPreLines(Logger* logger);

extern DECLSPEC unsigned int CALLCONVENTION Logger_GetPostLines(Logger* logger);


extern DECLSPEC int CALLCONVENTION Logger_WillLog(Logger* logger, unsigned int which_priority);


extern DECLSPEC void CALLCONVENTION Logger_SetSegmentFormatString(Logger* logger, const char* format_string);


extern Logger* g_logger;



#ifdef __cplusplus
}
#endif
#endif /* LOGGER_H */