monotime.h

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
#ifndef KUDU_UTIL_MONOTIME_H
#define KUDU_UTIL_MONOTIME_H

// NOTE: using stdint.h instead of cstdint because this file is supposed
//       to be processed by a compiler lacking C++11 support.
#include <stdint.h>

#include <string>

#ifdef KUDU_HEADERS_NO_STUBS
#include <gtest/gtest_prod.h>

#include "kudu/gutil/port.h"
#else
// This is a poor module interdependency, but the stubs are header-only and
// it's only for exported header builds, so we'll make an exception.
#include "kudu/client/stubs.h"
#endif

#include "kudu/util/kudu_export.h"


// The 'noexcept' specifier is recognized by a C++11-capable compiler, but this
// file is targeted to compile by C++-98 compiler as well. As it turns out,
// adding 'noexcept' doesn't affect the generated symbols in the exported
// MonoTime class, so it's safe to turn it on when compiling in the C++11 mode.
// The 'noexcept' specified is useful in cases when wrapping MonoTime into
// std::atomic<> and the standard C++ library explicitly requires that.
#ifdef LANG_CXX11
#define KUDU_MONOTIME_NOEXCEPT noexcept
#else
#define KUDU_MONOTIME_NOEXCEPT
#endif // #ifdef LANG_CXX11 ... #else ...

namespace kudu {

class KUDU_EXPORT MonoDelta {
 public:
  static MonoDelta FromSeconds(double seconds);
  static MonoDelta FromMilliseconds(int64_t ms);
  static MonoDelta FromMicroseconds(int64_t us);
  static MonoDelta FromNanoseconds(int64_t ns);

  MonoDelta();

  bool Initialized() const;

  bool LessThan(const MonoDelta &rhs) const;

  bool MoreThan(const MonoDelta &rhs) const;

  bool Equals(const MonoDelta &rhs) const;

  std::string ToString() const;

  double ToSeconds() const;
  int64_t ToMilliseconds() const;
  int64_t ToMicroseconds() const;
  int64_t ToNanoseconds() const;

  void ToTimeVal(struct timeval *tv) const;

  void ToTimeSpec(struct timespec *ts) const;

  static void NanosToTimeSpec(int64_t nanos, struct timespec* ts);

 private:
  static const int64_t kUninitialized;

  friend class MonoTime;
  friend MonoDelta operator-(const class MonoTime&, const class MonoTime&);
  FRIEND_TEST(TestMonoTime, TestDeltaConversions);

  explicit MonoDelta(int64_t delta);
  int64_t nano_delta_;
};

class KUDU_EXPORT MonoTime {
 public:
  static const int64_t kNanosecondsPerSecond = 1000000000L;
  static const int64_t kNanosecondsPerMillisecond = 1000000L;
  static const int64_t kNanosecondsPerMicrosecond = 1000L;

  static const int64_t kMicrosecondsPerSecond = 1000000L;

  static MonoTime Now();

  static MonoTime Max();

  static MonoTime Min();

  static const MonoTime& Earliest(const MonoTime& a, const MonoTime& b)
      ATTRIBUTE_DEPRECATED("use std::min() instead");

  MonoTime() KUDU_MONOTIME_NOEXCEPT;

  bool Initialized() const;

  MonoDelta GetDeltaSince(const MonoTime &rhs) const ATTRIBUTE_DEPRECATED(
      "use kudu::operator-(const MonoTime&, const MonoTime&) instead");

  void AddDelta(const MonoDelta &delta);

  bool ComesBefore(const MonoTime &rhs) const;

  std::string ToString() const;

  void ToTimeSpec(struct timespec* ts) const;

  bool Equals(const MonoTime& other) const;

  MonoTime& operator+=(const MonoDelta& delta);

  MonoTime& operator-=(const MonoDelta& delta);

 private:
  friend class MonoDelta;
  friend MonoDelta operator-(const MonoTime&, const MonoTime&);
  FRIEND_TEST(TestMonoTime, TestTimeSpec);
  FRIEND_TEST(TestMonoTime, TestDeltaConversions);

  explicit MonoTime(const struct timespec &ts) KUDU_MONOTIME_NOEXCEPT;
  explicit MonoTime(int64_t nanos) KUDU_MONOTIME_NOEXCEPT;
  double ToSeconds() const;
  int64_t nanos_;
};

void KUDU_EXPORT SleepFor(const MonoDelta& delta);

bool KUDU_EXPORT operator==(const MonoDelta &lhs, const MonoDelta &rhs);

bool KUDU_EXPORT operator!=(const MonoDelta &lhs, const MonoDelta &rhs);

bool KUDU_EXPORT operator<(const MonoDelta &lhs, const MonoDelta &rhs);

bool KUDU_EXPORT operator<=(const MonoDelta &lhs, const MonoDelta &rhs);

bool KUDU_EXPORT operator>(const MonoDelta &lhs, const MonoDelta &rhs);

bool KUDU_EXPORT operator>=(const MonoDelta &lhs, const MonoDelta &rhs);

bool KUDU_EXPORT operator==(const MonoTime& lhs, const MonoTime& rhs);

bool KUDU_EXPORT operator!=(const MonoTime& lhs, const MonoTime& rhs);

bool KUDU_EXPORT operator<(const MonoTime& lhs, const MonoTime& rhs);

bool KUDU_EXPORT operator<=(const MonoTime& lhs, const MonoTime& rhs);

bool KUDU_EXPORT operator>(const MonoTime& lhs, const MonoTime& rhs);

bool KUDU_EXPORT operator>=(const MonoTime& lhs, const MonoTime& rhs);

MonoTime KUDU_EXPORT operator+(const MonoTime& t, const MonoDelta& delta);

MonoTime KUDU_EXPORT operator-(const MonoTime& t, const MonoDelta& delta);

MonoDelta KUDU_EXPORT operator-(const MonoTime& t_end, const MonoTime& t_begin);

} // namespace kudu

#endif