src/Logger.cpp

Go to the documentation of this file.
00001 /*
00002 Copyright (c) 2000-2003, Jelle Kok, University of Amsterdam
00003 All rights reserved.
00004 
00005 Redistribution and use in source and binary forms, with or without
00006 modification, are permitted provided that the following conditions are met:
00007 
00008 1. Redistributions of source code must retain the above copyright notice, this
00009 list of conditions and the following disclaimer.
00010 
00011 2. Redistributions in binary form must reproduce the above copyright notice,
00012 this list of conditions and the following disclaimer in the documentation
00013 and/or other materials provided with the distribution.
00014 
00015 3. Neither the name of the University of Amsterdam nor the names of its
00016 contributors may be used to endorse or promote products derived from this
00017 software without specific prior written permission.
00018 
00019 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00020 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00021 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00022 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
00023 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00024 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
00025 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00026 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00027 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00028 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00029 */
00030 
00051 #include "Logger.h"
00052 #include <stdio.h>    // needed for vsprintf
00053 #include <string>     // needed for string
00054 #ifdef Solaris
00055  #include <varargs.h> // needed for va_list and va_start under Solaris
00056 #else
00057  #include <stdarg.h>
00058 #endif
00059 //#include <pthread.h> CYKO
00060 
00061 Logger Log;          
00062 Logger LogDraw;      
00064 /*****************************************************************************/
00065 /**************************** LOGGER *****************************************/
00066 /*****************************************************************************/
00067 
00075 Logger::Logger( ostream& o, int iMin, int iMax )
00076 {
00077 //pthread_mutex_init( &mutex_stream, NULL ); CYKO
00078   strcpy( m_strHeader, "" );
00079   m_timing.restartTime();
00080   addLogRange( iMin, iMax );
00081   m_os = &o;
00082 }
00083 
00091 bool Logger::log( int iLevel, string str)
00092 {
00093   if( isInLogLevel( iLevel ) )
00094   {
00095     *m_os << m_strHeader << str;
00096     return true;
00097   }
00098 
00099   return false;
00100 }
00101 
00112 bool Logger::log( int iLevel, char *str, ... )
00113 {
00114   if( isInLogLevel( iLevel ) )
00115   {
00116     logSignal(); // test whether there are no old strings left to log
00117     va_list ap;
00118 #ifdef Solaris
00119     va_start( ap );
00120 #else
00121     va_start( ap, str );
00122 #endif
00123     if( vsnprintf( m_buf, MAX_LOG_LINE-1, str, ap ) == -1 )
00124       cerr << "Logger::log, buffer is too small!\n" ;
00125     va_end(ap);
00126     *m_os << m_strHeader << m_buf << "\n";
00127     return true;
00128   }
00129 
00130   return false;
00131 }
00132 
00144 bool Logger::logWithTime( int iLevel, char *str, ... )
00145 {
00146   if( isInLogLevel( iLevel ) )
00147   {
00148     logSignal(); // test whether there are no old strings left to log
00149     va_list ap;
00150 #ifdef Solaris
00151     va_start( ap );
00152 #else
00153     va_start( ap, str );
00154 #endif
00155     if( vsnprintf( m_buf, MAX_LOG_LINE-1, str, ap ) == -1 )
00156       cerr << "Logger::log, buffer is too small!" << "\n";
00157     va_end(ap);
00158 
00159     string s = m_strHeader;
00160     s.append( m_buf );
00161     s.copy( m_buf, string::npos );
00162     m_buf[s.length()] = '\0';
00163     m_timing.printTimeDiffWithText( *m_os, m_buf );
00164 
00165     return true;
00166   }
00167 
00168   return false;
00169 }
00170 
00182 bool Logger::logFromSignal( int iLevel, char   *str, ...        )
00183 {
00184   char buf[MAX_LOG_LINE];
00185   if( isInLogLevel( iLevel ) )
00186   {
00187     va_list ap;
00188 #ifdef Solaris
00189     va_start( ap );
00190 #else
00191     va_start( ap, str );
00192 #endif
00193     if( vsnprintf( buf, MAX_LOG_LINE-1, str, ap ) == -1 )
00194       cerr << "Logger::log, buffer is too small!" << "\n";
00195     va_end(ap);
00196 
00197     char str[16];
00198     sprintf( str, "%2.2f: ", m_timing.getElapsedTime()*1000 );
00199     m_strSignal.append( str );
00200     m_strSignal.append( m_strHeader );
00201     m_strSignal.append( buf );
00202     m_strSignal.append(  "\n\0" );
00203 
00204     return true;
00205   }
00206 
00207   return false;
00208 
00209 }
00210 
00214 bool Logger::logSignal( )
00215 {
00216   if( ! m_strSignal.empty() )
00217   {
00218     *m_os << "\n" << m_strSignal ;
00219     m_strSignal = "";
00220     return true;
00221   }
00222   return false;
00223 }
00224 
00226 void Logger::restartTimer()
00227 {
00228   return m_timing.restartTime();
00229 }
00230 
00233 Timing Logger::getTiming( )
00234 {
00235   return m_timing;
00236 }
00237 
00238 
00244 bool Logger::isInLogLevel( int iLevel )
00245 {
00246   return m_setLogLevels.find( iLevel ) != m_setLogLevels.end() ;
00247 }
00248 
00253 bool  Logger::addLogLevel( int iLevel )
00254 {
00255   m_setLogLevels.insert( iLevel );
00256   return true;
00257 }
00258 
00264 bool  Logger::addLogRange( int iMin, int iMax )
00265 {
00266   bool bReturn = true;
00267   for( int i = iMin ; i <= iMax;  i++ )
00268     bReturn &= addLogLevel( i );
00269   return bReturn;
00270 }
00271 
00275 char* Logger::getHeader( )
00276 {
00277   return m_strHeader;
00278 }
00279 
00283 bool Logger::setHeader( char *str )
00284 {
00285   strcpy( m_strHeader, str );
00286   return true;
00287 }
00288 
00295 bool Logger::setHeader( int i1, int i2 )
00296 {
00297   sprintf( m_strHeader, "(%d, %d) ", i1, i2 );
00298   return true;
00299 }
00300 
00306 bool Logger::setHeader( int i )
00307 {
00308   sprintf( m_strHeader, " %d: ", i );
00309   return true;
00310 }
00311 
00312 
00318 bool Logger::setOutputStream( ostream& o )
00319 {
00320   m_os = &o;
00321   return true;
00322 }
00323 
00328 ostream& Logger::getOutputStream(  )
00329 {
00330   return *m_os;
00331 }
00332 
00336 void Logger::showLogLevels( ostream &os )
00337 {
00338   set<int>::iterator itr;
00339   for (itr = m_setLogLevels.begin() ; itr != m_setLogLevels.end() ; itr++)
00340     os << *itr << " " ;
00341   os << "\n";
00342 }
00343 /*****************************************************************************/
00344 /********************** CLASS TIMING *****************************************/
00345 /*****************************************************************************/
00346 
00351 #ifdef WIN32
00352 double Timing::getTimeDifference( DWORD tv1, DWORD tv2 )
00353 {
00354   return  ((double)(tv1 - tv2) / 1000.0) ;
00355 }
00356 #else
00357 double Timing::getTimeDifference( struct timeval tv1, struct timeval tv2 )
00358 {
00359 
00360   return  ((double)tv1.tv_sec + (double)tv1.tv_usec/1000000 ) -
00361           ((double)tv2.tv_sec + (double)tv2.tv_usec/1000000 ) ;
00362 }
00363 #endif
00364 
00373 void Timing::printTimeDiffWithText( ostream &os, char *str, int iFactor )
00374 {
00375   // set the with to 6 and fill remaining places with '0'.
00376   os <<setw(6)<< setfill('0')<< getElapsedTime()*iFactor << ":" << str << "\n";
00377 }
00378 
00382 double Timing::getElapsedTime( int iFactor )
00383 {
00384 #ifdef WIN32
00385   DWORD time2 = GetTickCount();
00386 #else
00387   struct timeval time2;
00388   gettimeofday( &time2, NULL );
00389 #endif
00390   return getTimeDifference( time2, time1 )*iFactor;
00391 }
00392 
00394 void Timing::restartTime( )
00395 {
00396 #ifdef WIN32
00397   time1 = GetTickCount();
00398 #else
00399   gettimeofday( &time1, NULL );
00400 #endif
00401 }
00402 
00403 
00404 /*****************************************************************************/
00405 /**************************** TESTING PURPOSES *******************************/
00406 /*****************************************************************************/
00407 
00408 /*
00409 #ifdef WIN32
00410   #include <windows.h>
00411 #else
00412   #include<sys/poll.h>
00413 #endif
00414 
00415 int main( void )
00416 {
00417   ofstream fout( "temp.txt" );
00418   Logger log( fout, 0, 2 );
00419   log.log( 0, "hello" );
00420   log.setHeader( "jelle" );
00421 #ifdef WIN32
00422   Sleep(1000);
00423 #else
00424   poll(0,0,1000);
00425 #endif
00426   log.log( 2, "hello" );
00427   log.log( 3, "hello" );
00428   int j = 2;
00429   double i = 2.324234;
00430   printf( "hoi: "); fflush(stdout);
00431   log.logWithTime( 1, "|%f %d|", i, j);
00432 }
00433 
00434 */

Generated on Thu Apr 26 22:45:27 2007 for GangOfSix(GOS)-RoboCupTeamProject by  doxygen 1.5.1-p1