muduo源码笔记-base-Timestamp

1. Timestamp.h 文件

Timestamp表示的是UTC时间，最小可表示微秒（us）。数据成员microSecondsSinceEpoch_使用int64_t（long long）表示对象，因此作者建议将此值按值传递，这样可以直接存放在寄存器中，提高访问速度。

#ifndef MUDUO_BASE_TIMESTAMP_H
#define MUDUO_BASE_TIMESTAMP_H

#include "muduo/base/copyable.h"
#include "muduo/base/Types.h"
#include <boost/operators.hpp>
namespace muduo
{
class Timestamp : public muduo::copyable,
                  public boost::equality_comparable<Timestamp>,
                  public boost::less_than_comparable<Timestamp>
{
 public:
  // 默认构造函数，   
  Timestamp()
    : microSecondsSinceEpoch_(0) {}
  // 使用特定时间的构造函数  
  explicit Timestamp(int64_t microSecondsSinceEpochArg)
    : microSecondsSinceEpoch_(microSecondsSinceEpochArg) {}
  // 交换两个Timestamp的值
  void swap(Timestamp& that)
  {
    std::swap(microSecondsSinceEpoch_, that.microSecondsSinceEpoch_);
  }

  // 使用默认的复制构造函数、赋值运算符、析构函数
  
  // 时间转换为字符串表示
  // 实例：1584364560.458500
  string toString() const;
  // 时间转换为格式化的字符串表示
  // 实例：20200316 13:16:00
  string toFormattedString(bool showMicroseconds = true) const;
  // 判断时间是否有效
  bool valid() const { return microSecondsSinceEpoch_ > 0; }

  // 返回微秒，仅供内部使用
  int64_t microSecondsSinceEpoch() const { return microSecondsSinceEpoch_; }
  // 返回秒数(time_t表示的是秒数)
  time_t secondsSinceEpoch() const
  { return static_cast<time_t>(microSecondsSinceEpoch_ / kMicroSecondsPerSecond); }

  // 获取当前时间
  static Timestamp now();
  static Timestamp invalid()
  {
    return Timestamp();
  }
  // 将time_t（秒）转换为Timestamp格式（微秒）
  static Timestamp fromUnixTime(time_t t)
  {
    return fromUnixTime(t, 0);
  }

  static Timestamp fromUnixTime(time_t t, int microseconds)
  {
    return Timestamp(static_cast<int64_t>(t) * kMicroSecondsPerSecond + microseconds);
  }
  // 静态成员变量，每秒多少微秒（10^6）
  static const int kMicroSecondsPerSecond = 1000 * 1000;

 private:
  // 微秒数，使用int64_t表示，可以直接存放寄存器，优化读取时间   
  int64_t microSecondsSinceEpoch_;
};
// 时间比较操作，由于继承自less_than_comparable<Timestamp>
// 因此需要提供 operator< ，其他 >、<=、>=会自动实现
inline bool operator<(Timestamp lhs, Timestamp rhs)
{
  return lhs.microSecondsSinceEpoch() < rhs.microSecondsSinceEpoch();
}
// 时间判等操作，由于继承自boost::equality_comparable<Timestamp>
// 因此需要提供 operator==操作，!=会自动实现
inline bool operator==(Timestamp lhs, Timestamp rhs)
{
  return lhs.microSecondsSinceEpoch() == rhs.microSecondsSinceEpoch();
}
// 计算两个时间戳相差的秒数
inline double timeDifference(Timestamp high, Timestamp low)
{
  int64_t diff = high.microSecondsSinceEpoch() - low.microSecondsSinceEpoch();
  return static_cast<double>(diff) / Timestamp::kMicroSecondsPerSecond;
}
// 实现时间戳+秒数
inline Timestamp addTime(Timestamp timestamp, double seconds)
{
  int64_t delta = static_cast<int64_t>(seconds * Timestamp::kMicroSecondsPerSecond);
  return Timestamp(timestamp.microSecondsSinceEpoch() + delta);
}
}  // namespace muduo
#endif  // MUDUO_BASE_TIMESTAMP_H

2. Timestamp.cc

#include "muduo/base/Timestamp.h"
#include <sys/time.h>  // time_t，gtime_r，gettimeofday
#include <stdio.h>
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif
// 跨平台的书写方式，主要是为了同时支持32位和64位操作系统。
// PRId64表示64位整数，在32位系统中表示long long int，在64位系统中表示long int
// 64位即lld，32位即ld
#include <inttypes.h>  // PRId64 

using namespace muduo;

static_assert(sizeof(Timestamp) == sizeof(int64_t),
              "Timestamp is same size as int64_t");
// 时间转换为字符串表示
string Timestamp::toString() const
{
  char buf[32] = {0};
  int64_t seconds = microSecondsSinceEpoch_ / kMicroSecondsPerSecond;
  int64_t microseconds = microSecondsSinceEpoch_ % kMicroSecondsPerSecond;
  snprintf(buf, sizeof(buf)-1, "%" PRId64 ".%06" PRId64 "", seconds, microseconds);
  return buf;
}
// 时间转换为格式化的字符串表示
string Timestamp::toFormattedString(bool showMicroseconds) const
{
  char buf[64] = {0};
  time_t seconds = static_cast<time_t>(microSecondsSinceEpoch_ / kMicroSecondsPerSecond);
  // 注意：tm是从1900年起的
  struct tm tm_time;
  gmtime_r(&seconds, &tm_time);

  if (showMicroseconds)
  {
    int microseconds = static_cast<int>(microSecondsSinceEpoch_ % kMicroSecondsPerSecond);
    snprintf(buf, sizeof(buf), "%4d%02d%02d %02d:%02d:%02d.%06d",
             tm_time.tm_year + 1900, tm_time.tm_mon + 1, tm_time.tm_mday,
             tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec,
             microseconds);
  }
  else
  {
    snprintf(buf, sizeof(buf), "%4d%02d%02d %02d:%02d:%02d",
             tm_time.tm_year + 1900, tm_time.tm_mon + 1, tm_time.tm_mday,
             tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec);
  }
  return buf;
}

Timestamp Timestamp::now()
{
  // timeval存了秒和微秒  
  struct timeval tv;
  gettimeofday(&tv, NULL);
  int64_t seconds = tv.tv_sec;
  return Timestamp(seconds * kMicroSecondsPerSecond + tv.tv_usec);
}