base1. Timestamp时间戳类

Timestamp类图

数据成员：
static const int kMicroSecondsPerSecond：微秒与秒之间的进制关系
int64_t microSecondsSinceEpoch_：从1970年1月1日起至当前的微秒数

成员函数：
Timestamp()：构造一个microSecondsSinceEpoch_==0的失效时间戳
Timestamp(int64_t microSecondsSinceEpoch)：构造一个microSecondsSinceEpoch_==microSecondsSinceEpoch的时间戳
void swap(Timestamp& that)：交换that与this的时间戳
string toString() const：将microSecondsSinceEpoch_转换为一个字符串
string toFormattedString() const：将microSecondsSinceEpoch_转换成一个格式化的字符串
bool valid() const：判断时间戳是否有效
int64_t microSecondsSinceEpoch() const：获取microSecondsSinceEpoch_的值
time_t secondsSinceEpoch() const：获取将microSecondsSinceEpoch_转换成秒的值
static Timestamp now()：获取当前时间的时间戳
static Timestamp invalid()：获取一个microSecondsSinceEpoch_=0的失效时间戳

Timestamp.h

//Timestamp.h

#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
{

///
/// Time stamp in UTC, in microseconds resolution.
///
/// This class is immutable.
/// It's recommended to pass it by value, since it's passed in register on x64.
///
/*
值语意：可以拷贝，拷贝之后与原对象脱离关系
对象语义：分为不可以拷贝的和可以拷贝的，但拷贝后与原对象仍存在一定关系，比如共享底层资源
muduo::copyable 空基类，标识类，表示其为值类型，可以拷贝
boost::less_than_comparable 模板类，要求实现<操作符，之后可自动实现>,<=,>=
*/
class Timestamp : public muduo::copyable,
                  public boost::less_than_comparable<Timestamp>
{
 public:
  ///
  /// Constucts an invalid Timestamp.
  ///
  //构造一个失效的时间戳
  Timestamp()
    : microSecondsSinceEpoch_(0)
  {
  }

  ///
  /// Constucts a Timestamp at specific time
  ///
  /// @param microSecondsSinceEpoch
  explicit Timestamp(int64_t microSecondsSinceEpoch);
  //that为引用
  void swap(Timestamp& that)
  {
    std::swap(microSecondsSinceEpoch_, that.microSecondsSinceEpoch_);
  }

  // default copy/assignment/dtor are Okay
  //将microSecondsSinceEpoch_转换为一个字符串
  string toString() const;
  //将microSecondsSinceEpoch_转换成一个格式化的字符串
  string toFormattedString() const;

  bool valid() const { return microSecondsSinceEpoch_ > 0; }

  // for internal usage.
  int64_t microSecondsSinceEpoch() const { return microSecondsSinceEpoch_; }
  time_t secondsSinceEpoch() const
  { return static_cast<time_t>(microSecondsSinceEpoch_ / kMicroSecondsPerSecond); }

  ///
  /// Get time of now.
  ///
  //获得当前时间距离1970.1.1号的微秒数
  static Timestamp now();
  //获取一个microSecondsSinceEpoch_=0的失效时间戳
  static Timestamp invalid();

  static const int kMicroSecondsPerSecond = 1000 * 1000;

 private:
  int64_t microSecondsSinceEpoch_;
};
//实现<操作符
inline bool operator<(Timestamp lhs, Timestamp rhs)
{
  return lhs.microSecondsSinceEpoch() < rhs.microSecondsSinceEpoch();
}
//实现==操作符
inline bool operator==(Timestamp lhs, Timestamp rhs)
{
  return lhs.microSecondsSinceEpoch() == rhs.microSecondsSinceEpoch();
}

///
/// Gets time difference of two timestamps, result in seconds.
///
/// @param high, low
/// @return (high-low) in seconds
/// @c double has 52-bit precision, enough for one-microseciond
/// resolution for next 100 years.
//返回high与low之间相差的秒数
inline double timeDifference(Timestamp high, Timestamp low)
{
  int64_t diff = high.microSecondsSinceEpoch() - low.microSecondsSinceEpoch();
  return static_cast<double>(diff) / Timestamp::kMicroSecondsPerSecond;
}

///
/// Add @c seconds to given timestamp.
///
/// @return timestamp+seconds as Timestamp
///
//在timestamp的基础上加上seconds秒
inline Timestamp addTime(Timestamp timestamp, double seconds)
{
  int64_t delta = static_cast<int64_t>(seconds * Timestamp::kMicroSecondsPerSecond);
  return Timestamp(timestamp.microSecondsSinceEpoch() + delta);
}

}
#endif  // MUDUO_BASE_TIMESTAMP_H

Timestamp.cc

//Timestamp.cc
#include <muduo/base/Timestamp.h>

#include <sys/time.h>
#include <stdio.h>
//跨平台打印int64_t
//<inttypes.h>里面包含了PRId64宏
#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#undef __STDC_FORMAT_MACROS

#include <boost/static_assert.hpp>



using namespace muduo;
//宏：BOOST_STATIC_ASSERT 编译时断言（assert是运行时断言）
//与类大小有关的因素：普通成员变量，虚函数，继承（单一继承，多重继承，重复继承，虚拟继承）
//与类大小无关的因素：静态成员变量，静态成员函数及普通成员函数
BOOST_STATIC_ASSERT(sizeof(Timestamp) == sizeof(int64_t));

Timestamp::Timestamp(int64_t microseconds)
  : microSecondsSinceEpoch_(microseconds)
{
}

string Timestamp::toString() const
{
  char buf[32] = {0};
  int64_t seconds = microSecondsSinceEpoch_ / kMicroSecondsPerSecond;
  int64_t microseconds = microSecondsSinceEpoch_ % kMicroSecondsPerSecond;
  //跨平台打印int64_t
  snprintf(buf, sizeof(buf)-1, "%" PRId64 ".%06" PRId64 "", seconds, microseconds);
  return buf;
}

string Timestamp::toFormattedString() const
{
  char buf[32] = {0};
  time_t seconds = static_cast<time_t>(microSecondsSinceEpoch_ / kMicroSecondsPerSecond);
  int microseconds = static_cast<int>(microSecondsSinceEpoch_ % kMicroSecondsPerSecond);
  struct tm tm_time;
  //_r表示是线程安全的函数，把seconds转换为一个tm_time的结构体
  gmtime_r(&seconds, &tm_time);
  //转换为格式化字符串，存到buf中
  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);
  return buf;
}

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

Timestamp Timestamp::invalid()
{
  return Timestamp();
}