(file) Return to Logger.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Logger.cpp between version 1.2 and 1.44

version 1.2, 2001/04/25 22:20:55 version 1.44, 2006/10/13 18:04:49
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
   //
   // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // 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:
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 // copy of this software and associated documentation files (the "Software"),  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 // to deal in the Software without restriction, including without limitation  // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 // and/or sell copies of the Software, and to permit persons to whom the  // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 // Software is furnished to do so, subject to the following conditions:  // 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
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // 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.  
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Sushma Fernandes (Hewlett-Packard Company)
   //              sushma_fernandes@hp.com
   // Modified By: Dave Rosckes (IBM)
   //              rosckes@us.ibm.com
   //              Amit K Arora, IBM (amita@in.ibm.com) for PEP101
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <iostream> #include <iostream>
 #include <fstream> #include <fstream>
   #include <cstring>
 #include "Logger.h" #include "Logger.h"
   #include "System.h"
   #include <Pegasus/Common/MessageLoader.h> //l10n
  
 using namespace std;  PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   
 const Uint32 Logger::TRACE = (1 << 0); const Uint32 Logger::TRACE = (1 << 0);
 const Uint32 Logger::INFORMATIVE = (1 << 1);  const Uint32 Logger::INFORMATION = (1 << 1);
 const Uint32 Logger::WARNING = (1 << 2); const Uint32 Logger::WARNING = (1 << 2);
 const Uint32 Logger::SEVERE = (1 << 3); const Uint32 Logger::SEVERE = (1 << 3);
 const Uint32 Logger::FATAL = (1 << 4); const Uint32 Logger::FATAL = (1 << 4);
  
   static char const* LOGLEVEL_LIST[] =
   {
       "TRACE",
       "INFORMATION",
       "WARNING",
       "SEVERE",
       "FATAL"
   };
   
 LoggerRep* Logger::_rep = 0; LoggerRep* Logger::_rep = 0;
 String Logger::_homeDirectory = "."; String Logger::_homeDirectory = ".";
  
 static char* _allocLogFileName(  const Uint32 Logger::_NUM_LOGLEVEL = 5;
   
   // Set separator
   const char Logger::_SEPARATOR = '@';
   
   Uint32 Logger::_severityMask;
   
   Uint32 Logger::_writeControlMask = 0xF;   // Set all on by default
   
   // Set the return codes
   const Boolean Logger::_SUCCESS = 1;
   const Boolean Logger::_FAILURE = 0;
   
   /* _allocLogFileName. Allocates the name from a name set.
       Today this is static.  However, it should be completely
       configerable and driven from the config file so that
       Log organization and names are open.
       ATTN: rewrite this so that names, choice to do logs and
       mask for level of severity are all driven from configuration
       input.
   */
   static CString _allocLogFileName(
     const String& homeDirectory,     const String& homeDirectory,
     Logger::LogFileType logFileType)     Logger::LogFileType logFileType)
 { {
     static char* fileNames[] =      static const char* fileNames[] =
     {     {
         "trace.log",          "PegasusTrace.log",
         "standard.log",          "PegasusStandard.log",
         "error.log"          "PegasusError.log",
           "PegasusDebug.log"
     };     };
  
     int index = int(logFileType);     int index = int(logFileType);
Line 62 
Line 109 
     const char* logFileName = fileNames[index];     const char* logFileName = fileNames[index];
  
     String result;     String result;
     result.reserve(homeDirectory.getLength() + 1 + strlen(logFileName));      result.reserveCapacity(homeDirectory.size() + 1 + strlen(logFileName));
     result += homeDirectory;      result.append(homeDirectory);
     result += '/';      result.append('/');
     result += logFileName;      result.append(logFileName);
     return result.allocateCString();      return result.getCString();
 } }
  
 class LoggerRep class LoggerRep
Line 75 
Line 122 
  
     LoggerRep(const String& homeDirectory)     LoggerRep(const String& homeDirectory)
     {     {
         char* fileName = _allocLogFileName(homeDirectory, Logger::TRACE_LOG);  #if !defined(PEGASUS_USE_SYSLOGS)
           // Add test for home directory set.
   
           // If home directory does not exist, create it.
           CString lgDir = homeDirectory.getCString();
   
           if (!System::isDirectory(lgDir))
               System::makeDirectory(lgDir);
   
           // KS: I put the second test in just in case some trys to create
           // a completly erronous directory.  At least we will get a message
           if (!System::isDirectory(lgDir)){
              //l10n
              //cerr << "Logging Disabled";
              MessageLoaderParms parms("Common.Logger.LOGGING_DISABLED",
                  "Logging Disabled");
   
              cerr << MessageLoader::getMessage(parms);
           }
   
           CString fileName = _allocLogFileName(homeDirectory, Logger::TRACE_LOG);
         _logs[Logger::TRACE_LOG].open(fileName, ios::app);         _logs[Logger::TRACE_LOG].open(fileName, ios::app);
         delete [] fileName;  
  
         fileName = _allocLogFileName(homeDirectory, Logger::STANDARD_LOG);         fileName = _allocLogFileName(homeDirectory, Logger::STANDARD_LOG);
         _logs[Logger::STANDARD_LOG].open(fileName, ios::app);         _logs[Logger::STANDARD_LOG].open(fileName, ios::app);
         delete [] fileName;  
  
         fileName = _allocLogFileName(homeDirectory, Logger::ERROR_LOG);         fileName = _allocLogFileName(homeDirectory, Logger::ERROR_LOG);
         _logs[Logger::ERROR_LOG].open(fileName, ios::app);         _logs[Logger::ERROR_LOG].open(fileName, ios::app);
         delete [] fileName;  
           fileName = _allocLogFileName(homeDirectory, Logger::DEBUG_LOG);
           _logs[Logger::DEBUG_LOG].open(fileName, ios::app);
   #endif
   
     }     }
  
     ostream& logOf(Logger::LogFileType logFileType)     ostream& logOf(Logger::LogFileType logFileType)
     {     {
         int index = int(logFileType);         int index = int(logFileType);
  
         if (index > int(Logger::ERROR_LOG))          if (index > int(Logger::NUM_LOGS))
             index = Logger::ERROR_LOG;             index = Logger::ERROR_LOG;
  
         return _logs[index];         return _logs[index];
Line 103 
Line 172 
     ofstream _logs[int(Logger::NUM_LOGS)];     ofstream _logs[int(Logger::NUM_LOGS)];
 }; };
  
 void Logger::put(  void Logger::_putInternal(
     LogFileType logFileType,     LogFileType logFileType,
     const String& systemId,     const String& systemId,
     Uint32 level,      const Uint32 logComponent, // TODO: Support logComponent mask in future release
       Uint32 logLevel,
     const String& formatString,     const String& formatString,
       const String& messageId,  // l10n
     const Formatter::Arg& arg0,     const Formatter::Arg& arg0,
     const Formatter::Arg& arg1,     const Formatter::Arg& arg1,
     const Formatter::Arg& arg2,     const Formatter::Arg& arg2,
Line 119 
Line 190 
     const Formatter::Arg& arg8,     const Formatter::Arg& arg8,
     const Formatter::Arg& arg9)     const Formatter::Arg& arg9)
 { {
       // Test for logLevel against severity mask to determine
       // if we write this log.
       if ((_severityMask & logLevel) != 0)
       {
     if (!_rep)     if (!_rep)
         _rep = new LoggerRep(_homeDirectory);         _rep = new LoggerRep(_homeDirectory);
  
     _rep->logOf(logFileType) << Formatter::format(formatString,          // Get the logLevel String
         arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) << endl;          // This converts bitmap to string based on highest order
           // bit set
           // ATTN: KS Fix this more efficiently.
           static const char* svNames[] =
           {
               "TRACE   ",
               "INFO    ",
               "WARNING ",
               "SEVERE  ",
               "FATAL   "
           };
           // NUM_LEVELS = 5
           int sizeSvNames = sizeof(svNames) / sizeof(svNames[0]) - 1;
   
   // l10n start
           // The localized message to be sent to the system log.
           String localizedMsg;
   
           // If the caller specified a messageId, then load the localized
           // message in the locale of the server process.
           if (messageId != String::EMPTY)
           {
               // A message ID was specified.  Use the MessageLoader.
               MessageLoaderParms msgParms(messageId, formatString);
               msgParms.useProcessLocale = true;
               msgParms.arg0 = arg0;
               msgParms.arg1 = arg1;
               msgParms.arg2 = arg2;
               msgParms.arg3 = arg3;
               msgParms.arg4 = arg4;
               msgParms.arg5 = arg5;
               msgParms.arg6 = arg6;
               msgParms.arg7 = arg7;
               msgParms.arg8 = arg8;
               msgParms.arg9 = arg9;
   
               localizedMsg = MessageLoader::getMessage(msgParms);
           }
           else
           {  // No message ID.  Use the Pegasus formatter
                 localizedMsg = Formatter::format(formatString,
                   arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
           }
   // l10n end
   
   #if defined(PEGASUS_USE_SYSLOGS)
   
           // Log the message
           System::syslog(systemId, logLevel, localizedMsg.getCString());
   
   #else
   
           // Prepend the systemId to the incoming message
           String messageString(systemId);
           messageString.append(": ");
           messageString.append(localizedMsg);  // l10n
   
           const char* tmp = "";
           if (logLevel & Logger::TRACE) tmp =       "TRACE   ";
           if (logLevel & Logger::INFORMATION) tmp = "INFO    ";
           if (logLevel & Logger::WARNING) tmp =     "WARNING ";
           if (logLevel & Logger::SEVERE) tmp =      "SEVERE  ";
           if (logLevel & Logger::FATAL) tmp =       "FATAL   ";
   
           _rep->logOf(logFileType) << System::getCurrentASCIITime()
              << " " << tmp << (const char *)messageString.getCString() << endl;
   
   #endif
       }
   }
   
   ////////////////////////////////////////////////////////////////////////////////
   //
   // Public methods start here:
   //
   ////////////////////////////////////////////////////////////////////////////////
   
   void Logger::put(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2,
       const Formatter::Arg& arg3,
       const Formatter::Arg& arg4,
       const Formatter::Arg& arg5,
       const Formatter::Arg& arg6,
       const Formatter::Arg& arg7,
       const Formatter::Arg& arg8,
       const Formatter::Arg& arg9)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, String::EMPTY, arg0, arg1, arg2, arg3,
               arg4, arg5, arg6, arg7, arg8, arg9);
       }
   }
   
   void Logger::put(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& formatString)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, String::EMPTY);
       }
   }
   
   void Logger::put(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& formatString,
       const Formatter::Arg& arg0)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, String::EMPTY, arg0);
       }
   }
   
   void Logger::put(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, String::EMPTY, arg0, arg1);
       }
   }
   
   void Logger::put(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, String::EMPTY, arg0, arg1, arg2);
       }
   }
   
   void Logger::put_l(
       LogFileType logFileType,
       const String& systemId,
       Uint32 logLevel,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2,
       const Formatter::Arg& arg3,
       const Formatter::Arg& arg4,
       const Formatter::Arg& arg5,
       const Formatter::Arg& arg6,
       const Formatter::Arg& arg7,
       const Formatter::Arg& arg8,
       const Formatter::Arg& arg9)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, messageId, arg0, arg1, arg2, arg3, arg4, arg5,
               arg6, arg7, arg8, arg9);
       }
   }
   
   void Logger::put_l(
        LogFileType logFileType,
        const String& systemId,
        Uint32 logLevel,
        const String& messageId,
        const String& formatString)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
           formatString, messageId);
       }
   }
   
   void Logger::put_l(
        LogFileType logFileType,
        const String& systemId,
        Uint32 logLevel,
        const String& messageId,
        const String& formatString,
        const Formatter::Arg& arg0)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, messageId, arg0);
       }
   }
   
   void Logger::put_l(
        LogFileType logFileType,
        const String& systemId,
        Uint32 logLevel,
        const String& messageId,
        const String& formatString,
        const Formatter::Arg& arg0,
        const Formatter::Arg& arg1)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, messageId, arg0, arg1);
       }
   }
   
   void Logger::put_l(
        LogFileType logFileType,
        const String& systemId,
        Uint32 logLevel,
        const String& messageId,
        const String& formatString,
        const Formatter::Arg& arg0,
        const Formatter::Arg& arg1,
        const Formatter::Arg& arg2)
   {
       if (wouldLog(logLevel))
       {
           Logger::_putInternal(logFileType, systemId, 0, logLevel,
               formatString, messageId, arg0, arg1, arg2);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2,
       const Formatter::Arg& arg3,
       const Formatter::Arg& arg4,
       const Formatter::Arg& arg5,
       const Formatter::Arg& arg6,
       const Formatter::Arg& arg7,
       const Formatter::Arg& arg8,
       const Formatter::Arg& arg9)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY, arg0, arg1, arg2, arg3, arg4, arg5,
               arg6, arg7, arg8, arg9);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString,
       const Formatter::Arg& arg0)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY, arg0);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY, arg0, arg1);
       }
   }
   
   void Logger::trace(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, String::EMPTY, arg0, arg1, arg2);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2,
       const Formatter::Arg& arg3,
       const Formatter::Arg& arg4,
       const Formatter::Arg& arg5,
       const Formatter::Arg& arg6,
       const Formatter::Arg& arg7,
       const Formatter::Arg& arg8,
       const Formatter::Arg& arg9)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId, arg0, arg1, arg2, arg3, arg4, arg5, arg6,
               arg7, arg8, arg9);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId, arg0);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId, arg0, arg1);
       }
   }
   
   void Logger::trace_l(
       LogFileType logFileType,
       const String& systemId,
       const Uint32 logComponent,
       const String& messageId,
       const String& formatString,
       const Formatter::Arg& arg0,
       const Formatter::Arg& arg1,
       const Formatter::Arg& arg2)
   {
       if (wouldLog(Logger::TRACE))
       {
           Logger::_putInternal(logFileType, systemId, logComponent, Logger::TRACE,
               formatString, messageId, arg0, arg1, arg2);
       }
 } }
  
 void Logger::setHomeDirectory(const String& homeDirectory) void Logger::setHomeDirectory(const String& homeDirectory)
Line 131 
Line 618 
     _homeDirectory = homeDirectory;     _homeDirectory = homeDirectory;
 } }
  
   void Logger::setlogLevelMask( const String logLevelList )
   {
       Uint32 position          = 0;
       Uint32 logLevelType = 0;
       String logLevelName      = logLevelList;
   
       // Check if logLevel has been specified
       if (logLevelName != String::EMPTY)
       {
           // initialise _severityMask
           _severityMask = 0;
   
           // Set logLevelType to indicate the level of logging
           // required by the user.
           if (String::equalNoCase(logLevelName,"TRACE"))
           {
               logLevelType =  Logger::TRACE;
           }
           else if (String::equalNoCase(logLevelName,"INFORMATION"))
           {
               logLevelType =  Logger::INFORMATION;
           }
           else if (String::equalNoCase(logLevelName,"WARNING"))
           {
               logLevelType = Logger::WARNING;
           }
           else if (String::equalNoCase(logLevelName,"SEVERE"))
           {
               logLevelType = Logger::SEVERE;
           }
           else if (String::equalNoCase(logLevelName,"FATAL"))
           {
               logLevelType = Logger::FATAL;
           }
           // Setting _severityMask.  NOTE:  When adding new logLevels
           // it is essential that they are adding in ascending order
           // based on priority.  Once a case statement is true we will
           // continue to set all following log levels with a higher
           // priority.
           switch(logLevelType)
           {
               case Logger::TRACE:
                     _severityMask |= Logger::TRACE;
               case Logger::INFORMATION:
                     _severityMask |= Logger::INFORMATION;
               case Logger::WARNING:
                     _severityMask |= Logger::WARNING;
               case Logger::SEVERE:
                     _severityMask |= Logger::SEVERE;
               case Logger::FATAL:
                     _severityMask |= Logger::FATAL;
           }
       }
       else
       {
           // Property logLevel not specified, set default value.
           _severityMask = ~Logger::TRACE;
       }
       return ;
   }
   
   Boolean Logger::isValidlogLevel(const String logLevel)
   {
       // Validate the logLevel and modify the logLevel argument
       // to reflect the invalid logLevel
   
       Uint32    position=0;
       Uint32    index=0;
       String    logLevelName = String::EMPTY;
       Boolean   validlogLevel=false;
       Boolean   retCode=true;
   
       logLevelName = logLevel;
   
       if (logLevelName != String::EMPTY)
       {
           // Lookup the index for logLevel name in _logLevel_LIST
           index = 0;
           validlogLevel = false;
   
           while (index < _NUM_LOGLEVEL)
           {
               if (String::equalNoCase(logLevelName, LOGLEVEL_LIST[index]))
               {
                   // Found logLevel, break from the loop
                   validlogLevel = true;
                   break;
               }
               else
               {
                   index++;
               }
           }
       }
       else
       {
           // logLevels is empty, it is a valid value so return true
           return _SUCCESS;
       }
   
       return validlogLevel;
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.44
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2