DayTime.hpp

Go to the documentation of this file.

#pragma ident "$Id: DayTime.hpp 2952 2011-10-28 14:53:20Z yanweignss $"



#ifndef GPSTK_DAYTIME_HPP
#define GPSTK_DAYTIME_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

//============================================================================
//
//This software developed by Applied Research Laboratories at the University of
//Texas at Austin, under contract to an agency or agencies within the U.S. 
//Department of Defense. The U.S. Government retains all rights to use,
//duplicate, distribute, disclose, or release this software. 
//
//Pursuant to DoD Directive 523024 
//
// DISTRIBUTION STATEMENT A: This software has been approved for public 
//                           release, distribution is unlimited.
//
//=============================================================================






#include <string>
#if defined _MSC_VER
#ifndef _WINSOCKAPI_
// timeval is defined in winsock.h, which we don't want to include
// because it breaks lots of this code
#ifndef timeval
struct timeval {
   long    tv_sec;         /* seconds */
   long    tv_usec;        /* and microseconds */
};
#endif   // #ifndef timeval
#endif   // #ifndef _WINSOCKAPI_
#else
#include <sys/time.h>
#endif

#include "MathBase.hpp"
#include "Exception.hpp"
#include "StringUtils.hpp"
#include "GPSZcount.hpp"
#include "CommonTime.hpp"

namespace gpstk
{

   class DayTime
   {
   public:
         // ----------- Part  1: exceptions and constants --------------
      NEW_EXCEPTION_CLASS(DayTimeException, gpstk::Exception);

      NEW_EXCEPTION_CLASS(FormatException, gpstk::Exception);

      enum TimeFrame
      {
         Unknown,    
         UTC,        
         LocalSystem,
         GPS_Tx,     
         GPS_Rx,     
            // (e.g., rx data if clock bias is applied)
         GPS_SV,     
         GPS_Receiver
      };


      static const long FACTOR;

      static const double JD_TO_MJD;
      static const long MJD_JDAY;
      static const long GPS_EPOCH_JDAY;
      static const long GPS_EPOCH_MJD;
      static const long UNIX_MJD;
      static const long HALFWEEK;
      static const long FULLWEEK;
      static const long SEC_DAY;
      static const long MS_PER_DAY;

      static const double ONE_NSEC_TOLERANCE;
      static const double ONE_USEC_TOLERANCE;
      static const double ONE_MSEC_TOLERANCE;
      static const double ONE_SEC_TOLERANCE;
      static const double ONE_MIN_TOLERANCE;
      static const double ONE_HOUR_TOLERANCE;
      
      static double DAYTIME_TOLERANCE;

      static const long BEGIN_LIMIT_JDAY;
      static const long END_LIMIT_JDAY;
      static const DayTime BEGINNING_OF_TIME;
      static const DayTime END_OF_TIME;

      static bool DAYTIME_TEST_VALID;

      
         // ----------- Part  2: member functions: tolerance ------------
         //
      static double setDayTimeTolerance(const double tol)
         throw()
      { DAYTIME_TOLERANCE = tol; return DAYTIME_TOLERANCE; }

      static double getDayTimeTolerance() 
         throw()
      { return DAYTIME_TOLERANCE; }
   
      DayTime& setTolerance(const double tol) throw();

      double getTolerance() throw()
      { return tolerance; }


         // ----------- Part  3: member functions: constructors ------------
         //
      DayTime()
         throw(DayTimeException);

      DayTime(short GPSWeek,
              double GPSSecond,
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(short GPSWeek,
              double GPSSecond,
              short year, 
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(short GPSWeek, 
              long zcount,
              short year,
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(unsigned long fullZcount, 
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(const GPSZcount& z,
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(const CommonTime& c,
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(short year,
              short month,
              short day,
              short hour,
              short minute,
              double second,
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(long double MJD, 
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(double MJD, 
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(short year,
              short doy,
              double sod, 
              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime(const struct timeval& t, 
              TimeFrame f = Unknown)
         throw(DayTimeException);

      ~DayTime()
         throw()
      {}

         // --------- Part  4: member functions: assignment and copy ----------
         //
      DayTime(const DayTime &right)
         throw(DayTimeException);

      DayTime& operator=(const DayTime& right)
         throw();

         // ----------- Part  5: member functions: arithmetic ------------
         //
      double operator-(const DayTime& right) const
         throw();

      DayTime operator+(double sec) const
         throw();

      DayTime operator-(double sec) const
         throw();

      DayTime& operator+=(double sec)
         throw(DayTimeException);

      DayTime& operator-=(double sec)
         throw(DayTimeException);

      DayTime& addSeconds(double seconds)
         throw(DayTimeException);

      DayTime& addSeconds(long seconds)
         throw(DayTimeException);

      DayTime& addMilliSeconds(long msec)
         throw(DayTimeException);

      DayTime& addMicroSeconds(long usec)
         throw(DayTimeException);

         // ----------- Part  6: member functions: comparisons ------------
         //
      bool operator==(const DayTime &right) const
         throw();
      bool operator!=(const DayTime &right) const
         throw();
      bool operator<(const DayTime &right) const
         throw();
      bool operator>(const DayTime &right) const
         throw();
      bool operator<=(const DayTime &right) const
         throw();
      bool operator>=(const DayTime &right) const
         throw();

         // ----------- Part  7: member functions: time frame ------------
         //
      DayTime& setAllButTimeFrame(const DayTime& right) 
         throw(DayTimeException);
      
      DayTime& setTimeFrame(TimeFrame f)
         throw()
      { timeFrame = f ; return *this ; }
      
      TimeFrame getTimeFrame() const 
         throw() 
      { return timeFrame ; }

         // ----------- Part  8: member functions: get --------------
         // 
         // These routines retrieve elements of day, time or both.
         //
      double JD() const
         throw();

      double MJD() const
         throw();

      short year() const
         throw();

      short month() const
         throw();

      short day() const
         throw();

      short dayOfWeek() const
         throw();

      void getYMD(int& yy, int& mm, int& dd) const 
         throw() 
      { convertJDtoCalendar(jday, yy, mm, dd) ; }

      short hour() const
         throw();

      short minute() const
         throw();

      double second() const
         throw();

      double secOfDay() const
         throw() 
      { return (double(mSod) + mSec) / FACTOR ; }

      short GPS10bitweek() const
         throw();

      long GPSzcount() const
         throw();

      long GPSzcountFloor() const
         throw();

      double GPSsecond() const
         throw() 
      { return GPSsow(); }

      double GPSsow() const
         throw();

      short GPSday() const
         throw() 
      { return dayOfWeek(); }

      short GPSfullweek() const
         throw();

      short GPSyear() const
         throw() 
      { return year(); }

      short DOYyear() const
         throw() 
      { return year(); }

      short DOYday() const
         throw() 
      { return DOY(); }

      short DOY() const
         throw();

      double DOYsecond() const
         throw() 
      { return secOfDay(); }

      double MJDdate() const
         throw() 
      { return double(getMJDasLongDouble()) ; }

      long double getMJDasLongDouble() const
         throw();

      struct timeval unixTime() const
         throw(DayTimeException);

      unsigned long fullZcount() const
         throw();

      unsigned long fullZcountFloor() const
         throw();

      operator GPSZcount() const
         throw(DayTimeException) ;

      operator CommonTime() const
         throw(DayTimeException);

         // ----------- Part  9: member functions: set ------------
         //
      DayTime& setYMDHMS(short year,
                         short month,
                         short day, 
                         short hour, 
                         short min,
                         double sec, 
                         TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setGPS(short week,
                      double sow, 
                      TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setGPS(short week, 
                      long zcount, 
                      TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setGPS(short week, 
                      long zcount,
                      short year, 
                      TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setGPS(short week, 
                      double sow,
                      short year, 
                      TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setGPS(unsigned long Zcount, 
                      TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setGPSfullweek(short fullweek,
                              double sow,
                              TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setGPSfullweek(short fullweek,
                              long zcount, 
                              TimeFrame f = Unknown)
         throw(DayTimeException)
      { return setGPSfullweek(fullweek, double(zcount) * 1.5, f) ; }

      DayTime& setGPSZcount(const GPSZcount& z,
                            TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setCommonTime(const CommonTime& c,
                             TimeFrame f = Unknown)
         throw();

      DayTime& setYDoySod(short year,
                          short day_of_year, 
                          double sec_of_day, 
                          TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setMJD(long double mjd,
                      TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setMJDdate(long double mjd, 
                          TimeFrame f = Unknown)
         throw(DayTimeException) 
      { return setMJD(mjd, f); }

      DayTime& setMJD(double mjd, 
                      TimeFrame f = Unknown)
         throw(DayTimeException)
      { return setMJD((long double)(mjd), f) ; }

      DayTime& setMJDdate(double mjd, 
                          TimeFrame f = Unknown)
         throw(DayTimeException)
      { return setMJD((long double)(mjd), f) ; }

      DayTime& setUnix(const struct timeval& t, 
                       TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setANSI(const time_t& t,
                       TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setSystemTime()
         throw(DayTimeException);

      DayTime& setLocalTime()
         throw(DayTimeException);

      DayTime& setYMD(int yy,
                      int mm,
                      int dd,
                      TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setHMS(int hh,
                      int mm,
                      double sec, 
                      TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setSecOfDay(double sod,
                           TimeFrame f = Unknown)
         throw(DayTimeException);

      DayTime& setYDoy(int yy,
                       int doy,
                       TimeFrame f = Unknown)
         throw(DayTimeException);

         // ----------- Part 10: member functions: setToString, printf --------
         //
         // FIX someone figure out how to make the table below show up
         // nice in doxygen.
      DayTime& setToString(const std::string& str, 
                           const std::string& fmt)
         throw(DayTimeException, FormatException,
               gpstk::StringUtils::StringException);


         // if you can see this, ignore the \'s below, as they are for
         // the nasty html-ifying of doxygen.  Browsers try and
         // interpret the % and they get all messed up.
      std::string printf(const char *fmt) const
         throw(gpstk::StringUtils::StringException);

      std::string printf(const std::string& fmt) const
         throw(gpstk::StringUtils::StringException) 
      { return printf(fmt.c_str()) ; }

      std::string toString(int decimals=0,char datesep='-', char timesep=':') const
         throw(gpstk::StringUtils::StringException);
      

      std::string asString() const
         throw(gpstk::StringUtils::StringException);

      void dump(std::ostream& s) const
         throw(DayTimeException);

      void update() { setSystemTime(); }

      double elapsed() const {return ( DayTime() - (*this) );}

      bool isElapsed(double interval) const 
      { return elapsed()>interval?true:false; }


         // ----------- Part 11: functions: fundamental conversions ----------
         // 
      static void convertJDtoCalendar(long jd, 
                                      int& iyear, 
                                      int& imonth, 
                                      int& iday)
         throw();

      static long convertCalendarToJD(int iyear, 
                                      int imonth,
                                      int iday) 
         throw();

      static void convertSODtoTime(double sod,
                                   int& hh, 
                                   int& mm, 
                                   double& sec) 
         throw();

      static double convertTimeToSOD(int hh,
                                     int mm, 
                                     double sec) 
         throw();

         // ----------- Part 12: private functions and member data ----------
         //
   private:
      void init() 
         throw();

      DayTime(long jd,
              long sod,
              double ms,
              double tol, 
              TimeFrame f = Unknown)
         throw() 
            : jday(jd), mSod(sod), mSec(ms), tolerance(tol), timeFrame(f) 
      {}

      void addLongDeltaTime(long ldd,
                            long lds, 
                            double ds)
         throw(DayTimeException);
         
      void realignInternals(void)
         throw();

      long jday; 
          
      long mSod;           

      double mSec;         

      double tolerance;    

      TimeFrame timeFrame; 

   };   // end class DayTime

      // ----------- Part 13: operator<< -----------
      //
   std::ostream& operator<<( std::ostream& s,
                             const gpstk::DayTime& t );


}  // namespace gpstk

#endif   // GPSTK_DAYTIME_HPP

---