boost/thread/tss.hpp

   1 #ifndef BOOST_THREAD_TSS_HPP
   2 #define BOOST_THREAD_TSS_HPP
   3 // Distributed under the Boost Software License, Version 1.0. (See
   4 // accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6 // (C) Copyright 2007-8 Anthony Williams
   7
   8 #include <boost/thread/detail/config.hpp>
   9 #include <boost/shared_ptr.hpp>
  10 #include <boost/thread/detail/thread_heap_alloc.hpp>
  11
  12 #include <boost/config/abi_prefix.hpp>
  13
  14 namespace boost
  15 {
  16     namespace detail
  17     {
  18         struct tss_cleanup_function
  19         {
  20             virtual ~tss_cleanup_function()
  21             {}
  22
  23             virtual void operator()(void* data)=0;
  24         };
  25
  26         BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
  27         BOOST_THREAD_DECL void* get_tss_data(void const* key);
  28     }
  29
  30     template <typename T>
  31     class thread_specific_ptr
  32     {
  33     private:
  34         thread_specific_ptr(thread_specific_ptr&);
  35         thread_specific_ptr& operator=(thread_specific_ptr&);
  36
  37         struct delete_data:
  38             detail::tss_cleanup_function
  39         {
  40             void operator()(void* data)
  41             {
  42                 delete static_cast<T*>(data);
  43             }
  44         };
  45
  46         struct run_custom_cleanup_function:
  47             detail::tss_cleanup_function
  48         {
  49             void (*cleanup_function)(T*);
  50
  51             explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
  52                 cleanup_function(cleanup_function_)
  53             {}
  54
  55             void operator()(void* data)
  56             {
  57                 cleanup_function(static_cast<T*>(data));
  58             }
  59         };
  60
  61
  62         boost::shared_ptr<detail::tss_cleanup_function> cleanup;
  63
  64     public:
  65         thread_specific_ptr():
  66             cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
  67         {}
  68         explicit thread_specific_ptr(void (*func_)(T*))
  69         {
  70             if(func_)
  71             {
  72                 cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
  73             }
  74         }
  75         ~thread_specific_ptr()
  76         {
  77             reset();
  78         }
  79
  80         T* get() const
  81         {
  82             return static_cast<T*>(detail::get_tss_data(this));
  83         }
  84         T* operator->() const
  85         {
  86             return get();
  87         }
  88         T& operator*() const
  89         {
  90             return *get();
  91         }
  92         T* release()
  93         {
  94             T* const temp=get();
  95             detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
  96             return temp;
  97         }
  98         void reset(T* new_value=0)
  99         {
 100             T* const current_value=get();
 101             if(current_value!=new_value)
 102             {
 103                 detail::set_tss_data(this,cleanup,new_value,true);
 104             }
 105         }
 106     };
 107 }
 108
 109 #include <boost/config/abi_suffix.hpp>
 110
 111 #endif