once.h

Go to the documentation of this file.

#ifndef ION_BASE_ONCE_H_
#define ION_BASE_ONCE_H_

#include <functional>

#include "base/integral_types.h"
#include "base/macros.h"
#include "ion/base/staticsafedeclare.h"
#include "ion/port/atomic.h"
#include "ion/port/macros.h"
#include "ion/port/threadutils.h"

namespace ion {
namespace base {

class ION_API OnceFlag {
 public:
  OnceFlag() : value_(init_value_) {}

  void CallOnce(const std::function<void()>& target);

  static void CallChecked(const std::function<bool()>& target) {
    if (!target()) {
      LOG(ERROR) << "CallOnce target returned false.";
    }
  }

 private:
  std::atomic<int32> value_;
  static const int32 init_value_ = 0;
  DISALLOW_COPY_AND_ASSIGN(OnceFlag);
};

template <typename T> class Lazy {
 public:
  explicit Lazy(const std::function<T()>& creator) : creator_(creator) {}

  Lazy(const Lazy<T>& other) : creator_(other.creator_) {}
  const T& Get() const {
    flag_.CallOnce(std::bind(&Lazy::Populate, this));
    return value_;
  }

 private:
  void Populate() const { value_ = creator_(); }

  std::function<T()> creator_;

  mutable T value_;

  mutable OnceFlag flag_;
  ION_DISALLOW_ASSIGN_ONLY(Lazy<T>);
};


inline void OnceFlag::CallOnce(const std::function<void()>& target) {
  const int32 running_value = 0x325ad493;
  const int32 done_value = 0x46f36511;
  if (value_.load(std::memory_order_acquire) == done_value) {
    return;
  }
  int32 expected_value = init_value_;
  if (value_.compare_exchange_strong(expected_value, running_value)) {
    target();
    value_ = done_value;
  } else if (expected_value != done_value) {
    while (value_ != done_value) {
      port::YieldThread();
    }
  }
}

}  // namespace base
}  // namespace ion

#define ION_STATIC_ONCE_CHECKED(function) \
    ION_STATIC_ONCE(std::bind(::ion::base::OnceFlag::CallChecked, &function));

#define ION_STATIC_ONCE(function) \
  do { \
    ION_DECLARE_SAFE_STATIC_POINTER(::ion::base::OnceFlag, s_once_flag_macro); \
    s_once_flag_macro->CallOnce(function); \
  } while (0)

#endif  // ION_BASE_ONCE_H_