iTime.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include <iostream>
#include <iomanip>
#include <sstream>
 
#include <QString>
 
#include "Preference.h"
 
#include "FileName.h"
#include "IString.h"
#include "iTime.h"
#include "SpecialPixel.h"
#include "NaifStatus.h"
 
using namespace std;
namespace Isis {
 
  // Static initializations
  bool iTime::p_lpInitialized = false;
 
  //---------------------------------------------------------------------------
  // Constructors
  //---------------------------------------------------------------------------
 
  iTime::iTime() {
    p_et = 0.0;
  }
 
  iTime::iTime(const QString &time) {
    LoadLeapSecondKernel();
 
    NaifStatus::CheckErrors();
 
    // Convert the time string to a double ephemeris time
    SpiceDouble et;
    str2et_c(time.toLatin1().data(), &et);
 
    p_et = et;
    NaifStatus::CheckErrors();
  }
 
 
  //---------------------------------------------------------------------------
  // Public members
  //---------------------------------------------------------------------------
 
  void iTime::operator=(const QString &time) {
    LoadLeapSecondKernel();
 
    NaifStatus::CheckErrors();
    // Convert the time string to a double ephemeris time
    SpiceDouble et;
    str2et_c(time.toLatin1().data(), &et);
 
    p_et = et;
    NaifStatus::CheckErrors();
  }
 
  // Overload of "=" with a c string
  void iTime::operator=(const char *time) {
    LoadLeapSecondKernel();
 
    NaifStatus::CheckErrors();
    // Convert the time string to a double ephemeris time
    SpiceDouble et;
    str2et_c(time, &et);
 
    p_et = et;
    NaifStatus::CheckErrors();
  }
 
 
  // Overload of "=" with a double
  void iTime::operator=(const double time) {
    LoadLeapSecondKernel();
    p_et = time;
  }
 
  bool iTime::operator>=(const iTime &time) {
    return (p_et >= time.p_et);
  }
 
  bool iTime::operator<=(const iTime &time) {
    return (p_et <= time.p_et);
  }
 
  bool iTime::operator>(const iTime &time) {
    return (p_et > time.p_et);
  }
 
 
  bool iTime::operator<(const iTime &time) {
    return (p_et < time.p_et);
  }
 
  bool iTime::operator!=(const iTime &time) {
    return (p_et != time.p_et);
  }
 
  bool iTime::operator==(const iTime &time) {
    return (p_et == time.p_et);
  }
 
 
  iTime iTime::operator +(const double &secondsToAdd) const {
    iTime tmp(*this);
    tmp += secondsToAdd;
    return tmp;
  }
 
 
  void iTime::operator +=(const double &secondsToAdd) {
    if(!IsSpecial(secondsToAdd) && !IsSpecial(p_et))
      p_et += secondsToAdd;
  }
 
 
  iTime operator +(const double &secondsToAdd, iTime time) {
    time += secondsToAdd;
    return time;
  }
 
 
 
 
  iTime iTime::operator -(const double &secondsToSubtract) const {
    iTime tmp(*this);
    tmp -= secondsToSubtract;
    return tmp;
  }
 
 
  double iTime::operator -(const iTime &iTimeToSubtract) const {
    return p_et - iTimeToSubtract.p_et;
  }
 
 
  void iTime::operator -=(const double &secondsToSubtract) {
    if (!IsSpecial(secondsToSubtract) && !IsSpecial(p_et))
      p_et -= secondsToSubtract;
  }
 
 
  iTime operator -(const double &secondsToSubtract, iTime time) {
    time -= secondsToSubtract;
    return time;
  }
 
 
 
 
 
 
  QString iTime::YearString() const {
    return toString(Year());
  }
 
  int iTime::Year() const {
    NaifStatus::CheckErrors();
    SpiceChar out[5];
 
    // Populate the private year member
    timout_c(p_et, "YYYY", 5, out);
    NaifStatus::CheckErrors();
    return IString(out).ToInteger();
  }
 
  QString iTime::MonthString() const {
    return toString(Month());
  }
 
  int iTime::Month() const {
    NaifStatus::CheckErrors();
    SpiceChar out[3];
 
    // Populate the private year member
    timout_c(p_et, "MM", 3, out);
    NaifStatus::CheckErrors();
    return IString(out).ToInteger();
  }
 
  QString iTime::DayString() const {
    return toString(Day());
  }
 
  int iTime::Day() const {
    NaifStatus::CheckErrors();
    SpiceChar out[3];
 
    // Populate the private year member
    timout_c(p_et, "DD", 3, out);
    NaifStatus::CheckErrors();
    return IString(out).ToInteger();
  }
 
  QString iTime::HourString() const {
    return toString(Hour());
  }
 
  int iTime::Hour() const {
    NaifStatus::CheckErrors();
    SpiceChar out[3];
 
    // Populate the private year member
    timout_c(p_et, "HR", 3, out);
    NaifStatus::CheckErrors();
    return IString(out).ToInteger();
  }
 
  QString iTime::MinuteString() const {
    return toString(Minute());
  }
 
  int iTime::Minute() const {
    NaifStatus::CheckErrors();
    SpiceChar out[3];
 
    // Populate the private year member
    timout_c(p_et, "MN", 3, out);
    NaifStatus::CheckErrors();
    return IString(out).ToInteger();
  }
 
  QString iTime::SecondString(int precision) const {
    ostringstream osec;
    osec.setf(ios::fixed);
    osec << setprecision(precision) << Second();
    QString sSeconds(osec.str().c_str());
    sSeconds = sSeconds.remove(QRegExp("(\\.0*|0*)$"));
 
    if(sSeconds.isEmpty()) sSeconds = "0";
    return sSeconds;
  }
 
  double iTime::Second() const {
    NaifStatus::CheckErrors();
    SpiceChar out[256];
 
    // Populate the private year member
    timout_c(p_et, "SC.#######::RND", 256, out);
    NaifStatus::CheckErrors();
    return IString(out).ToDouble();
  }
 
  QString iTime::DayOfYearString() const {
    return toString(DayOfYear());
  }
 
  int iTime::DayOfYear() const {
    NaifStatus::CheckErrors();
    SpiceChar out[4];
 
    // Populate the private year member
    timout_c(p_et, "DOY", 4, out);
    NaifStatus::CheckErrors();
    return IString(out).ToInteger();
  }
 
  QString iTime::EtString() const {
    return toString(p_et);
  }
 
  QString iTime::UTC(int precision) const {
    QString utc = YearString() + "-" ;
    if(Month() < 10) utc += "0" + MonthString() + "-";
    else utc += MonthString() + "-";
 
    if(Day() < 10) utc += "0" + DayString() + "T";
    else utc += DayString() + "T";
 
    if(Hour() < 10) utc += "0" + HourString() + ":";
    else utc += HourString() + ":";
 
    if(Minute() < 10) utc += "0" + MinuteString() + ":";
    else utc += MinuteString() + ":";
 
    if(Second() < 10) utc += "0" + SecondString(precision);
    else utc += SecondString(precision);
 
    return utc;
  }
 
  void iTime::setEt(double et) {
    if(!IsSpecial(et))
      p_et = et;
    else
      p_et = 0.0;
  }
 
  void iTime::setUtc(QString utcString) {
    // If the time string is in ISO basic format add separators for utc2et
    if ( utcString.contains("T") && // Check for ISO T format
         !utcString.contains("-") && // Check for missing data separator
         !utcString.contains(":")) { // Check for missing time separator
      QString dateString = utcString.split("T").front();
      dateString.insert(4, "-");
      // If format is YYYYDOY we are done with the date string
      // Otherwise we are in YYYYMMDD format
      if (dateString.size() > 8) {
        dateString.insert(7, "-");
      }
 
      QString timeString = utcString.split("T").back();
      // If the format is hh or hhmm, resize and pad with 0s out to hh0000 or hhmm00
      if (timeString.size() < 6) {
        timeString.resize(6, '0');
      }
      timeString.insert(2, ":");
      timeString.insert(5, ":");
 
      utcString = dateString + "T" + timeString;
    }
 
    NaifStatus::CheckErrors();
    LoadLeapSecondKernel();
 
    double et;
    utc2et_c(utcString.toLatin1().data(), &et);
    setEt(et);
    NaifStatus::CheckErrors();
  }
 
  //---------------------------------------------------
  // Private members
  //---------------------------------------------------
 
 
  void iTime::LoadLeapSecondKernel() {
    // Inorder to improve the speed of iTime comparisons, the leapsecond
    // kernel is loaded only once and left open.
    if(p_lpInitialized) return;
 
    // Get the leap second kernel file open
    Isis::PvlGroup &dataDir = Isis::Preference::Preferences().findGroup("DataDirectory");
    QString baseDir = dataDir["Base"];
    baseDir += "/kernels/lsk/";
    FileName leapSecond(baseDir + "naif????.tls");
 
    NaifStatus::CheckErrors();
    QString leapSecondName(leapSecond.highestVersion().expanded());
    furnsh_c(leapSecondName.toLatin1().data());
    NaifStatus::CheckErrors();
 
    p_lpInitialized = true;
  }
 
  QString iTime::CurrentGMT() {
    time_t startTime = time(NULL);
    struct tm *tmbuf = gmtime(&startTime);
    char timestr[80];
    strftime(timestr, 80, "%Y-%m-%dT%H:%M:%S", tmbuf);
    return (QString) timestr;
  }
 
 
  QString iTime::CurrentLocalTime() {
    time_t startTime = time(NULL);
    struct tm *tmbuf = localtime(&startTime);
    char timestr[80];
    strftime(timestr, 80, "%Y-%m-%dT%H:%M:%S", tmbuf);
    return (QString) timestr;
  }
} // end namespace isis