Removed linux_code
Change-Id: I7327828d2c9efdf03172d1b90f49d5c51fbba86e
diff --git a/aos/complex_thread_local.h b/aos/complex_thread_local.h
new file mode 100644
index 0000000..224d3b2
--- /dev/null
+++ b/aos/complex_thread_local.h
@@ -0,0 +1,131 @@
+#ifndef AOS_COMPLEX_THREAD_LOCAL_H_
+#define AOS_COMPLEX_THREAD_LOCAL_H_
+
+#include <assert.h>
+
+#include <type_traits>
+#include <utility>
+
+namespace aos {
+
+// Instances form a (per-thread) list of destructor functions to call when the
+// thread exits.
+// Only ComplexThreadLocal should use this.
+struct ComplexThreadLocalDestructor {
+ // Adds this to the list of destructors in this thread.
+ void Add();
+ // Removes this from the list of destructors in this thread. ::aos::Dies if it
+ // is not there.
+ void Remove();
+
+ void (*function)(void *);
+ void *param;
+
+ ComplexThreadLocalDestructor *next;
+};
+
+// Handles creating a thread-local (per type) object with non-trivial
+// constructor and/or destructor. It will be correctly destroyed on thread exit.
+//
+// Each thread using an instantiation of this class has its own independent slot
+// for storing a T. An instance of T is not actually constructed until a thread
+// calls Create, after which a pointer to it will be returned from get() etc
+// until after Clear is called.
+//
+// Example usage:
+// class Something {
+// private:
+// class Data {
+// public:
+// Data(const ::std::string &value) : value_(value) {}
+//
+// int DoSomething() {
+// if (cached_result_ == 0) {
+// // Do something expensive with value_ and store it in
+// // cached_result_.
+// }
+// return cached_result_;
+// }
+//
+// private:
+// const ::std::string value_;
+// int cached_result_ = 0;
+// };
+// ComplexThreadLocal<Data> thread_local_;
+// ::std::string a_string_;
+//
+// int DoSomething() {
+// thread_local_.Create(a_string_);
+// return thread_local_->DoSomething();
+// }
+// };
+//
+// The current implementation is based on
+// <http://stackoverflow.com/questions/12049684/gcc-4-7-on-linux-pthreads-nontrivial-thread-local-workaround-using-thread-n>.
+// TODO(brians): Change this to just simple standard C++ thread_local once all
+// of our compilers have support.
+template <typename T>
+class ComplexThreadLocal {
+ public:
+ // Actually creates the object in this thread if there is not one there
+ // already.
+ // args are all perfectly forwarded to the constructor.
+ template <typename... Args>
+ void Create(Args &&... args) {
+ if (initialized) return;
+ new (&storage) T(::std::forward<Args>(args)...);
+ destructor.function = PlacementDelete;
+ destructor.param = &storage;
+ destructor.Add();
+ initialized = true;
+ }
+
+ // Removes the object in this thread (if any), including calling its
+ // destructor.
+ void Clear() {
+ if (!initialized) return;
+ destructor.Remove();
+ PlacementDelete(&storage);
+ initialized = false;
+ }
+
+ // Returns true if there is already an object in this thread.
+ bool created() const { return initialized; }
+
+ // Returns the object currently created in this thread or nullptr.
+ T *operator->() const {
+ return get();
+ }
+ T *get() const {
+ if (initialized) {
+ return static_cast<T *>(static_cast<void *>(&storage));
+ } else {
+ return nullptr;
+ }
+ }
+
+ private:
+ typedef typename ::std::aligned_storage<
+ sizeof(T), ::std::alignment_of<T>::value>::type Storage;
+
+ // Convenient helper for calling a destructor.
+ static void PlacementDelete(void *t) { static_cast<T *>(t)->~T(); }
+
+ // True iff this storage has been initialized.
+ static __thread bool initialized;
+ // Where we actually store the object for this thread (if any).
+ static __thread Storage storage;
+ // The linked list element representing this storage.
+ static __thread ComplexThreadLocalDestructor destructor;
+};
+
+template <typename T>
+__thread bool ComplexThreadLocal<T>::initialized;
+template <typename T>
+__thread typename ComplexThreadLocal<T>::Storage ComplexThreadLocal<T>::storage;
+template <typename T>
+__thread ComplexThreadLocalDestructor ComplexThreadLocal<T>::destructor;
+
+} // namespace aos
+
+#endif // AOS_COMPLEX_THREAD_LOCAL_H_