* @author Spencer Ahrens (sahrens)
*/
-#ifndef FOLLY_THREADLOCAL_H_
-#define FOLLY_THREADLOCAL_H_
+#pragma once
+#include <folly/Likely.h>
#include <folly/Portability.h>
+#include <folly/ScopeGuard.h>
#include <boost/iterator/iterator_facade.hpp>
-#include <folly/Likely.h>
#include <type_traits>
-
+#include <utility>
namespace folly {
enum class TLPDestructionMode {
}
T* get() const {
- threadlocal_detail::ElementWrapper& w = StaticMeta::get(&id_);
+ threadlocal_detail::ElementWrapper& w = StaticMeta::instance().get(&id_);
return static_cast<T*>(w.ptr);
}
}
T* release() {
- threadlocal_detail::ElementWrapper& w = StaticMeta::get(&id_);
+ threadlocal_detail::ElementWrapper& w = StaticMeta::instance().get(&id_);
return static_cast<T*>(w.release());
}
void reset(T* newPtr = nullptr) {
- threadlocal_detail::ElementWrapper& w = StaticMeta::get(&id_);
+ auto guard = makeGuard([&] { delete newPtr; });
+ threadlocal_detail::ElementWrapper& w = StaticMeta::instance().get(&id_);
- if (w.ptr != newPtr) {
- w.dispose(TLPDestructionMode::THIS_THREAD);
- w.set(newPtr);
- }
+ w.dispose(TLPDestructionMode::THIS_THREAD);
+ guard.dismiss();
+ w.set(newPtr);
}
explicit operator bool() const {
return get() != nullptr;
}
+ /**
+ * reset() that transfers ownership from a smart pointer
+ */
+ template <
+ typename SourceT,
+ typename Deleter,
+ typename = typename std::enable_if<
+ std::is_convertible<SourceT*, T*>::value>::type>
+ void reset(std::unique_ptr<SourceT, Deleter> source) {
+ auto deleter = [delegate = source.get_deleter()](
+ T * ptr, TLPDestructionMode) {
+ delegate(ptr);
+ };
+ reset(source.release(), deleter);
+ }
+
+ /**
+ * reset() that transfers ownership from a smart pointer with the default
+ * deleter
+ */
+ template <
+ typename SourceT,
+ typename = typename std::enable_if<
+ std::is_convertible<SourceT*, T*>::value>::type>
+ void reset(std::unique_ptr<SourceT> source) {
+ reset(source.release());
+ }
+
/**
* reset() with a custom deleter:
* deleter(T* ptr, TLPDestructionMode mode)
* "mode" is ALL_THREADS if we're destructing this ThreadLocalPtr (and thus
* deleting pointers for all threads), and THIS_THREAD if we're only deleting
- * the member for one thread (because of thread exit or reset())
+ * the member for one thread (because of thread exit or reset()).
+ * Invoking the deleter must not throw.
*/
template <class Deleter>
- void reset(T* newPtr, Deleter deleter) {
- threadlocal_detail::ElementWrapper& w = StaticMeta::get(&id_);
- if (w.ptr != newPtr) {
- w.dispose(TLPDestructionMode::THIS_THREAD);
- w.set(newPtr, deleter);
- }
+ void reset(T* newPtr, const Deleter& deleter) {
+ auto guard = makeGuard([&] {
+ if (newPtr) {
+ deleter(newPtr, TLPDestructionMode::THIS_THREAD);
+ }
+ });
+ threadlocal_detail::ElementWrapper& w = StaticMeta::instance().get(&id_);
+ w.dispose(TLPDestructionMode::THIS_THREAD);
+ guard.dismiss();
+ w.set(newPtr, deleter);
}
// Holds a global lock for iteration through all thread local child objects.
class Accessor {
friend class ThreadLocalPtr<T,Tag>;
- threadlocal_detail::StaticMeta<Tag>& meta_;
+ threadlocal_detail::StaticMetaBase& meta_;
std::mutex* lock_;
uint32_t id_;
boost::bidirectional_traversal_tag> { // traversal
friend class Accessor;
friend class boost::iterator_core_access;
- const Accessor* const accessor_;
+ const Accessor* accessor_;
threadlocal_detail::ThreadEntry* e_;
void increment() {
Accessor accessAllThreads() const {
static_assert(!std::is_same<Tag, void>::value,
"Must use a unique Tag to use the accessAllThreads feature");
- return Accessor(id_.getOrAllocate());
+ return Accessor(id_.getOrAllocate(StaticMeta::instance()));
}
private:
void destroy() {
- StaticMeta::destroy(&id_);
+ StaticMeta::instance().destroy(&id_);
}
// non-copyable
};
} // namespace folly
-
-#endif /* FOLLY_THREADLOCAL_H_ */