1 files changed, 145 insertions, 0 deletions

diff --git a/src/multilog.h b/src/multilog.h
new file mode 100644
index 0000000..30ad8d7
--- /dev/null
+++ b/src/multilog.h
@@ -0,0 +1,145 @@
+#ifndef MULTILOG_H
+#define MULTILOG_H
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <time.h>
+
+#include "ringlist.h"
+#include "linkedlist.h"
+
+/**
+ * Calls the DetailLog function but includes pre-processor macros to fill in
+ * most of the fields for you.  This makes your life a lot easier, and makes the
+ * log useful for system debugging as well as just letting people know what's
+ * going on.
+ *@param LEVEL The log level, comes from an enum in the MultiLog class.
+ *@param FORMAT The text to store in the log, using printf style formatting.
+ *@param ... Parameters to help format the text in the FROMAT param.
+ */
+#define LineLog( LEVEL, FORMAT, ...) DetailLog( LEVEL, __FILE__, __LINE__, __PRETTY_FUNCTION__, FORMAT, ##__VA_ARGS__ )
+
+/** MultiLog keeps track of logfile info in a myriad of varieties, and is
+  * easily configurable between them all.  It allows output to the standard
+  * output, error output, files, networks, and streams, which includes memory
+  * buffers.
+  * MultiLog uses the singleton pattern to keep only a single instance of
+  * the log.  Instead of instantiating a new copy, call the getLog method.
+  *@author Mike Buland
+  */
+class MultiLog
+{
+public:
+        /**
+         * Keeps track of a single log entry, in a standard format, that can be
+         * processed by any MultiLogChannel derrived class.
+         *@author Mike Buland
+         */
+        typedef struct LogEntry
+        {
+                /** Safely delete a log entry. */
+                ~LogEntry();
+                time_t xTime;   /**< The time the log entry was made. */
+                int nLevel;             /**< The log-level of the entry. */
+                char *lpFile;   /**< The name of the file this entry came from. */
+                int nLine;              /**< The line number that this log came from. */
+                char *lpText;   /**< The text content of this log entry. */
+        } LogEntry;
+        
+private:
+        /**
+         * Private constructor, this ensures that this is a singleton.
+         */
+        MultiLog();
+
+        /**
+         * The only instance of MultiLog ever.
+         */
+        static MultiLog *singleLog;
+
+        /**
+         * Append a new logentry to the log list, possibly pushing an old entry off.
+         *@param pEntry The new entry to append.
+         */
+        void append( LogEntry *pEntry );
+
+        /**
+         * The actual log entry storage mechanism.
+         */
+        RingList *rEntry;
+
+        /**
+         * The number of entries that have rolled off the end of the RingList.
+         */
+        unsigned long nEntriesLost;
+
+        /**
+         * A list of all channels that are registered with the MultiLog.
+         */
+        LinkedList *lChannel;
+        
+public:
+        /**
+         * Destroy the multilog.
+         *@todo Why is this public?  Does it need to be?
+         */
+        ~MultiLog();
+
+        /** Sends info to the logfile.
+          *@param nLevel The type of data being logged (error, info, etc.)
+          *@param lpFormat The data to send to the log.
+          *@author Mike Buland
+          */
+        //void Log( int nLevel, const char *lpFormat, ...);
+
+        /** Sends info to the logfile with extra information, including the files
+          * that it was called from and the line in the code.  Besides that, it's
+          * exactly the same as Log.  Please use the LineLog macro to make DetailLog
+          * really easy to use.  It operates exacly like Log, but inserts the
+          * builtin macros as the lpFile and nLine parameters.
+          *@param nLevel The type of data being logged (error, info, etc.)
+          *@param lpFile The name of the file that called the log function.
+          *@param nLine The line in the file that this log function was called from.
+          *@param lpFunction The name of the function that called the log function.
+          *@param lpFormat The data to send to the log.
+          *@author Mike Buland
+          */
+        void DetailLog( int nLevel, const char *lpFile, int nLine, const char *lpFunction, const char *lpFormat, ...);
+
+        /** Gets a pointer to the only instantion of the MultiLog that can exist.
+          * If there is no instantion in existance, it creates one, so it's
+          * foolproof.
+          *@returns A pointer to the only MultiLog instantion.
+          *@author Mike Buland
+          */
+        static MultiLog *getLog();
+
+        /** Performs standard cleanup and deletes the only instantiation of MultiLog
+          * that can exist.  This is just the same as delete and will nicely close
+          * all open logs.  always call this when you are done with your MultiLog.
+          */
+        static void cleanup();
+
+        /**
+         * Adds a logging channel to the MultiLog channel chain.  Every added
+         * channel will automatically receive a complete log of everything that
+         * happened before the channel was added as well as all future messages.
+         *@param pChannel A pointer to the pre-contructed channel object to add.
+         */
+        void addChannel( class MultiLogChannel *pChannel );
+
+        /** The various pre-defined levels available to use when logging.
+          * The person logging can make up their own, just make sure to remember
+          * which value is which (all levels are integers).
+          *@author Mike Buland
+          */
+        enum Levels
+        {
+                LError,
+                LWarning,
+                LInfo,
+                LStatus
+        };
+};
+
+#endif