Logger.hpp

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_HPP
#define LOGGER_HPP

// For FILE* 
#include <cstdio>
#include <cstdarg> // for va_list
#include <string>

#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 */

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

class DECLSPEC Logger
{
public:
        
        Logger();

        bool Init();

        bool Init(const std::string& base_name);

        bool Init(FILE* file_handle, const std::string& base_name);

        ~Logger();

        void Close();

        inline static LoggerVersion GetCompiledVersion()
        {
                LoggerVersion ver;
                ver.major = LOGGER_MAJOR_VERSION;
                ver.minor = LOGGER_MINOR_VERSION;
                ver.patch = LOGGER_PATCH_VERSION;
                return ver;
        }

        static LoggerVersion GetLinkedVersion();

        static bool IsCompiledWithLocking();
                
        int LogEvent(unsigned int priority, 
                const char* keyword, const char* subkeyword,
                const char* text, ...);

        int LogEventv(unsigned int priority, 
                const char* keyword, const char* subkeyword,
                const char* text, va_list argp); 

        int LogEventNoFormat(unsigned int priority, 
                const char* keyword, const char* subkeyword,
                const char* text);

        void Enable();

        void Disable();

        bool IsEnabled() const;

        void Flush();

        void EnableAutoFlush();

        void DisableAutoFlush();

        bool IsAutoFlushEnabled() const;

        void SetThresholdPriority(unsigned int thresh_val);

        unsigned int GetThresholdPriority() const;

        void SetDefaultPriority(unsigned int pri_level);

        unsigned int GetDefaultPriority() const;

        void SetMinSegmentSize(unsigned int num_bytes);

        unsigned int GetMinSegmentSize() const;

        void EchoOn();

        void EchoOff();

        bool IsEchoOn() const;

        void SetEchoToStdout();

        void SetEchoToStderr();

        /* 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.
         */
           
        void SetPreLines(unsigned int pre_lines);

        void SetPostLines(unsigned int post_lines);

        void SetNewLines(unsigned int pre_lines, unsigned int post_lines);

        unsigned int GetPreLines() const;

        unsigned int GetPostLines() const;

        bool WillLog(unsigned int which_priority) const;

        /*
         * Sets the format string that is used to create the segment file 
         * extensions.
         * When segmentation occurs, a new file must be created. The scheme is 
         * to take the base file name and append a numeric value represening the 
         * current segment number (starting with 0). 
         * 
         * The default format is ".%04d".
         * 
         * This will produce files like 
         * Mylog.log, Mylog.log.0000, Mylog.log.0001, etc.
         * 
         * Notice that the period is specified in that format string, so if you 
         * want something else in the segment, you may specify it.
         * 
         * You must have a %d somewhere in the format string. The underlying
         * implementation uses a snprintf(target, fmtstr, seg_number, maxsize),
         * so an integer will try to be inserted into the string.
         * 
         * You should also never change the format string after LogEvent* has 
         * been called, (i.e. don't change the file name schemes after segmentation 
         * may have begun). While this may actually work, it's not something that
         * was really thought about and won't be supported.
         *
         * In general, you should be very careful when using this function.
         *
         * This function will make it's own internal copy of the string you
         * pass in, so you may do what you want with your string after this call.
         *
         * @param format_string The format string 
         * (the kind used in the printf family).
         * NULL will reset the logger instance to use the default format.
         *
         */
        //void SetSegmentFormatString(const std::string& format_string);

        void SetSegmentMinWidth(unsigned int width);

        unsigned int GetSegmentMinWidth() const;

private:

        bool OpenFile(const std::string& filename);
        bool CloseFile();
        bool SegmentFile();

        int PrintHeaderToFileHandle(FILE* file_handle, 
                unsigned int pre_new_lines,
                unsigned int priority,
                const char* time_stamp, 
                const char* keyword, 
                const char* subkeyword);

        int PrintFooterToFileHandle(FILE* file_handle, 
                unsigned int post_new_lines,
                bool auto_flush_enabled);

        
        std::string baseName; 
//      size_t baseNameMaxSize; /**< Max size of baseName with \\0. */
        
        FILE* fileHandle; 
        FILE* echoHandle; 
        unsigned int thresholdPriority; 
        unsigned int defaultPriority; 
        bool echoOn; 
        bool loggingEnabled; 
        bool autoFlushEnabled; 
        unsigned int preNewLines; 
        unsigned int postNewLines; 
        unsigned int segmentNumber; 
        unsigned int currentByteCount; 
        unsigned int minSegmentBytes; 
//      std::string segmentFormatString; /**< Format str for ext like ".%04d". */
//      size_t segmentFormatStringMaxSize; /**< Max size of the fmtstr with \\0. */     

        unsigned int segmentMinWidth; 
#ifdef LOGGER_ENABLE_LOCKING

        mutable void* loggerMutex;
#endif
};

extern Logger g_logger;



#endif // LOGGER_HPP