folly: avoid compile warning/failure due to lvalue-to-rvalue conversion

[folly.git] / folly / io / async / DelayedDestructionBase.h

diff --git a/folly/io/async/DelayedDestructionBase.h b/folly/io/async/DelayedDestructionBase.h
index bd68c1cb89daaccfd6c164ae76ae94633ff0384c..9375baa0ce266388a8827f19c357b95c3b0e2bdd 100644 (file)
--- a/folly/io/async/DelayedDestructionBase.h
+++ b/folly/io/async/DelayedDestructionBase.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,13 +18,14 @@
 
 #include <assert.h>
 #include <cstddef>
+#include <cstdint>
+#include <functional>
 #include <memory>
 #include <type_traits>
 #include <utility>
+
 #include <boost/noncopyable.hpp>
-#include <functional>
 #include <glog/logging.h>
-#include <inttypes.h>
 
 namespace folly {
 
@@ -37,7 +38,7 @@ namespace folly {
  *
  * Classes needing this functionality should:
  * - derive from DelayedDestructionBase directly
- * - pass a callback to onDestroy_ which'll be called before the object is
+ * - implement onDelayedDestroy which'll be called before the object is
  *   going to be destructed
  * - create a DestructorGuard object on the stack in each public method that
  *   may invoke a callback
@@ -93,7 +94,7 @@ class DelayedDestructionBase : private boost::noncopyable {
         assert(dd_->guardCount_ > 0);
         --dd_->guardCount_;
         if (dd_->guardCount_ == 0) {
-          dd_->onDestroy_(true);
+          dd_->onDelayedDestroy(true);
         }
       }
     }
@@ -213,14 +214,15 @@ class DelayedDestructionBase : private boost::noncopyable {
   }
 
   /**
-   * Implement onDestroy_ in subclasses.
-   * onDestroy_() is invoked when the object is potentially being destroyed.
+   * Implement onDelayedDestroy in subclasses.
+   * onDelayedDestroy() is invoked when the object is potentially being
+   * destroyed.
    *
    * @param delayed  This parameter is true if destruction was delayed because
-   *                 of a DestructorGuard object, or false if onDestroy_() is
-   *                 being called directly from the destructor.
+   *                 of a DestructorGuard object, or false if onDelayedDestroy()
+   *                 is being called directly from the destructor.
    */
-  std::function<void(bool)> onDestroy_;
+  virtual void onDelayedDestroy(bool delayed) = 0;
 
  private:
   /**
@@ -245,25 +247,25 @@ inline bool operator !=(
     const DelayedDestructionBase::DestructorGuard& right) {
   return left.get() != right.get();
 }
-inline bool operator ==(
+inline bool operator==(
     const DelayedDestructionBase::DestructorGuard& left,
-    std::nullptr_t right) {
-  return left.get() == right;
+    std::nullptr_t) {
+  return left.get() == nullptr;
 }
-inline bool operator ==(
-    std::nullptr_t left,
+inline bool operator==(
+    std::nullptr_t,
     const DelayedDestructionBase::DestructorGuard& right) {
-  return left == right.get();
+  return nullptr == right.get();
 }
-inline bool operator !=(
+inline bool operator!=(
     const DelayedDestructionBase::DestructorGuard& left,
-    std::nullptr_t right) {
-  return left.get() != right;
+    std::nullptr_t) {
+  return left.get() != nullptr;
 }
-inline bool operator !=(
-    std::nullptr_t left,
+inline bool operator!=(
+    std::nullptr_t,
     const DelayedDestructionBase::DestructorGuard& right) {
-  return left != right.get();
+  return nullptr != right.get();
 }
 
 template <typename LeftAliasType, typename RightAliasType>
@@ -279,27 +281,27 @@ inline bool operator !=(
   return left.get() != right.get();
 }
 template <typename LeftAliasType>
-inline bool operator ==(
+inline bool operator==(
     const DelayedDestructionBase::IntrusivePtr<LeftAliasType>& left,
-    std::nullptr_t right) {
-  return left.get() == right;
+    std::nullptr_t) {
+  return left.get() == nullptr;
 }
 template <typename RightAliasType>
-inline bool operator ==(
-    std::nullptr_t left,
+inline bool operator==(
+    std::nullptr_t,
     const DelayedDestructionBase::IntrusivePtr<RightAliasType>& right) {
-  return left == right.get();
+  return nullptr == right.get();
 }
 template <typename LeftAliasType>
-inline bool operator !=(
+inline bool operator!=(
     const DelayedDestructionBase::IntrusivePtr<LeftAliasType>& left,
-    std::nullptr_t right) {
-  return left.get() != right;
+    std::nullptr_t) {
+  return left.get() != nullptr;
 }
 template <typename RightAliasType>
-inline bool operator !=(
-    std::nullptr_t left,
+inline bool operator!=(
+    std::nullptr_t,
     const DelayedDestructionBase::IntrusivePtr<RightAliasType>& right) {
-  return left != right.get();
+  return nullptr != right.get();
 }
-} // folly
+} // namespace folly