← Back to branch summary

~ubuntu-branches/ubuntu/saucy/deal.ii/saucy

« back to all changes in this revision

Viewing changes to contrib/boost/include/boost/smart_ptr/detail/shared_array_nmt.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Adam C. Powell, IV, Adam C. Powell, IV, Denis Barbier
  • Date: 2010-07-29 13:47:01 UTC
  • mfrom: (3.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20100729134701-akb8jb3stwge8tcm
Tags: 6.3.1-1
http://bugs.debian.org/562332
[ Adam C. Powell, IV ]
* Changed to source format 3.0 (quilt).
* Changed maintainer to debian-science with Adam Powell as uploader.
* Added source lintian overrides about Adam Powell's name.
* Added Vcs info on git repository.
* Bumped Standards-Version.
* Changed stamp-patch to patch target and fixed its application criterion.
* Moved make_dependencies and expand_instantiations to a versioned directory
  to avoid shlib package conflicts.

[ Denis Barbier ]
* New upstream release (closes: #562332).
  + Added libtbb support.
  + Forward-ported all patches.
* Updates for new PETSc version, including workaround for different versions
  of petsc and slepc.
* Add debian/watch.
* Update to debhelper 7.
* Added pdebuild patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/boost/include/boost/smart_ptr/detail/shared_array_nmt.hpp
 
1
#ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
 
2
#define BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
 
3
 
 
4
//
 
5
//  detail/shared_array_nmt.hpp - shared_array.hpp without member templates
 
6
//
 
7
//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 
8
//  Copyright (c) 2001, 2002 Peter Dimov
 
9
//
 
10
//  Distributed under the Boost Software License, Version 1.0. (See
 
11
//  accompanying file LICENSE_1_0.txt or copy at
 
12
//  http://www.boost.org/LICENSE_1_0.txt)
 
13
//
 
14
//  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
 
15
//
 
16
 
 
17
#include <boost/assert.hpp>
 
18
#include <boost/checked_delete.hpp>
 
19
#include <boost/throw_exception.hpp>
 
20
#include <boost/smart_ptr/detail/atomic_count.hpp>
 
21
 
 
22
#include <cstddef>          // for std::ptrdiff_t
 
23
#include <algorithm>        // for std::swap
 
24
#include <functional>       // for std::less
 
25
#include <new>              // for std::bad_alloc
 
26
 
 
27
namespace boost
 
28
{
 
29
 
 
30
template<class T> class shared_array
 
31
{
 
32
private:
 
33
 
 
34
    typedef detail::atomic_count count_type;
 
35
 
 
36
public:
 
37
 
 
38
    typedef T element_type;
 
39
      
 
40
    explicit shared_array(T * p = 0): px(p)
 
41
    {
 
42
#ifndef BOOST_NO_EXCEPTIONS
 
43
 
 
44
        try  // prevent leak if new throws
 
45
        {
 
46
            pn = new count_type(1);
 
47
        }
 
48
        catch(...)
 
49
        {
 
50
            boost::checked_array_delete(p);
 
51
            throw;
 
52
        }
 
53
 
 
54
#else
 
55
 
 
56
        pn = new count_type(1);
 
57
 
 
58
        if(pn == 0)
 
59
        {
 
60
            boost::checked_array_delete(p);
 
61
            boost::throw_exception(std::bad_alloc());
 
62
        }
 
63
 
 
64
#endif
 
65
    }
 
66
 
 
67
    ~shared_array()
 
68
    {
 
69
        if(--*pn == 0)
 
70
        {
 
71
            boost::checked_array_delete(px);
 
72
            delete pn;
 
73
        }
 
74
    }
 
75
 
 
76
    shared_array(shared_array const & r) : px(r.px)  // never throws
 
77
    {
 
78
        pn = r.pn;
 
79
        ++*pn;
 
80
    }
 
81
 
 
82
    shared_array & operator=(shared_array const & r)
 
83
    {
 
84
        shared_array(r).swap(*this);
 
85
        return *this;
 
86
    }
 
87
 
 
88
    void reset(T * p = 0)
 
89
    {
 
90
        BOOST_ASSERT(p == 0 || p != px);
 
91
        shared_array(p).swap(*this);
 
92
    }
 
93
 
 
94
    T * get() const  // never throws
 
95
    {
 
96
        return px;
 
97
    }
 
98
 
 
99
    T & operator[](std::ptrdiff_t i) const  // never throws
 
100
    {
 
101
        BOOST_ASSERT(px != 0);
 
102
        BOOST_ASSERT(i >= 0);
 
103
        return px[i];
 
104
    }
 
105
 
 
106
    long use_count() const  // never throws
 
107
    {
 
108
        return *pn;
 
109
    }
 
110
 
 
111
    bool unique() const  // never throws
 
112
    {
 
113
        return *pn == 1;
 
114
    }
 
115
 
 
116
    void swap(shared_array<T> & other)  // never throws
 
117
    {
 
118
        std::swap(px, other.px);
 
119
        std::swap(pn, other.pn);
 
120
    }
 
121
 
 
122
private:
 
123
 
 
124
    T * px;            // contained pointer
 
125
    count_type * pn;   // ptr to reference counter
 
126
      
 
127
};  // shared_array
 
128
 
 
129
template<class T, class U> inline bool operator==(shared_array<T> const & a, shared_array<U> const & b)
 
130
{
 
131
    return a.get() == b.get();
 
132
}
 
133
 
 
134
template<class T, class U> inline bool operator!=(shared_array<T> const & a, shared_array<U> const & b)
 
135
{
 
136
    return a.get() != b.get();
 
137
}
 
138
 
 
139
template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b)
 
140
{
 
141
    return std::less<T*>()(a.get(), b.get());
 
142
}
 
143
 
 
144
template<class T> void swap(shared_array<T> & a, shared_array<T> & b)
 
145
{
 
146
    a.swap(b);
 
147
}
 
148
 
 
149
} // namespace boost
 
150
 
 
151
#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED