Epoch.hpp

Go to the documentation of this file.

#pragma ident "$Id: Epoch.hpp 1163 2008-03-28 13:01:33Z snelsen $"



#ifndef GPSTK_EPOCH_HPP
#define GPSTK_EPOCH_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 "MathBase.hpp"
#include "Exception.hpp"
#include "StringUtils.hpp"

#include "GPSZcount.hpp"
#include "CommonTime.hpp"
#include "TimeTag.hpp"
#include "SystemTime.hpp"
#include "YDSTime.hpp"

namespace gpstk
{

   class Epoch
   {
   public:
      NEW_EXCEPTION_CLASS(EpochException, gpstk::Exception);
      
      NEW_EXCEPTION_CLASS(FormatException, gpstk::Exception);
      

      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 EPOCH_TOLERANCE;
      
      static const Epoch BEGINNING_OF_TIME;
      static const Epoch END_OF_TIME;

      static std::string PRINT_FORMAT;
      


      static double setEpochTolerance(double tol)
         throw()
      { return EPOCH_TOLERANCE = tol; }

      static double getEpochTolerance() 
         throw()
      { return EPOCH_TOLERANCE; }
   
      Epoch& setTolerance(double tol)
         throw();

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



      Epoch(const TimeTag& tt = SystemTime())
         throw(EpochException);

      Epoch(const CommonTime& ct)
         throw();

      Epoch(const TimeTag& tt,
            short year)
         throw(EpochException);

      Epoch(const GPSZcount& gzc)
         throw();
      
         // Other Constructors:
         // gps 29-bit zcount w/ epoch determined by current system time
         //     (GPSZcount29 + SystemTime)

      ~Epoch()
         throw()
      {}



      Epoch(const Epoch &right)
         throw();

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


      double operator-(const Epoch& right) const
         throw();

      Epoch operator+(double sec) const
         throw(EpochException);

      Epoch operator-(double sec) const
         throw(EpochException);

      Epoch& operator+=(double sec)
         throw(EpochException);

      Epoch& operator-=(double sec)
         throw(EpochException);

      Epoch& addSeconds(double seconds)
         throw(EpochException);

      Epoch& addSeconds(long seconds)
         throw(EpochException);

      Epoch& addMilliSeconds(long msec)
         throw(EpochException);

      Epoch& addMicroSeconds(long usec)
         throw(EpochException);


      bool operator==(const Epoch &right) const
         throw();
      bool operator!=(const Epoch &right) const
         throw();
      bool operator<(const Epoch &right) const
         throw();
      bool operator>(const Epoch &right) const
         throw();
      bool operator<=(const Epoch &right) const
         throw();
      bool operator>=(const Epoch &right) const
         throw();





      template <class TimeTagType>
      TimeTagType get() const
         throw(EpochException);

      inline long double JD() const
         throw(EpochException);

      inline long double MJD() const
         throw(EpochException);

      inline short year() const
         throw(EpochException);

      inline short month() const
         throw(EpochException);

      inline short day() const
         throw(EpochException);

      inline short dow() const
         throw(EpochException);

      inline short hour() const
         throw(EpochException);

      inline short minute() const
         throw(EpochException);

      inline double second() const
         throw(EpochException);

      inline double sod() const
         throw(EpochException);

      inline short GPSweek10() const
         throw(EpochException);

      inline long GPSzcount() const
         throw(EpochException);

      inline long GPSzcountFloor() const
         throw(EpochException);

      inline unsigned long GPSzcount32() const
         throw(EpochException);

      inline unsigned long GPSzcount32Floor() const
         throw(EpochException);

      inline double GPSsow() const
         throw(EpochException);

      inline short GPSweek() const
         throw(EpochException);

      inline short doy() const
         throw(EpochException);

      inline long double getMJDasLongDouble() const
         throw(EpochException);

      inline struct timeval unixTime() const
         throw(EpochException);

      operator GPSZcount() const
         throw(EpochException);

      operator CommonTime() const
         throw();


      Epoch& set(const TimeTag& tt = SystemTime())
         throw(EpochException);
      
      Epoch& set(const TimeTag& tt,
                 short year)
         throw(EpochException);
      
      Epoch& set(const CommonTime& c)
         throw();

      Epoch& set(const GPSZcount& z)
         throw(EpochException);

      Epoch& setTime(const CommonTime& ct)
         throw(EpochException);

      Epoch& setDate(const CommonTime& ct)
         throw(EpochException);

      Epoch& setLocalTime()
         throw(EpochException);

         // other sets:
         // ymdhms
         // week and sow (if week is 10-bit, set epoch from system time)
         // week and zcount (if week is 10-bit, set epoch from system time) 
         // week, zcount, year (if week is 10-bit, set epoch from given year)
         // week, sow, year  (if week is 10-bit, set epoch from given year)
         // gps 29-bit zcount (epoch determined by system time)
         // gps full week and sow
         // gps full week and zcount
         // year, doy, sod
         // long double mjd
         // double mjd
         // Unix struct timeval
         // ANSI time
         // YMD, (year/doy) w/ time unchanged
         // HMS, sod w/ date unchanged





      Epoch& scanf(const std::string& str, 
                   const std::string& fmt)
         throw(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 std::string& fmt = PRINT_FORMAT) const
         throw(StringUtils::StringException);

   private:



      CommonTime core;
      
      double tolerance;    
      
      short whichGPSEpoch(int week, int year) const
         throw(EpochException);
   };   // end class Epoch



   std::ostream& operator<<( std::ostream& s,
                             const Epoch& t );


}  // namespace gpstk

#endif   // GPSTK_EPOCH_HPP

---