iTime.cpp

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <sstream>

#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) {
    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