Classes | Namespaces | Typedefs | Functions | Variables
time.h File Reference
#include <sys/time.h>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <ctime>
#include <ostream>
#include <string>
#include <type_traits>
#include <utility>
#include "absl/strings/string_view.h"
#include "absl/time/civil_time.h"
#include "absl/time/internal/cctz/include/cctz/time_zone.h"
Include dependency graph for time.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  absl::Time::Breakdown
 
struct  absl::TimeZone::CivilInfo
 
struct  absl::TimeZone::CivilTransition
 
class  absl::Duration
 
class  absl::Time
 
struct  absl::TimeConversion
 
struct  absl::TimeZone::TimeInfo
 
class  absl::TimeZone
 

Namespaces

 absl
 
 absl::time_internal
 

Typedefs

template<typename T >
using absl::time_internal::EnableIfFloat = typename std::enable_if< std::is_floating_point< T >::value, int >::type
 
template<typename T >
using absl::time_internal::EnableIfIntegral = typename std::enable_if< std::is_integral< T >::value||std::is_enum< T >::value, int >::type
 

Functions

Duration absl::AbsDuration (Duration d)
 
 absl::time_internal::bool ())
 
Duration absl::Ceil (const Duration d, const Duration unit)
 
absl::TimeConversion absl::ConvertDateTime (int64_t year, int mon, int day, int hour, int min, int sec, TimeZone tz)
 
Duration absl::DurationFromTimespec (timespec ts)
 
Duration absl::DurationFromTimeval (timeval tv)
 
double absl::FDivDuration (Duration num, Duration den)
 
TimeZone absl::FixedTimeZone (int seconds)
 
Duration absl::Floor (const Duration d, const Duration unit)
 
std::string absl::FormatDuration (Duration d)
 
std::string absl::FormatTime (const std::string &format, absl::Time t, absl::TimeZone tz)
 
std::string absl::FormatTime (absl::Time t, absl::TimeZone tz)
 
std::string absl::FormatTime (absl::Time t)
 
Time absl::FromChrono (const std::chrono::system_clock::time_point &tp)
 
constexpr Duration absl::FromChrono (const std::chrono::nanoseconds &d)
 
constexpr Duration absl::FromChrono (const std::chrono::microseconds &d)
 
constexpr Duration absl::FromChrono (const std::chrono::milliseconds &d)
 
constexpr Duration absl::FromChrono (const std::chrono::seconds &d)
 
constexpr Duration absl::FromChrono (const std::chrono::minutes &d)
 
constexpr Duration absl::FromChrono (const std::chrono::hours &d)
 
template<typename Rep , typename Period >
constexpr Duration absl::time_internal::FromChrono (const std::chrono::duration< Rep, Period > &d)
 
Time absl::FromCivil (CivilSecond ct, TimeZone tz)
 
Time absl::FromDateTime (int64_t year, int mon, int day, int hour, int min, int sec, TimeZone tz)
 
template<std::intmax_t N>
constexpr Duration absl::time_internal::FromInt64 (int64_t v, std::ratio< 1, N >)
 
constexpr Duration absl::time_internal::FromInt64 (int64_t v, std::ratio< 60 >)
 
constexpr Duration absl::time_internal::FromInt64 (int64_t v, std::ratio< 3600 >)
 
constexpr Time absl::FromTimeT (time_t t)
 
absl::Time absl::FromTM (const struct tm &tm, absl::TimeZone tz)
 
absl::Time absl::FromUDate (double udate)
 
absl::Time absl::FromUniversal (int64_t universal)
 
constexpr Time absl::time_internal::FromUnixDuration (Duration d)
 
constexpr Time absl::FromUnixMicros (int64_t us)
 
constexpr Time absl::FromUnixMillis (int64_t ms)
 
constexpr Time absl::FromUnixNanos (int64_t ns)
 
constexpr Time absl::FromUnixSeconds (int64_t s)
 
constexpr int64_t absl::time_internal::GetRepHi (Duration d)
 
constexpr uint32_t absl::time_internal::GetRepLo (Duration d)
 
constexpr Duration absl::Hours (int64_t n)
 
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration absl::Hours (T n)
 
int64_t absl::IDivDuration (Duration num, Duration den, Duration *rem)
 
int64_t absl::time_internal::IDivDuration (bool satq, const Duration num, const Duration den, Duration *rem)
 
constexpr Duration absl::InfiniteDuration ()
 
constexpr Time absl::InfiniteFuture ()
 
constexpr Time absl::InfinitePast ()
 
constexpr bool absl::time_internal::IsInfiniteDuration (Duration d)
 
template<typename T >
constexpr auto absl::time_internal::IsValidRep64 (int) -> decltype(int64_t
 
template<typename T >
constexpr auto absl::time_internal::IsValidRep64 (char) -> bool
 
bool absl::LoadTimeZone (const std::string &name, TimeZone *tz)
 
TimeZone absl::LocalTimeZone ()
 
constexpr Duration absl::time_internal::MakeDuration (int64_t hi, uint32_t lo)
 
constexpr Duration absl::time_internal::MakeDuration (int64_t hi, int64_t lo)
 
constexpr Duration absl::time_internal::MakeNormalizedDuration (int64_t sec, int64_t ticks)
 
Duration absl::time_internal::MakePosDoubleDuration (double n)
 
constexpr Duration absl::Microseconds (int64_t n)
 
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration absl::Microseconds (T n)
 
constexpr Duration absl::Milliseconds (int64_t n)
 
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration absl::Milliseconds (T n)
 
constexpr Duration absl::Minutes (int64_t n)
 
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration absl::Minutes (T n)
 
constexpr Duration absl::Nanoseconds (int64_t n)
 
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration absl::Nanoseconds (T n)
 
constexpr int64_t absl::time_internal::NegateAndSubtractOne (int64_t n)
 
constexpr bool absl::operator!= (Duration lhs, Duration rhs)
 
constexpr bool absl::operator!= (Time lhs, Time rhs)
 
Duration absl::operator% (Duration lhs, Duration rhs)
 
template<typename T >
Duration absl::operator* (Duration lhs, T rhs)
 
template<typename T >
Duration absl::operator* (T lhs, Duration rhs)
 
Duration absl::operator+ (Duration lhs, Duration rhs)
 
Time absl::operator+ (Time lhs, Duration rhs)
 
Time absl::operator+ (Duration lhs, Time rhs)
 
constexpr Duration absl::operator- (Duration d)
 
Duration absl::operator- (Duration lhs, Duration rhs)
 
Time absl::operator- (Time lhs, Duration rhs)
 
Duration absl::operator- (Time lhs, Time rhs)
 
template<typename T >
Duration absl::operator/ (Duration lhs, T rhs)
 
int64_t absl::operator/ (Duration lhs, Duration rhs)
 
constexpr bool absl::operator< (Duration lhs, Duration rhs)
 
constexpr bool absl::operator< (Time lhs, Time rhs)
 
std::ostream & absl::operator<< (std::ostream &os, Duration d)
 
std::ostream & absl::operator<< (std::ostream &os, Time t)
 
constexpr bool absl::operator<= (Duration lhs, Duration rhs)
 
constexpr bool absl::operator<= (Time lhs, Time rhs)
 
constexpr bool absl::operator== (Duration lhs, Duration rhs)
 
constexpr bool absl::operator== (Time lhs, Time rhs)
 
constexpr bool absl::operator> (Duration lhs, Duration rhs)
 
constexpr bool absl::operator> (Time lhs, Time rhs)
 
constexpr bool absl::operator>= (Duration lhs, Duration rhs)
 
constexpr bool absl::operator>= (Time lhs, Time rhs)
 
constexpr Duration absl::time_internal::OppositeInfinity (Duration d)
 
bool absl::ParseDuration (const std::string &dur_string, Duration *d)
 
bool absl::ParseFlag (const std::string &text, absl::Time *t, std::string *error)
 
bool absl::ParseFlag (const std::string &text, Duration *dst, std::string *)
 
bool absl::ParseTime (const std::string &format, const std::string &input, absl::Time *time, std::string *err)
 
bool absl::ParseTime (const std::string &format, const std::string &input, absl::TimeZone tz, absl::Time *time, std::string *err)
 
constexpr Duration absl::Seconds (int64_t n)
 
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration absl::Seconds (T n)
 
absl::Time absl::TimeFromTimespec (timespec ts)
 
absl::Time absl::TimeFromTimeval (timeval tv)
 
template<typename T >
absl::time_internal::ToChronoDuration (Duration d)
 
std::chrono::hours absl::ToChronoHours (Duration d)
 
std::chrono::microseconds absl::ToChronoMicroseconds (Duration d)
 
std::chrono::milliseconds absl::ToChronoMilliseconds (Duration d)
 
std::chrono::minutes absl::ToChronoMinutes (Duration d)
 
std::chrono::nanoseconds absl::ToChronoNanoseconds (Duration d)
 
std::chrono::seconds absl::ToChronoSeconds (Duration d)
 
std::chrono::system_clock::time_point absl::ToChronoTime (absl::Time t)
 
CivilDay absl::ToCivilDay (Time t, TimeZone tz)
 
CivilHour absl::ToCivilHour (Time t, TimeZone tz)
 
CivilMinute absl::ToCivilMinute (Time t, TimeZone tz)
 
CivilMonth absl::ToCivilMonth (Time t, TimeZone tz)
 
CivilSecond absl::ToCivilSecond (Time t, TimeZone tz)
 
CivilYear absl::ToCivilYear (Time t, TimeZone tz)
 
double absl::ToDoubleHours (Duration d)
 
double absl::ToDoubleMicroseconds (Duration d)
 
double absl::ToDoubleMilliseconds (Duration d)
 
double absl::ToDoubleMinutes (Duration d)
 
double absl::ToDoubleNanoseconds (Duration d)
 
double absl::ToDoubleSeconds (Duration d)
 
template<typename Ratio >
int64_t absl::time_internal::ToInt64 (Duration d, Ratio)
 
int64_t absl::time_internal::ToInt64 (Duration d, std::nano)
 
int64_t absl::time_internal::ToInt64 (Duration d, std::micro)
 
int64_t absl::time_internal::ToInt64 (Duration d, std::milli)
 
int64_t absl::time_internal::ToInt64 (Duration d, std::ratio< 1 >)
 
int64_t absl::time_internal::ToInt64 (Duration d, std::ratio< 60 >)
 
int64_t absl::time_internal::ToInt64 (Duration d, std::ratio< 3600 >)
 
int64_t absl::ToInt64Hours (Duration d)
 
int64_t absl::ToInt64Microseconds (Duration d)
 
int64_t absl::ToInt64Milliseconds (Duration d)
 
int64_t absl::ToInt64Minutes (Duration d)
 
int64_t absl::ToInt64Nanoseconds (Duration d)
 
int64_t absl::ToInt64Seconds (Duration d)
 
timespec absl::ToTimespec (Time t)
 
timespec absl::ToTimespec (Duration d)
 
time_t absl::ToTimeT (Time t)
 
timeval absl::ToTimeval (Time t)
 
timeval absl::ToTimeval (Duration d)
 
struct tm absl::ToTM (absl::Time t, absl::TimeZone tz)
 
double absl::ToUDate (Time t)
 
int64_t absl::ToUniversal (absl::Time t)
 
constexpr Duration absl::time_internal::ToUnixDuration (Time t)
 
int64_t absl::ToUnixMicros (Time t)
 
int64_t absl::ToUnixMillis (Time t)
 
int64_t absl::ToUnixNanos (Time t)
 
int64_t absl::ToUnixSeconds (Time t)
 
Duration absl::Trunc (Duration d, Duration unit)
 
constexpr Time absl::UniversalEpoch ()
 
constexpr Time absl::UnixEpoch ()
 
std::string absl::UnparseFlag (absl::Time t)
 
std::string absl::UnparseFlag (Duration d)
 
TimeZone absl::UTCTimeZone ()
 
constexpr Duration absl::ZeroDuration ()
 

Variables

constexpr int64_t absl::time_internal::kTicksPerNanosecond = 4
 
constexpr int64_t absl::time_internal::kTicksPerSecond = 1000 * 1000 * 1000 * kTicksPerNanosecond
 


abseil_cpp
Author(s):
autogenerated on Mon Feb 28 2022 21:31:22