home | help 
std::chrono..._conversion(3)   C++ Standard Libary  std::chrono..._conversion(3)

NAME
     std::chrono::clock_time_conversion - std::chrono::clock_time_conversion

Synopsis
	Defined in header <chrono>
	template< class Dest, class Source >  (since C++20)
	struct clock_time_conversion {};

	std::chrono::clock_time_conversion is a trait that specifies how to con-
     vert a
	std::chrono::time_point  of  the Source clock to that of the Dest clock.
     It does so by
	providing a const-callable operator() that accepts an argument of type
	std::chrono::time_point<Source, Duration> and returns a
	std::chrono::time_point<Dest, OtherDuration> that represents an  equiva-
     lent point in
	time.  The  duration  of  the  returned  time point is computed from the
     source duration
	in a manner that varies for each  specialization.  clock_time_conversion
     is normally
	only used indirectly, via std::chrono::clock_cast.

	A  program  may  specialize clock_time_conversion if at least one of the
     template
	parameters is a user-defined clock type.

	The primary template is an empty struct. The standard defines  the  fol-
     lowing
	specializations:

	template<  class  Clock >					     (1)
     (since C++20)
	struct clock_time_conversion<Clock, Clock>;
	template<>
	struct	clock_time_conversion<std::chrono::system_clock,	     (2)
     (since C++20)
	std::chrono::system_clock>;
	template<>
	struct	clock_time_conversion<std::chrono::utc_clock,		     (3)
     (since C++20)
	std::chrono::utc_clock>;
	template<>
	struct	clock_time_conversion<std::chrono::system_clock,	     (4)
     (since C++20)
	std::chrono::utc_clock>;
	template<>
	struct	clock_time_conversion<std::chrono::utc_clock,		     (5)
     (since C++20)
	std::chrono::system_clock>;
	template< class Clock  >					     (6)
     (since C++20)
	struct clock_time_conversion<Clock, std::chrono::system_clock>;
	template<  class  Clock >					     (7)
     (since C++20)
	struct clock_time_conversion<std::chrono::system_clock, Clock>;
	template< class Clock  >					     (8)
     (since C++20)
	struct clock_time_conversion<Clock, std::chrono::utc_clock>;
	template<  class  Clock >					     (9)
     (since C++20)
	struct clock_time_conversion<std::chrono::utc_clock, Clock>;

	1-3) Identity conversion: operator() returns a copy of the argument.
	4,5)	  Conversions	   between	 std::chrono::sys_time	     and
     std::chrono::utc_time: operator()
	calls		      std::chrono::utc_clock::to_sys		     and
     std::chrono::utc_clock::from_sys,
	respectively.
	6,7) Conversions to and from std::chrono::sys_time when  Clock	supports
     from_sys and
	to_sys:  operator()  calls  Clock::to_sys  and	Clock::from_sys, respec-
     tively.
	8,9) Conversions to and from std::chrono::utc_time when  Clock	supports
     from_utc and
	to_utc:  operator()  calls  Clock::to_utc  and	Clock::from_utc, respec-
     tively.

Member functions
	Each specialization has an implicitly-declared default constructor, copy
	constructor, move constructor, copy assignment operator, move assignment
     operator,
	and destructor.

     std::chrono::clock_time_conversion::operator()

	template< class Duration >

	std::chrono::time_point<Clock, Duration>		    (1)  (member
     of
									special-
     ization (1))
	    operator()( const std::chrono::time_point<Clock,
	Duration>& t ) const;
	template< class Duration >

	std::chrono::sys_time<Duration> 			     (2) (member
     of
									special-
     ization (2))
	    operator()( const std::chrono::sys_time<Duration> & t )
	const;
	template< class Duration >

	std::chrono::utc_time<Duration> 			    (3)  (member
     of
									special-
     ization (3))
	    operator()( const std::chrono::utc_time<Duration>& t )
	const;
	template< class Duration >

	std::chrono::sys_time<Duration> 			     (4) (member
     of
									special-
     ization (4))
	    operator()( const std::chrono::utc_time<Duration>& t )
	const;
	template< class Duration >

	std::chrono::utc_time<Duration> 			    (5)  (member
     of
									special-
     ization (5))
	    operator()( const std::chrono::sys_time<Duration>& t )
	const;
	template< class Duration >

	auto  operator()( const std::chrono::sys_time<Duration>& t ) (6) (member
     of
	const								special-
     ization (6))

	    -> decltype(Clock::from_sys(t));
	template< class Duration >

	auto operator()( const std::chrono::time_point<SourceClock, (7)  (member
     of
	Duration>& t ) const						special-
     ization (7))

	    -> decltype(Clock::to_sys(t));
	template< class Duration >

	auto  operator()( const std::chrono::utc_time<Duration>& t ) (8) (member
     of
	const								special-
     ization (8))

	    -> decltype(Clock::from_utc(t));
	template< class Duration >

	auto operator()( const std::chrono::time_point<Clock,	    (9)  (member
     of
	Duration>& t ) const						special-
     ization (9))

	    -> decltype(Clock::to_utc(t));

	Converts the argument std::chrono::time_point to the destination clock.

	1-3) Identity conversion. Returns t unchanged.
	4) Returns std::chrono::utc_clock::to_sys(t).
	5) Returns std::chrono::utc_clock::from_sys(t).
	6)  Returns  Clock::from_sys(t).  This overload participates in overload
     resolution
	only if the expression Clock::from_sys(t) is well-formed. The program is
     ill-formed
	if Clock::from_sys(t) does not return std::chrono::time_point<Clock, Du-
     ration> where
	Duration is some valid specialization of std::chrono::duration.
	7) Returns Clock::to_sys(t). This overload participates in overload res-
     olution only
	if the expression Clock::to_sys(t) is well-formed. The program	is  ill-
     formed if
	Clock::to_sys(t)  does	not return std::chrono::sys_time<Duration> where
     Duration is
	some valid specialization of std::chrono::duration.
	8) Returns Clock::from_utc(t). This overload  participates  in	overload
     resolution
	only if the expression Clock::from_utc(t) is well-formed. The program is
     ill-formed
	if Clock::from_utc(t) does not return std::chrono::time_point<Clock, Du-
     ration> where
	Duration is some valid specialization of std::chrono::duration.
	9) Returns Clock::to_utc(t). This overload participates in overload res-
     olution only
	if  the  expression Clock::to_utc(t) is well-formed. The program is ill-
     formed if
	Clock::to_utc(t) does not return  std::chrono::utc_time<Duration>  where
     Duration is
	some valid specialization of std::chrono::duration.

Parameters
	t - time point to convert

Return value
	The result of the conversion as described above:

	1-3) t.
	4) std::chrono::utc_clock::to_sys(t).
	5) std::chrono::utc_clock::from_sys(t).
	6) Clock::from_sys(t).
	7) Clock::to_sys(t).
	8) Clock::from_utc(t).
	9) Clock::to_utc(t).

See also
	clock_cast convert time points of one clock to another
	(C++20)    (function template)

http://cppreference.com 	   2024.06.10	    std::chrono..._conversion(3)
home | help