KVDatime.cpp

/*******************************************************************************
$Id: KVDatime.cpp,v 1.7 2009/01/15 16:10:13 franklan Exp $
$Revision: 1.7 $
$Date: 2009/01/15 16:10:13 $
$Author: franklan $
*******************************************************************************/
#include "KVError.h"
#include "KVDatime.h"
#include "KVString.h"
 
ClassImp(KVDatime)
 
const std::vector<std::string> KVDatime::fNumToMonth = {"JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC"};
std::unordered_map<std::string,int> KVDatime::fMonthToNum;
 
 
 
void KVDatime::init_month_map()
{
   // set up static map of month names to month numbers if needed
   if(fMonthToNum.empty())
   {
      int mth=1;
      for(auto M : fNumToMonth)
         fMonthToNum[M]=mth++;
   }
}
 
 
 
 
std::optional<int> KVDatime::get_month_from_name(const char* Month)
{
   if(fMonthToNum.find(Month) == std::end(fMonthToNum))
   {
      KVError::Error(this,"get_month_from_name",
                     "Unrecognised month in date (%s)", Month);
      return {};
   }
   return fMonthToNum[Month];
}
 
 
 
 
KVDatime::KVDatime()
   : TDatime()
{
}
 
 
 
 
KVDatime::KVDatime(const Char_t* DateString, EKVDateFormat f)
   : KVDatime()
{
   //if f = KVDatime::kGANACQ:
   //
   //Decodes GANIL acquisition (INDRA) run-sheet format date into a TDatime
   //
   //Format of date string is: `29-SEP-2005 09:42:17.00`
   //
   //if f = KVDatime::kGANACQ2010:
   //
   //Decodes GANIL acquisition runfile format date into a TDatime
   //
   //Format of date string is: `27Nov10_02h07m40s`
   //
   //if f = KVDatime::kGANACQNarval:
   //
   //Decodes GANIL Narval acquisition runfile format date into a TDatime
   //
   //Format of date string is: `12-04-18_17h09m41s`
   //
   //if f = KVDatime::kSQL:
   //
   //Decodes SQL format date into a TDatime (i.e. same format as returned
   //by TDatime::AsSQLString(): `2007-05-02 14:52:18`)
   //
   //if f = KVDatime::kSRB:
   //
   //Decodes SRB format date into a TDatime
   //
   //Format of date string is: `2008-12-19-15.21`
   //
   //if f = KVDatime::kIRODS:
   //
   //Decodes IRODS format date into a TDatime
   //
   //Format of date string is: `2008-12-19.15:21`
   //
   //if f = KVDatime::kDMY:
   //
   //Decodes DMY format date into a TDatime
   //
   //Format of date string is: `19/12/2008`
 
   switch (f) {
      case kGANACQ:
         SetGanacqDate(DateString);
         break;
      case kGANACQ2010:
         SetGanacq2010Date(DateString);
         break;
      case kGANACQNarval:
         SetGanacqNarvalDate(DateString);
         break;
      case kSQL:
         SetSQLDate(DateString);
         break;
      case kSRB:
         SetSRBDate(DateString);
         break;
      case kIRODS:
         SetIRODSDate(DateString);
         break;
      case kDMY:
         SetDMYDate(DateString);
         break;
      default:
         {
            KVError::Error(this, "KVDatime", "Unknown date format");
         }
   }
}
 
 
KVDatime::KVDatime(const KVDatime& d)
   : TDatime(d)
{}
 
KVDatime::KVDatime(const TDatime& d)
   : TDatime(d)
{}
 
KVDatime::KVDatime(UInt_t tloc, Bool_t dosDate)
   : TDatime(tloc,dosDate)
{}
 
KVDatime::KVDatime(Int_t date, Int_t time)
   : TDatime(date,time)
{}
 
KVDatime::KVDatime(Int_t year, Int_t month, Int_t day, Int_t hour, Int_t min, Int_t sec)
   : TDatime(year,month,day,hour,min,sec)
{}
 
 
 
KVDatime& KVDatime::operator=(const KVDatime& d)
{
   // copy assignment operator
   return dynamic_cast<KVDatime&>(TDatime::operator=(d));
}
 
 
 
 
void KVDatime::SetSQLDate(const Char_t* DateString)
{
   //Decodes SQL format date into a TDatime (i.e. same format as returned
   //by TDatime::AsSQLString(): "2007-05-02 14:52:18")
   Int_t Y, M, D, h, m, s;
   sscanf(DateString, "%4d-%02d-%02d %02d:%02d:%02d",
          &Y, &M, &D, &h, &m, &s);
   Set(Y, M, D, h, m, s);
}
 
 
 
 
void KVDatime::SetSRBDate(const Char_t* DateString)
{
   //Decodes SRB format date into a TDatime
   //Format of date string is:
   //         2008-12-19-15.21
 
   Int_t Y, M, D, h, m, s;
   sscanf(DateString, "%4d-%02d-%02d-%02d.%02d",
          &Y, &M, &D, &h, &m);
   s = 0;
   Set(Y, M, D, h, m, s);
}
 
 
 
 
void KVDatime::SetIRODSDate(const Char_t* DateString)
{
   //Decodes IRODS format date into a TDatime
   //Format of date string is:
   //         2008-12-19.15:21
 
   Int_t Y, M, D, h, m, s;
   sscanf(DateString, "%4d-%02d-%02d.%02d:%02d",
          &Y, &M, &D, &h, &m);
   s = 0;
   Set(Y, M, D, h, m, s);
}
 
 
 
 
void KVDatime::SetDMYDate(const Char_t* DMYString)
{
   // Set date from string in format "DD/MM/YYYY"
   Int_t Y, M, D;
   sscanf(DMYString, "%2d/%2d/%4d", &D, &M, &Y);
   Set(Y, M, D, 0, 0, 0);
}
 
 
 
 
void KVDatime::SetGanacq2010Date(const Char_t* GanacqDateString)
{
   // Decodes dates in new (2010) format of GANIL acquisition
   // run files, e.g. run_0058.dat.27Nov10_02h07m40s
 
   init_month_map();
   Int_t Y, D, H, M, S;
   Char_t Month[5];
   TString tmp(GanacqDateString);
   tmp.ToUpper();
   tmp.ReplaceAll("_", " ");
   if (sscanf(tmp.Data(), "%02d%3s%02d %02dH%02dM%02dS", &D, Month, &Y, &H, &M, &S) == 6)
   {
      if(auto imonth = get_month_from_name(Month))
      {
         Y += 2000;
         Set(Y, *imonth, D, H, M, S);
      }
   }
}
 
 
 
 
void KVDatime::SetGanacqNarvalDate(const Char_t* GanacqDateString)
{
   // Decodes dates in format of GANIL Narval acquisition
   // run files, e.g. run_0058.dat.27-11-10_02h07m40s
   Int_t Y, D, H, M, S, Month;
   TString tmp(GanacqDateString);
   tmp.ToUpper();
   tmp.ReplaceAll("_", " ");
   if (sscanf(tmp.Data(), "%02d-%02d-%02d %02dH%02dM%02dS", &D, &Month, &Y, &H, &M, &S) == 6) {
      Y += 2000;
      Set(Y, Month, D, H, M, S);
   }
}
 
 
 
 
void KVDatime::SetGanacqDate(const Char_t* GanacqDateString)
{
   //Decodes GANIL acquisition (INDRA) run-sheet format date into a TDatime
   //Format of date string is:
   //      29-SEP-2005 09:42:17.00
   //  or  29-SEP-2005 09:42:17
   //  or  29-SEP-05 09:42:17.00
   //  or  29-SEP-05 09:42:17
   //
   //If format is not respected, we set to current time & date
 
   if (!IsGANACQFormat(GanacqDateString))
   {
      // if format is correct, there should be 6 or 7 elements in toks
      KVError::Error(this, "SetGanacqDate",
                     "Format is incorrect: %s (should be like \"29-SEP-2005 09:42:17.00\" or \"29-SEP-05 09:42:17\")",
                     GanacqDateString);
      Set();
      return;
   }
   KVString tmp(GanacqDateString);
   tmp.Begin("-:. ");
   auto day = tmp.Next().Atoi();
   auto month = get_month_from_name(tmp.Next(true).Data());
   if(!month){
      Set();
      return;
   }
   auto year = tmp.Next().Atoi();
   // year may be written in shortened form: 97 instead of 1997
   if (year < 100) {
      (year < 82 ? year += 2000 : year += 1900);
   }
   auto hour = tmp.Next().Atoi();
   auto min = tmp.Next().Atoi();
   auto sec = tmp.Next().Atoi();
   Set(year, *month, day, hour, min, sec);
}
 
 
 
 
const Char_t* KVDatime::AsGanacqDateString() const
{
   //Return date and time string with format "29-SEP-2005 09:42:17.00"
   //Copy the string immediately if you want to reuse/keep it
   return Form("%d-%s-%4d %02d:%02d:%02d.00",
               GetDay(), fNumToMonth[GetMonth()-1].c_str(), GetYear(), GetHour(), GetMinute(), GetSecond());
}
 
 
 
 
const Char_t* KVDatime::AsDMYDateString() const
{
   return Form("%02d/%02d/%4d",
               GetDay(),
               GetMonth(), GetYear());
}
 
 
 
 
const Char_t* KVDatime::String(EKVDateFormat fmt)
{
   // Returns date & time as a string in required format:
   //  fmt = kCTIME (default)  :  ctime format e.g. Thu Apr 10 10:48:34 2008
   //  fmt = kSQL              :  SQL format e.g. 1997-01-15 20:16:28
   //  fmt = kGANACQ           :  GANIL acquisition format e.g. 29-SEP-2005 09:42:17.00
   //  fmt = kDMY           :  DD/MM/YYYY
   switch (fmt) {
      case kCTIME:
         fStr = AsString();
         break;
      case kSQL:
         fStr = AsSQLString();
         break;
      case kGANACQ:
         fStr = AsGanacqDateString();
         break;
      case kDMY:
         fStr = AsDMYDateString();
         break;
      default:
         fStr = "";
   }
   return fStr.Data();
}
 
 
 
 
Bool_t KVDatime::IsGANACQFormat(const Char_t* date)
{
   // Static method, returns kTRUE if 'date' is in format of GANIL acquisition
   // e.g. 29-SEP-2005 09:42:17.00
 
   KVString tmp(date);
   auto nelem = tmp.GetNValues("-:. ");
    // if format is correct, there should be 6 or 7 elements in toks
   return (nelem > 5 && nelem < 8);
}
 
 
 
 
Bool_t KVDatime::IsGANACQ2010Format(const Char_t* date)
{
   // Static method, returns kTRUE if 'date' is in new (2010) format of GANIL acquisition
   // run files, e.g. run_0058.dat.27Nov10_02h07m40s
 
   Int_t Y, D, H, M, S;
   Char_t Month[5];
   TString tmp(date);
   tmp.ToUpper();
   tmp.ReplaceAll("_", " ");
   if (sscanf(tmp.Data(), "%02d%3s%02d %02dH%02dM%02dS", &D, Month, &Y, &H, &M, &S) == 6)
      return kTRUE;
   return kFALSE;
}
 
 
 
 
Bool_t KVDatime::IsGANACQNarvalFormat(const Char_t* date)
{
   // Static method, returns kTRUE if 'date' is in format of GANIL Narval acquisition
   // run files, e.g. run_0058.dat.27-11-10_02h07m40s
 
   Int_t Y, D, H, M, S, Month;
   TString tmp(date);
   tmp.ToUpper();
   tmp.ReplaceAll("_", " ");
   if (sscanf(tmp.Data(), "%02d-%02d-%02d %02dH%02dM%02dS", &D, &Month, &Y, &H, &M, &S) == 6)
      return kTRUE;
   return kFALSE;
}
 
 
 
 
Bool_t KVDatime::IsSQLFormat(const Char_t* date)
{
   // Static method, returns kTRUE if 'date' is in SQL format
   // e.g. 2007-05-02 14:52:18
 
   Int_t Y, M, D, h, m, s;
   if (sscanf(date, "%4d-%02d-%02d %02d:%02d:%02d",
              &Y, &M, &D, &h, &m, &s) != 6) return kFALSE;
   return kTRUE;
}
 
 
 
 
Bool_t KVDatime::IsSRBFormat(const Char_t* date)
{
   // Static method, returns kTRUE if 'date' is in SRB format
   // e.g. 2008-12-19-15.21
 
   Int_t Y, M, D, h, m;
   if (sscanf(date, "%4d-%02d-%02d-%02d.%02d",
              &Y, &M, &D, &h, &m) != 5) return kFALSE;
   return kTRUE;
}
 
 
 
 
Bool_t KVDatime::IsIRODSFormat(const Char_t* date)
{
   // Static method, returns kTRUE if 'date' is in IRODS format
   // e.g. 2008-12-19.15:21
 
   Int_t Y, M, D, h, m;
   if (sscanf(date, "%4d-%02d-%02d.%02d:%02d",
              &Y, &M, &D, &h, &m) != 5) return kFALSE;
   return kTRUE;
}
 
 
 
 
const Char_t* KVDatime::Month(Int_t m)
{
   return fNumToMonth[m-1].c_str();
}
 
 
 
 
Double_t KVDatime::GetNumberOfSeconds(Int_t ref_year)
{
 
   Double_t total_ins = 0;
 
   Double_t year_ins = GetYear();
   year_ins -= ref_year;
 
   year_ins *= 365.25; //1y=365.25 d
   year_ins *= 24; //1d=24 h
   year_ins *= 3660; //1h=60x60=3660 s
 
   total_ins += year_ins;
 
   //nombre de jours depuis le debut de l annee
   Double_t month_ins = GetMonth() - 1;
   month_ins *= 365.25 / 12; //1month = 30.437d (365.25/12) approximatif
   month_ins += GetDay(); //-> nombre de jours
   month_ins *= 24;  //1d=24 h
   month_ins *= 3660; //1h=60x60=3660 s
 
   total_ins += month_ins; //nombre de jours totals en second
 
   total_ins += GetHour() * 3600;
   total_ins += GetMinute() * 60;
   total_ins += GetSecond();
 
   return total_ins;
 
 
}
 
 
 
 
Double_t KVDatime::GetDureeInSeconds(KVDatime from)
{
   Int_t year_ref = from.GetYear();
   if (year_ref > this->GetYear()) year_ref = this->GetYear();
 
   Double_t sum = from.GetNumberOfSeconds(year_ref);
   return this->GetNumberOfSeconds(year_ref) - sum;
}