CommonTime.hpp

Go to the documentation of this file.

#pragma ident "$Id: CommonTime.hpp 3180 2012-06-29 19:37:14Z snelsen $"

#ifndef GPSTK_COMMONTIME_HPP
#define GPSTK_COMMONTIME_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., 51 Franklin Street, Fifth Floor, Boston, MA 02110, 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 "Exception.hpp"
#include "TimeConstants.hpp"
#include "TimeSystem.hpp"

namespace gpstk
{
   class CommonTime
   {
     public:

      static const long BEGIN_LIMIT_JDAY;
      static const long END_LIMIT_JDAY;

      static const CommonTime BEGINNING_OF_TIME;
      static const CommonTime END_OF_TIME;

      static const double eps;


      explicit CommonTime(TimeSystem timeSystem = TimeSystem::Unknown )
         throw( InvalidParameter )
      { set( 0, 0, 0.0, timeSystem ); }

      CommonTime( const CommonTime& right )
         throw();

      CommonTime& operator=( const CommonTime& right )
         throw();
      
      virtual ~CommonTime()
         throw()
      {}


      CommonTime& set( long day, 
                       long sod,
                       double fsod = 0.0,
                       TimeSystem timeSystem = TimeSystem::Unknown )
         throw( InvalidParameter );

      CommonTime& set( long day,
                       double sod = 0.0,
                       TimeSystem timeSystem = TimeSystem::Unknown )
         throw( InvalidParameter );
      
      CommonTime& set( double day,
                       TimeSystem timeSys = TimeSystem::Unknown )
         throw( InvalidParameter );

      CommonTime& setInternal( long day = 0,
                               long msod = 0,
                               double fsod = 0.0,
                               TimeSystem timeSys = TimeSystem::Unknown )
         throw( InvalidParameter );

      void setTimeSystem( const TimeSystem& timeSystem )
         throw()
      { m_timeSystem = timeSystem; }

      void get( long& day, 
                long& sod,
                double& fsod,
                TimeSystem& timeSystem ) const
         throw();

      void get( long& day, 
                long& sod,
                double& fsod ) const
         throw();

      void get( long& day,
                double& sod,
                TimeSystem& timeSystem ) const
         throw();

      void get( long& day,
                double& sod ) const
         throw();

      void get( double& day,
                TimeSystem& timeSystem ) const
         throw();

      void get( double& day ) const
         throw();

      void getInternal( long& day,
                        long& msod,
                        double& fsod,
                        TimeSystem& timeSystem ) const
         throw()
      { day = m_day; msod = m_msod; fsod = m_fsod; timeSystem = m_timeSystem; }

      void getInternal( long& day,
                        long& msod,
                        double& fsod ) const
         throw()
      { day = m_day; msod = m_msod; fsod = m_fsod; }

      double getDays() const 
         throw();

      double getSecondOfDay() const
         throw();

      TimeSystem getTimeSystem() const
         throw();


      double operator-( const CommonTime& right ) const
         throw( InvalidRequest );

      CommonTime operator+( double seconds ) const
         throw();

      CommonTime operator-( double seconds ) const
         throw();

      CommonTime& operator+=( double seconds )
         throw();

      CommonTime& operator-=( double seconds )
         throw();

      CommonTime& addSeconds( double seconds )
         throw();

      CommonTime& addDays( long days )
         throw();

      CommonTime& addSeconds( long seconds )
         throw();

      CommonTime& addMilliseconds( long ms )
         throw();

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

      void reset()
         throw()
      { m_day = m_msod = 0; m_fsod = 0.0; m_timeSystem = TimeSystem::Unknown; }

      std::string asString() const
         throw();

   protected:
      
      CommonTime( long day, 
                  long sod,
                  double fsod,
                  TimeSystem timeSystem = TimeSystem::Unknown )
         throw( InvalidParameter )
      { set( day, sod, fsod, timeSystem ); }
      
      bool add( long days,
                long msod,
                double fsod )
         throw();
      
      bool normalize()
         throw();
      
      long m_day;     
      long m_msod;    
      double m_fsod;  

      TimeSystem m_timeSystem; 

   }; // end class CommonTime

   std::ostream& operator<<(std::ostream& o, const CommonTime& ct);

} // namespace

#endif // GPSTK_COMMONTIME_HPP

---