Back to index

PHTimeStamp.C

 
//----------------------------------------------------------------------------- 
//  $Header: /afs/rhic/phenix/PHENIX_CVS/offline/database/pdbcal/PHTimeStamp.C,v 1.5 2000/06/04 04:13:56 purschke Exp $ 
// 
//  The PHOOL's Software 
//  Copyright (C) PHENIX collaboration, 1999 
// 
//  Implementation of class PHTimeStamp 
// 
//  Author: Matthias Messer 
//----------------------------------------------------------------------------- 
#include "PHTimeStamp.h" 
#include <string.h> 
 
const phtime_t ticOffset = 35067168000000000ULL; 
const phtime_t ticFactor = 10000000; 
 
PHTimeStamp::PHTimeStamp()  
{ 
   binaryTime = 0; 
} 
 
PHTimeStamp::PHTimeStamp(int year, int month, int day, int hour, int minute, int second, int fraction)  
{ 
   set(year, month, day, hour, minute, second, fraction); 
} 
 
PHTimeStamp::PHTimeStamp(time_t t)  
{ 
   setTics(t); 
} 
 
PHTimeStamp::~PHTimeStamp()  
{ 
} 
 
void PHTimeStamp::set(int year, int month, int day, int hour, int minute, int second, int fraction) 
{ 
   tm newTime; 
 
   newTime.tm_year = year  - 1900; 
   newTime.tm_mon  = month - 1; 
   newTime.tm_mday = day; 
   newTime.tm_hour = hour; 
   newTime.tm_min  = minute; 
   newTime.tm_sec  = second; 
 
   setTics(mktime(&newTime)); 
   binaryTime += fraction; 
} 
 
void PHTimeStamp::set(const char * timeString) 
{ 
  tm newTime; 
  strptime(timeString, "%A %h %d %H:%M:%S %Y", &newTime); 
  setTics(mktime(&newTime)); 
} 
 
void PHTimeStamp::setToSystemTime() 
{ 
   setTics(time(0)); 
} 
 
time_t PHTimeStamp::getTics() const 
{ 
   return binaryTimeToTics(binaryTime); 
} 
 
void PHTimeStamp::setTics(time_t tics) 
{ 
   binaryTime = ticsToBinaryTime(tics); 
} 
 
phtime_t PHTimeStamp::ticsToBinaryTime(time_t tics) const 
{ 
   return tics * ticFactor + ticOffset; 
} 
 
time_t PHTimeStamp::binaryTimeToTics(phtime_t bt) const 
{ 
   return (bt - ticOffset) / ticFactor; 
} 
 
int PHTimeStamp::isInRange(const PHTimeStamp & t1, const PHTimeStamp & t2) 
{ 
   return ( binaryTime > t1.getBinaryTime() && binaryTime < t2.getBinaryTime()); 
} 
 
void PHTimeStamp::print() 
{ 
   cout << *this; 
} 
 
// 
// Operators 
// 
int PHTimeStamp::operator == (const PHTimeStamp & t) const 
{ 
   return binaryTime == t.getBinaryTime(); 
} 
 
int PHTimeStamp::operator != (const PHTimeStamp & t) const 
{ 
   return binaryTime != t.getBinaryTime(); 
} 
 
int PHTimeStamp::operator > (const PHTimeStamp & t) const 
{ 
   return binaryTime > t.getBinaryTime(); 
} 
 
int PHTimeStamp::operator < (const PHTimeStamp & t) const 
{ 
   return binaryTime < t.getBinaryTime(); 
} 
 
int PHTimeStamp::operator >= (const PHTimeStamp & t) const 
{ 
   return binaryTime >= t.getBinaryTime(); 
} 
 
int PHTimeStamp::operator <= (const PHTimeStamp & t) const 
{ 
   return binaryTime <= t.getBinaryTime(); 
} 
 
PHTimeStamp & PHTimeStamp::operator = (const PHTimeStamp & t) 
{ 
   binaryTime = t.getBinaryTime(); 
   return *this; 
} 
 
PHTimeStamp PHTimeStamp::operator += (time_t t) 
{ 
   binaryTime += t * ticFactor; 
   return *this; 
} 
 
PHTimeStamp PHTimeStamp::operator -= (time_t t) 
{ 
   binaryTime -= t * ticFactor; 
   return *this; 
} 
 
void PHTimeStamp::print() const 
{ 
   cout << *this << endl; 
} 
char * PHTimeStamp::formatTimeString() const 
{ 
 
  // this one gives, for naming purposes, the time string  
  // without blanks 
 
  time_t tics = getTics(); 
  char timeString[25]; 
  timeString[24] = '\0'; 
  strncpy(timeString, ctime(&tics), 24); 
  char *line = new char[25]; 
 
  char *u = strtok (timeString, " "); 
 
  if (u) strcpy (line,u); 
 
  while ( (u=strtok(0," ")) ) 
    { 
	strcat (line, "_"); 
	strcat (line, u); 
    } 
  return line; 
} 
 
// 
// Non member operators and functions 
// 
 
PHTimeStamp operator + (const PHTimeStamp & t1, time_t t2) 
{ 
   PHTimeStamp newTime = t1; 
   newTime += t2; 
   return newTime; 
} 
 
PHTimeStamp operator - (const PHTimeStamp & t1, time_t t2) 
{ 
   PHTimeStamp newTime = t1; 
   newTime -= t2; 
   return newTime; 
} 
 
time_t operator - (const PHTimeStamp & t1, const PHTimeStamp & t2) 
{ 
   return t1.getTics() - t2.getTics(); 
} 
 
ostream & operator << (ostream & s, const PHTimeStamp & t) 
{ 
   time_t tics = t.getTics(); 
   char timeString[25]; 
   timeString[24] = '\0'; 
   strncpy(timeString, ctime(&tics), 24); 
   return s << timeString; 
} 
 
istream & operator >> (istream & s, PHTimeStamp & t) 
{ 
   char timeString[25]; 
   s.getline(timeString, 25); 
   t.set(timeString); 
} 
 
 

Back to index