Blame view

3rdparty/boost_1_81_0/boost/thread/tss.hpp 2.54 KB
dbf9e800   Hu Chunming   提交_GLIBCXX_USE_CX...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
  #ifndef BOOST_THREAD_TSS_HPP
  #define BOOST_THREAD_TSS_HPP
  // Distributed under the Boost Software License, Version 1.0. (See
  // accompanying file LICENSE_1_0.txt or copy at
  // http://www.boost.org/LICENSE_1_0.txt)
  // (C) Copyright 2007-8 Anthony Williams
  
  #include <boost/thread/detail/config.hpp>
  
  #include <boost/type_traits/add_reference.hpp>
  
  #include <boost/config/abi_prefix.hpp>
  
  namespace boost
  {
      namespace detail
      {
          namespace thread
          {
              typedef void(*cleanup_func_t)(void*);
              typedef void(*cleanup_caller_t)(cleanup_func_t, void*);
          }
  
          BOOST_THREAD_DECL void set_tss_data(void const* key,detail::thread::cleanup_caller_t caller,detail::thread::cleanup_func_t func,void* tss_data,bool cleanup_existing);
          BOOST_THREAD_DECL void* get_tss_data(void const* key);
      }
  
      template <typename T>
      class thread_specific_ptr
      {
      private:
          thread_specific_ptr(thread_specific_ptr&);
          thread_specific_ptr& operator=(thread_specific_ptr&);
  
          typedef void(*original_cleanup_func_t)(T*);
  
          static void default_deleter(T* data)
          {
              delete data;
          }
  
          static void cleanup_caller(detail::thread::cleanup_func_t cleanup_function,void* data)
          {
              reinterpret_cast<original_cleanup_func_t>(cleanup_function)(static_cast<T*>(data));
          }
  
  
          detail::thread::cleanup_func_t cleanup;
  
      public:
          typedef T element_type;
  
          thread_specific_ptr():
              cleanup(reinterpret_cast<detail::thread::cleanup_func_t>(&default_deleter))
          {}
          explicit thread_specific_ptr(void (*func_)(T*))
            : cleanup(reinterpret_cast<detail::thread::cleanup_func_t>(func_))
          {}
          ~thread_specific_ptr()
          {
              detail::set_tss_data(this,0,0,0,true);
          }
  
          T* get() const
          {
              return static_cast<T*>(detail::get_tss_data(this));
          }
          T* operator->() const
          {
              return get();
          }
          typename add_reference<T>::type operator*() const
          {
              return *get();
          }
          T* release()
          {
              T* const temp=get();
              detail::set_tss_data(this,0,0,0,false);
              return temp;
          }
          void reset(T* new_value=0)
          {
              T* const current_value=get();
              if(current_value!=new_value)
              {
                  detail::set_tss_data(this,&cleanup_caller,cleanup,new_value,true);
              }
          }
      };
  }
  
  #include <boost/config/abi_suffix.hpp>
  
  #endif