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);
 
 
  MonoDelta& operator+=(const MonoDelta& delta);
 
  MonoDelta& operator-=(const MonoDelta& delta);
 
 private:
  static const int64_t kUninitialized;
 
  friend class MonoTime;
 
  friend MonoDelta operator-(const class MonoTime&, const class MonoTime&);
  friend MonoDelta operator-(const MonoDelta&, const MonoDelta&);
  friend MonoDelta operator+(const MonoDelta&, const MonoDelta&);
 
  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);
 
MonoDelta KUDU_EXPORT operator-(const MonoDelta& lhs, const MonoDelta& rhs);
 
MonoDelta 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