← Back to branch summary

~ubuntu-branches/ubuntu/wily/davix/wily

« back to all changes in this revision

Viewing changes to deps/boost_intern/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp

  • Committer: Package Import Robot
  • Author(s): Mattias Ellert
  • Date: 2015-07-31 13:17:55 UTC
  • mfrom: (5.1.3 sid)
  • Revision ID: package-import@ubuntu.com-20150731131755-mizprbmn7ogv33te
Tags: 0.4.1-1
* Update to version 0.4.1
* Implement Multi-Arch support

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/boost_intern/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp
1
 
#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SNC_PS3_HPP_INCLUDED
2
 
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SNC_PS3_HPP_INCLUDED
3
 
 
4
 
// MS compatible compilers support #pragma once
5
 
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
6
 
# pragma once
7
 
#endif
8
 
 
9
 
//  detail/sp_counted_base_gcc_sparc.hpp - g++ on Sparc V8+
10
 
//
11
 
//  Copyright (c) 2006 Piotr Wyderski
12
 
//  Copyright (c) 2006 Tomas Puverle
13
 
//  Copyright (c) 2006 Peter Dimov
14
 
//  Copyright (c) 2011 Emil Dotchevski
15
 
//
16
 
//  Distributed under the Boost Software License, Version 1.0.
17
 
//  See accompanying file LICENSE_1_0.txt or copy at
18
 
//  http://www.boost.org/LICENSE_1_0.txt
19
 
//
20
 
//  Thanks to Michael van der Westhuizen
21
 
 
22
 
#include <boost/detail/sp_typeinfo.hpp>
23
 
#include <inttypes.h> // uint32_t
24
 
 
25
 
namespace boost
26
 
{
27
 
 
28
 
namespace detail
29
 
{
30
 
 
31
 
inline uint32_t compare_and_swap( uint32_t * dest_, uint32_t compare_, uint32_t swap_ )
32
 
{
33
 
    return __builtin_cellAtomicCompareAndSwap32(dest_,compare_,swap_);
34
 
}
35
 
 
36
 
inline uint32_t atomic_fetch_and_add( uint32_t * pw, uint32_t dv )
37
 
{
38
 
    // long r = *pw;
39
 
    // *pw += dv;
40
 
    // return r;
41
 
 
42
 
    for( ;; )
43
 
    {
44
 
        uint32_t r = *pw;
45
 
 
46
 
        if( __builtin_expect((compare_and_swap(pw, r, r + dv) == r), 1) )
47
 
        {
48
 
            return r;
49
 
        }
50
 
    }
51
 
}
52
 
 
53
 
inline void atomic_increment( uint32_t * pw )
54
 
{
55
 
    (void) __builtin_cellAtomicIncr32( pw );
56
 
}
57
 
 
58
 
inline uint32_t atomic_decrement( uint32_t * pw )
59
 
{
60
 
    return __builtin_cellAtomicDecr32( pw );
61
 
}
62
 
 
63
 
inline uint32_t atomic_conditional_increment( uint32_t * pw )
64
 
{
65
 
    // long r = *pw;
66
 
    // if( r != 0 ) ++*pw;
67
 
    // return r;
68
 
 
69
 
    for( ;; )
70
 
    {
71
 
        uint32_t r = *pw;
72
 
 
73
 
        if( r == 0 )
74
 
        {
75
 
            return r;
76
 
        }
77
 
 
78
 
        if( __builtin_expect( ( compare_and_swap( pw, r, r + 1 ) == r ), 1 ) )
79
 
        {
80
 
            return r;
81
 
        }
82
 
    }    
83
 
}
84
 
 
85
 
class sp_counted_base
86
 
{
87
 
private:
88
 
 
89
 
    sp_counted_base( sp_counted_base const & );
90
 
    sp_counted_base & operator= ( sp_counted_base const & );
91
 
 
92
 
    uint32_t use_count_;        // #shared
93
 
    uint32_t weak_count_;       // #weak + (#shared != 0)
94
 
 
95
 
public:
96
 
 
97
 
    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
98
 
    {
99
 
    }
100
 
 
101
 
    virtual ~sp_counted_base() // nothrow
102
 
    {
103
 
    }
104
 
 
105
 
    // dispose() is called when use_count_ drops to zero, to release
106
 
    // the resources managed by *this.
107
 
 
108
 
    virtual void dispose() = 0; // nothrow
109
 
 
110
 
    // destroy() is called when weak_count_ drops to zero.
111
 
 
112
 
    virtual void destroy() // nothrow
113
 
    {
114
 
        delete this;
115
 
    }
116
 
 
117
 
    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
118
 
    virtual void * get_untyped_deleter() = 0;
119
 
 
120
 
    void add_ref_copy()
121
 
    {
122
 
        atomic_increment( &use_count_ );
123
 
    }
124
 
 
125
 
    bool add_ref_lock() // true on success
126
 
    {
127
 
        return atomic_conditional_increment( &use_count_ ) != 0;
128
 
    }
129
 
 
130
 
    void release() // nothrow
131
 
    {
132
 
        if( atomic_decrement( &use_count_ ) == 1 )
133
 
        {
134
 
            dispose();
135
 
            weak_release();
136
 
        }
137
 
    }
138
 
 
139
 
    void weak_add_ref() // nothrow
140
 
    {
141
 
        atomic_increment( &weak_count_ );
142
 
    }
143
 
 
144
 
    void weak_release() // nothrow
145
 
    {
146
 
        if( atomic_decrement( &weak_count_ ) == 1 )
147
 
        {
148
 
            destroy();
149
 
        }
150
 
    }
151
 
 
152
 
    long use_count() const // nothrow
153
 
    {
154
 
        return const_cast< uint32_t const volatile & >( use_count_ );
155
 
    }
156
 
};
157
 
 
158
 
} // namespace detail
159
 
 
160
 
} // namespace boost
161
 
 
162
 
#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SNC_PS3_HPP_INCLUDED