/*
- * Copyright 2015 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.
* limitations under the License.
*/
-#ifndef FOLLY_MEMORY_H_
-#define FOLLY_MEMORY_H_
+#pragma once
#include <folly/Traits.h>
* @author Xu Ning (xning@fb.com)
*/
-#if __cplusplus >= 201402L || \
- defined __cpp_lib_make_unique && __cpp_lib_make_unique >= 201304L
+#if __cplusplus >= 201402L || __cpp_lib_make_unique >= 201304L || \
+ (__ANDROID__ && __cplusplus >= 201300L) || _MSC_VER >= 1900
/* using override */ using std::make_unique;
template <typename T, void(*f)(T*)>
struct static_function_deleter {
- void operator()(T* t) { f(t); }
+ void operator()(T* t) const {
+ f(t);
+ }
};
/**
*
* Useful when `T` is long, such as:
*
- * using T = foobar::cpp2::FooBarServiceAsyncClient;
+ * using T = foobar::FooBarAsyncClient;
*/
template <typename T, typename D>
std::shared_ptr<T> to_shared_ptr(std::unique_ptr<T, D>&& ptr) {
return std::shared_ptr<T>(std::move(ptr));
}
+/**
+ * to_weak_ptr
+ *
+ * Make a weak_ptr and return it from a shared_ptr without specifying the
+ * template type parameter and letting the compiler deduce it.
+ *
+ * So you can write this:
+ *
+ * auto wptr = to_weak_ptr(getSomethingShared<T>());
+ *
+ * Instead of this:
+ *
+ * auto wptr = weak_ptr<T>(getSomethingShared<T>());
+ *
+ * Useful when `T` is long, such as:
+ *
+ * using T = foobar::FooBarAsyncClient;
+ */
+template <typename T>
+std::weak_ptr<T> to_weak_ptr(const std::shared_ptr<T>& ptr) {
+ return std::weak_ptr<T>(ptr);
+}
+
+namespace detail {
+/**
+ * Not all STL implementations define ::free in a way that its address can be
+ * determined at compile time. So we must wrap ::free in a function whose
+ * address can be determined.
+ */
+inline void SysFree(void* p) {
+ ::free(p);
+}
+}
+
+using SysBufferDeleter = static_function_deleter<void, &detail::SysFree>;
+using SysBufferUniquePtr = std::unique_ptr<void, SysBufferDeleter>;
+inline SysBufferUniquePtr allocate_sys_buffer(size_t size) {
+ return SysBufferUniquePtr(::malloc(size));
+}
+
/**
* A SimpleAllocator must provide two methods:
*
*/
template <class T> struct IsArenaAllocator : std::false_type { };
-} // namespace folly
+/*
+ * folly::enable_shared_from_this
+ *
+ * To be removed once C++17 becomes a minimum requirement for folly.
+ */
+#if __cplusplus >= 201700L || \
+ __cpp_lib_enable_shared_from_this >= 201603L
+
+// Guaranteed to have std::enable_shared_from_this::weak_from_this(). Prefer
+// type alias over our own class.
+/* using override */ using std::enable_shared_from_this;
+
+#else
+
+/**
+ * Extends std::enabled_shared_from_this. Offers weak_from_this() to pre-C++17
+ * code. Use as drop-in replacement for std::enable_shared_from_this.
+ *
+ * C++14 has no direct means of creating a std::weak_ptr, one must always
+ * create a (temporary) std::shared_ptr first. C++17 adds weak_from_this() to
+ * std::enable_shared_from_this to avoid that overhead. Alas code that must
+ * compile under different language versions cannot call
+ * std::enable_shared_from_this::weak_from_this() directly. Hence this class.
+ *
+ * @example
+ * class MyClass : public folly::enable_shared_from_this<MyClass> {};
+ *
+ * int main() {
+ * std::shared_ptr<MyClass> sp = std::make_shared<MyClass>();
+ * std::weak_ptr<MyClass> wp = sp->weak_from_this();
+ * }
+ */
+template <typename T>
+class enable_shared_from_this : public std::enable_shared_from_this<T> {
+public:
+ constexpr enable_shared_from_this() noexcept = default;
+
+ std::weak_ptr<T> weak_from_this() noexcept {
+ return weak_from_this_<T>(this);
+ }
+
+ std::weak_ptr<T const> weak_from_this() const noexcept {
+ return weak_from_this_<T>(this);
+ }
+
+private:
+ // Uses SFINAE to detect and call
+ // std::enable_shared_from_this<T>::weak_from_this() if available. Falls
+ // back to std::enable_shared_from_this<T>::shared_from_this() otherwise.
+ template <typename U>
+ auto weak_from_this_(std::enable_shared_from_this<U>* base_ptr)
+ noexcept -> decltype(base_ptr->weak_from_this()) {
+ return base_ptr->weak_from_this();
+ }
+
+ template <typename U>
+ auto weak_from_this_(std::enable_shared_from_this<U> const* base_ptr)
+ const noexcept -> decltype(base_ptr->weak_from_this()) {
+ return base_ptr->weak_from_this();
+ }
+
+ template <typename U>
+ std::weak_ptr<U> weak_from_this_(...) noexcept {
+ try {
+ return this->shared_from_this();
+ } catch (std::bad_weak_ptr const&) {
+ // C++17 requires that weak_from_this() on an object not owned by a
+ // shared_ptr returns an empty weak_ptr. Sadly, in C++14,
+ // shared_from_this() on such an object is undefined behavior, and there
+ // is nothing we can do to detect and handle the situation in a portable
+ // manner. But in case a compiler is nice enough to implement C++17
+ // semantics of shared_from_this() and throws a bad_weak_ptr, we catch it
+ // and return an empty weak_ptr.
+ return std::weak_ptr<U>{};
+ }
+ }
-#endif /* FOLLY_MEMORY_H_ */
+ template <typename U>
+ std::weak_ptr<U const> weak_from_this_(...) const noexcept {
+ try {
+ return this->shared_from_this();
+ } catch (std::bad_weak_ptr const&) {
+ return std::weak_ptr<U const>{};
+ }
+ }
+};
+
+#endif
+
+} // namespace folly