third_party/boost/include/boost/date_time/local_time_adjustor.hpp - webm/webmlive - Git at Google

 #ifndef DATE_TIME_LOCAL_TIME_ADJUSTOR_HPP__
 #define DATE_TIME_LOCAL_TIME_ADJUSTOR_HPP__

 /* Copyright (c) 2002,2003 CrystalClear Software, Inc.
  * Use, modification and distribution is subject to the
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland
  * $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $
  */

 /*! @file local_time_adjustor.hpp
   Time adjustment calculations for local times
 */

 #include <stdexcept>
 #include <boost/throw_exception.hpp>
 #include <boost/date_time/compiler_config.hpp>
 #include <boost/date_time/date_generators.hpp>
 #include <boost/date_time/dst_rules.hpp>
 #include <boost/date_time/time_defs.hpp> // boost::date_time::dst_flags
 #include <boost/date_time/special_defs.hpp> // not_a_date_time

 namespace boost {
   namespace date_time {


     //! Provides a base offset adjustment from utc
     template<class time_duration_type,
              short hours, unsigned short minutes = 0>
     class utc_adjustment
     {
     public:
       static time_duration_type local_to_utc_base_offset()
       {
         time_duration_type td(hours,minutes,0);
         return td.invert_sign();
       }
       static time_duration_type utc_to_local_base_offset()
       {
         return time_duration_type(hours,minutes,0);
       }
     };


     //! Allow sliding utc adjustment with fixed dst rules
     template<class time_type, class dst_rules>
     class dynamic_local_time_adjustor : public dst_rules
     {
     public:
       typedef typename time_type::time_duration_type time_duration_type;
       typedef typename time_type::date_type date_type;

       dynamic_local_time_adjustor(time_duration_type utc_offset) :
         utc_offset_(utc_offset)
       {}

       //! Presumes local time
       time_duration_type utc_offset(bool is_dst)
       {
         if (is_dst) {
           return utc_offset_ + this->dst_offset();
         }
         else {
           return utc_offset_;
         }

       }
     private:
       time_duration_type utc_offset_;

     };


     //! Embed the rules for local time adjustments at compile time
     template<class time_type, class dst_rules, class utc_offset_rules>
     class static_local_time_adjustor: public dst_rules, public utc_offset_rules
     {
     public:
       typedef typename time_type::time_duration_type time_duration_type;
       typedef typename time_type::date_type date_type;

       //! Calculates the offset from a utc time to local based on dst and utc offset
       /*! @param t UTC time to calculate offset to local time
        *  This adjustment depends on the following observations about the
        *  workings of the DST boundary offset.  Since UTC time labels are
        *  monotonically increasing we can determine if a given local time
        *  is in DST or not and therefore adjust the offset appropriately.
        *
        *  The logic is as follows.  Starting with UTC time use the offset to
        *  create a label for an non-dst adjusted local time.  Then call
        *  dst_rules::local_is_dst with the non adjust local time.  The
        *  results of this function will either unabiguously decide that
        *  the initial local time is in dst or return an illegal or
        *  ambiguous result.  An illegal result only occurs at the end
        *  of dst (where labels are skipped) and indicates that dst has
        *  ended.  An ambiguous result means that we need to recheck by
        *  making a dst adjustment and then rechecking.  If the dst offset
        *  is added to the utc time and the recheck proves non-ambiguous
        *  then we are past the boundary.  If it is still ambiguous then
        *  we are ahead of the boundary and dst is still in effect.
        *
        *  TODO -- check if all dst offsets are positive.  If not then
        *  the algorithm needs to check for this and reverse the
        *  illegal/ambiguous logic.
        */
       static time_duration_type utc_to_local_offset(const time_type& t)
       {
         //get initial local time guess by applying utc offset
         time_type initial = t + utc_offset_rules::utc_to_local_base_offset();
         time_is_dst_result dst_flag =
           dst_rules::local_is_dst(initial.date(), initial.time_of_day());
         switch(dst_flag) {
         case is_in_dst:        return utc_offset_rules::utc_to_local_base_offset() + dst_rules::dst_offset();
         case is_not_in_dst:    return utc_offset_rules::utc_to_local_base_offset();
         case invalid_time_label:return utc_offset_rules::utc_to_local_base_offset() + dst_rules::dst_offset();
         case ambiguous: {
           time_type retry = initial + dst_rules::dst_offset();
           dst_flag = dst_rules::local_is_dst(retry.date(), retry.time_of_day());
           //if still ambibuous then the utc time still translates to a dst time
           if (dst_flag == ambiguous) {
             return utc_offset_rules::utc_to_local_base_offset() + dst_rules::dst_offset();
           }
           // we are past the dst boundary
           else {
             return utc_offset_rules::utc_to_local_base_offset();
           }
         }
         }//case
         //TODO  better exception type
         boost::throw_exception(std::out_of_range("Unreachable case"));
         BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return time_duration_type(not_a_date_time)); // should never reach
       }

       //! Get the offset to UTC given a local time
       static time_duration_type local_to_utc_offset(const time_type& t,
                                                     date_time::dst_flags dst=date_time::calculate)
       {
         switch (dst) {
         case is_dst:
           return utc_offset_rules::local_to_utc_base_offset() - dst_rules::dst_offset();
         case not_dst:
           return utc_offset_rules::local_to_utc_base_offset();
         case calculate:
           time_is_dst_result res =
             dst_rules::local_is_dst(t.date(), t.time_of_day());
           switch(res) {
           case is_in_dst:      return utc_offset_rules::local_to_utc_base_offset() - dst_rules::dst_offset();
           case is_not_in_dst:      return utc_offset_rules::local_to_utc_base_offset();
           case ambiguous:          return utc_offset_rules::local_to_utc_base_offset();
           case invalid_time_label: break;
           }
         }
         boost::throw_exception(std::out_of_range("Time label invalid"));
         BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return time_duration_type(not_a_date_time)); // should never reach
       }


     private:

     };

     void dummy_to_prevent_msvc6_ice(); //why ask why?

     //! Template that simplifies the creation of local time calculator
     /*! Use this template to create the timezone to utc convertors as required.
      *
      *  This class will also work for other regions that don't use dst and
      *  have a utc offset which is an integral number of hours.
      *
      *  <b>Template Parameters</b>
      *  -time_type  -- Time class to use
      *  -utc_offset -- Number hours local time is adjust from utc
      *  -use_dst -- true (default) if region uses dst, false otherwise
      *  For example:
      *  @code
      *  //eastern timezone is utc-5
      typedef date_time::local_adjustor<ptime, -5, us_dst> us_eastern;
      typedef date_time::local_adjustor<ptime, -6, us_dst> us_central;
      typedef date_time::local_adjustor<ptime, -7, us_dst> us_mountain;
      typedef date_time::local_adjustor<ptime, -8, us_dst> us_pacific;
      typedef date_time::local_adjustor<ptime, -7, no_dst> us_arizona;
      @endcode

     */
     template<class time_type, short utc_offset, class dst_rule>
     class local_adjustor
     {
     public:
       typedef typename time_type::time_duration_type time_duration_type;
       typedef typename time_type::date_type date_type;
       typedef static_local_time_adjustor<time_type,
                                          dst_rule,
                                          utc_adjustment<time_duration_type,
                                                         utc_offset> > dst_adjustor;
       //! Convert a utc time to local time
       static time_type utc_to_local(const time_type& t)
       {
         time_duration_type td = dst_adjustor::utc_to_local_offset(t);
         return t + td;
       }
       //! Convert a local time to utc
       static time_type local_to_utc(const time_type& t,
                                     date_time::dst_flags dst=date_time::calculate)
       {
         time_duration_type td = dst_adjustor::local_to_utc_offset(t, dst);
         return t + td;
       }
     };


   } } //namespace date_time


 #endif
	#ifndef DATE_TIME_LOCAL_TIME_ADJUSTOR_HPP__
	#define DATE_TIME_LOCAL_TIME_ADJUSTOR_HPP__

	/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
	* Use, modification and distribution is subject to the
	* Boost Software License, Version 1.0. (See accompanying
	* file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
	* Author: Jeff Garland
	* $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $
	*/

	/*! @file local_time_adjustor.hpp
	Time adjustment calculations for local times
	*/

	#include <stdexcept>
	#include <boost/throw_exception.hpp>
	#include <boost/date_time/compiler_config.hpp>
	#include <boost/date_time/date_generators.hpp>
	#include <boost/date_time/dst_rules.hpp>
	#include <boost/date_time/time_defs.hpp> // boost::date_time::dst_flags
	#include <boost/date_time/special_defs.hpp> // not_a_date_time

	namespace boost {
	namespace date_time {


	//! Provides a base offset adjustment from utc
	template<class time_duration_type,
	short hours, unsigned short minutes = 0>
	class utc_adjustment
	{
	public:
	static time_duration_type local_to_utc_base_offset()
	{
	time_duration_type td(hours,minutes,0);
	return td.invert_sign();
	}
	static time_duration_type utc_to_local_base_offset()
	{
	return time_duration_type(hours,minutes,0);
	}
	};



	//! Allow sliding utc adjustment with fixed dst rules
	template<class time_type, class dst_rules>
	class dynamic_local_time_adjustor : public dst_rules
	{
	public:
	typedef typename time_type::time_duration_type time_duration_type;
	typedef typename time_type::date_type date_type;

	dynamic_local_time_adjustor(time_duration_type utc_offset) :
	utc_offset_(utc_offset)
	{}

	//! Presumes local time
	time_duration_type utc_offset(bool is_dst)
	{
	if (is_dst) {
	return utc_offset_ + this->dst_offset();
	}
	else {
	return utc_offset_;
	}

	}
	private:
	time_duration_type utc_offset_;

	};



	//! Embed the rules for local time adjustments at compile time
	template<class time_type, class dst_rules, class utc_offset_rules>
	class static_local_time_adjustor: public dst_rules, public utc_offset_rules
	{
	public:
	typedef typename time_type::time_duration_type time_duration_type;
	typedef typename time_type::date_type date_type;

	//! Calculates the offset from a utc time to local based on dst and utc offset
	/*! @param t UTC time to calculate offset to local time
	* This adjustment depends on the following observations about the
	* workings of the DST boundary offset. Since UTC time labels are
	* monotonically increasing we can determine if a given local time
	* is in DST or not and therefore adjust the offset appropriately.
	*
	* The logic is as follows. Starting with UTC time use the offset to
	* create a label for an non-dst adjusted local time. Then call
	* dst_rules::local_is_dst with the non adjust local time. The
	* results of this function will either unabiguously decide that
	* the initial local time is in dst or return an illegal or
	* ambiguous result. An illegal result only occurs at the end
	* of dst (where labels are skipped) and indicates that dst has
	* ended. An ambiguous result means that we need to recheck by
	* making a dst adjustment and then rechecking. If the dst offset
	* is added to the utc time and the recheck proves non-ambiguous
	* then we are past the boundary. If it is still ambiguous then
	* we are ahead of the boundary and dst is still in effect.
	*
	* TODO -- check if all dst offsets are positive. If not then
	* the algorithm needs to check for this and reverse the
	* illegal/ambiguous logic.
	*/
	static time_duration_type utc_to_local_offset(const time_type& t)
	{
	//get initial local time guess by applying utc offset
	time_type initial = t + utc_offset_rules::utc_to_local_base_offset();
	time_is_dst_result dst_flag =
	dst_rules::local_is_dst(initial.date(), initial.time_of_day());
	switch(dst_flag) {
	case is_in_dst: return utc_offset_rules::utc_to_local_base_offset() + dst_rules::dst_offset();
	case is_not_in_dst: return utc_offset_rules::utc_to_local_base_offset();
	case invalid_time_label:return utc_offset_rules::utc_to_local_base_offset() + dst_rules::dst_offset();
	case ambiguous: {
	time_type retry = initial + dst_rules::dst_offset();
	dst_flag = dst_rules::local_is_dst(retry.date(), retry.time_of_day());
	//if still ambibuous then the utc time still translates to a dst time
	if (dst_flag == ambiguous) {
	return utc_offset_rules::utc_to_local_base_offset() + dst_rules::dst_offset();
	}
	// we are past the dst boundary
	else {
	return utc_offset_rules::utc_to_local_base_offset();
	}
	}
	}//case
	//TODO better exception type
	boost::throw_exception(std::out_of_range("Unreachable case"));
	BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return time_duration_type(not_a_date_time)); // should never reach
	}

	//! Get the offset to UTC given a local time
	static time_duration_type local_to_utc_offset(const time_type& t,
	date_time::dst_flags dst=date_time::calculate)
	{
	switch (dst) {
	case is_dst:
	return utc_offset_rules::local_to_utc_base_offset() - dst_rules::dst_offset();
	case not_dst:
	return utc_offset_rules::local_to_utc_base_offset();
	case calculate:
	time_is_dst_result res =
	dst_rules::local_is_dst(t.date(), t.time_of_day());
	switch(res) {
	case is_in_dst: return utc_offset_rules::local_to_utc_base_offset() - dst_rules::dst_offset();
	case is_not_in_dst: return utc_offset_rules::local_to_utc_base_offset();
	case ambiguous: return utc_offset_rules::local_to_utc_base_offset();
	case invalid_time_label: break;
	}
	}
	boost::throw_exception(std::out_of_range("Time label invalid"));
	BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return time_duration_type(not_a_date_time)); // should never reach
	}


	private:

	};

	void dummy_to_prevent_msvc6_ice(); //why ask why?

	//! Template that simplifies the creation of local time calculator
	/*! Use this template to create the timezone to utc convertors as required.
	*
	* This class will also work for other regions that don't use dst and
	* have a utc offset which is an integral number of hours.
	*
	* <b>Template Parameters</b>
	* -time_type -- Time class to use
	* -utc_offset -- Number hours local time is adjust from utc
	* -use_dst -- true (default) if region uses dst, false otherwise
	* For example:
	* @code
	* //eastern timezone is utc-5
	typedef date_time::local_adjustor<ptime, -5, us_dst> us_eastern;
	typedef date_time::local_adjustor<ptime, -6, us_dst> us_central;
	typedef date_time::local_adjustor<ptime, -7, us_dst> us_mountain;
	typedef date_time::local_adjustor<ptime, -8, us_dst> us_pacific;
	typedef date_time::local_adjustor<ptime, -7, no_dst> us_arizona;
	@endcode

	*/
	template<class time_type, short utc_offset, class dst_rule>
	class local_adjustor
	{
	public:
	typedef typename time_type::time_duration_type time_duration_type;
	typedef typename time_type::date_type date_type;
	typedef static_local_time_adjustor<time_type,
	dst_rule,
	utc_adjustment<time_duration_type,
	utc_offset> > dst_adjustor;
	//! Convert a utc time to local time
	static time_type utc_to_local(const time_type& t)
	{
	time_duration_type td = dst_adjustor::utc_to_local_offset(t);
	return t + td;
	}
	//! Convert a local time to utc
	static time_type local_to_utc(const time_type& t,
	date_time::dst_flags dst=date_time::calculate)
	{
	time_duration_type td = dst_adjustor::local_to_utc_offset(t, dst);
	return t + td;
	}
	};


	} } //namespace date_time



	#endif