← Back to branch summary

~ubuntu-branches/debian/experimental/kopete/experimental

« back to all changes in this revision

Viewing changes to protocols/jabber/googletalk/libjingle/talk/base/scoped_ptr.h

  • Committer: Package Import Robot
  • Author(s): Maximiliano Curia
  • Date: 2015-02-24 11:32:57 UTC
  • mfrom: (1.1.41 vivid)
  • Revision ID: package-import@ubuntu.com-20150224113257-gnupg4v7lzz18ij0
Tags: 4:14.12.2-1
* New upstream release (14.12.2).
* Bump Standards-Version to 3.9.6, no changes needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
protocols/jabber/googletalk/libjingle/talk/base/scoped_ptr.h
1
 
//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
2
 
//  Copyright (c) 2001, 2002 Peter Dimov
3
 
//
4
 
//  Permission to copy, use, modify, sell and distribute this software
5
 
//  is granted provided this copyright notice appears in all copies.
6
 
//  This software is provided "as is" without express or implied
7
 
//  warranty, and with no claim as to its suitability for any purpose.
8
 
//
9
 
//  See http://www.boost.org/libs/smart_ptr/scoped_ptr.htm for documentation.
10
 
//
11
 
 
12
 
//  scoped_ptr mimics a built-in pointer except that it guarantees deletion
13
 
//  of the object pointed to, either on destruction of the scoped_ptr or via
14
 
//  an explicit reset(). scoped_ptr is a simple solution for simple needs;
15
 
//  use shared_ptr or std::auto_ptr if your needs are more complex.
16
 
 
17
 
//  scoped_ptr_malloc added in by Google.  When one of
18
 
//  these goes out of scope, instead of doing a delete or delete[], it
19
 
//  calls free().  scoped_ptr_malloc<char> is likely to see much more
20
 
//  use than any other specializations.
21
 
 
22
 
//  release() added in by Google. Use this to conditionally
23
 
//  transfer ownership of a heap-allocated object to the caller, usually on
24
 
//  method success.
25
 
#ifndef TALK_BASE_SCOPED_PTR_H__
26
 
#define TALK_BASE_SCOPED_PTR_H__
27
 
 
28
 
#include <cstddef>             // for std::ptrdiff_t
29
 
#include <stdlib.h>            // for free() decl
30
 
 
31
 
#include "talk/base/common.h"  // for ASSERT
32
 
 
33
 
#ifdef _WIN32
34
 
namespace std { using ::ptrdiff_t; };
35
 
#endif // _WIN32
36
 
 
37
 
namespace talk_base {
38
 
 
39
 
template <typename T>
40
 
class scoped_ptr {
41
 
 private:
42
 
 
43
 
  T* ptr;
44
 
 
45
 
  scoped_ptr(scoped_ptr const &);
46
 
  scoped_ptr & operator=(scoped_ptr const &);
47
 
 
48
 
 public:
49
 
 
50
 
  typedef T element_type;
51
 
 
52
 
  explicit scoped_ptr(T* p = NULL): ptr(p) {}
53
 
 
54
 
  ~scoped_ptr() {
55
 
    typedef char type_must_be_complete[sizeof(T)];
56
 
    delete ptr;
57
 
  }
58
 
 
59
 
  void reset(T* p = NULL) {
60
 
    typedef char type_must_be_complete[sizeof(T)];
61
 
 
62
 
    if (ptr != p) {
63
 
      T* obj = ptr;
64
 
      ptr = p;
65
 
      // Delete last, in case obj destructor indirectly results in ~scoped_ptr
66
 
      delete obj;
67
 
    }
68
 
  }
69
 
 
70
 
  T& operator*() const {
71
 
    ASSERT(ptr != NULL);
72
 
    return *ptr;
73
 
  }
74
 
 
75
 
  T* operator->() const  {
76
 
    ASSERT(ptr != NULL);
77
 
    return ptr;
78
 
  }
79
 
 
80
 
  T* get() const  {
81
 
    return ptr;
82
 
  }
83
 
 
84
 
  void swap(scoped_ptr & b) {
85
 
    T* tmp = b.ptr;
86
 
    b.ptr = ptr;
87
 
    ptr = tmp;
88
 
  }
89
 
 
90
 
  T* release() {
91
 
    T* tmp = ptr;
92
 
    ptr = NULL;
93
 
    return tmp;
94
 
  }
95
 
 
96
 
  T** accept() {
97
 
    if (ptr) {
98
 
      delete ptr;
99
 
      ptr = NULL;
100
 
    }
101
 
    return &ptr;
102
 
  }
103
 
 
104
 
  T** use() {
105
 
    return &ptr;
106
 
  }
107
 
};
108
 
 
109
 
template<typename T> inline
110
 
void swap(scoped_ptr<T>& a, scoped_ptr<T>& b) {
111
 
  a.swap(b);
112
 
}
113
 
 
114
 
 
115
 
 
116
 
 
117
 
//  scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
118
 
//  is guaranteed, either on destruction of the scoped_array or via an explicit
119
 
//  reset(). Use shared_array or std::vector if your needs are more complex.
120
 
 
121
 
template<typename T>
122
 
class scoped_array {
123
 
 private:
124
 
 
125
 
  T* ptr;
126
 
 
127
 
  scoped_array(scoped_array const &);
128
 
  scoped_array & operator=(scoped_array const &);
129
 
 
130
 
 public:
131
 
 
132
 
  typedef T element_type;
133
 
 
134
 
  explicit scoped_array(T* p = NULL) : ptr(p) {}
135
 
 
136
 
  ~scoped_array() {
137
 
    typedef char type_must_be_complete[sizeof(T)];
138
 
    delete[] ptr;
139
 
  }
140
 
 
141
 
  void reset(T* p = NULL) {
142
 
    typedef char type_must_be_complete[sizeof(T)];
143
 
 
144
 
    if (ptr != p) {
145
 
      T* arr = ptr;
146
 
      ptr = p;
147
 
      // Delete last, in case arr destructor indirectly results in ~scoped_array
148
 
      delete [] arr;
149
 
    }
150
 
  }
151
 
 
152
 
  T& operator[](std::ptrdiff_t i) const {
153
 
    ASSERT(ptr != NULL);
154
 
    ASSERT(i >= 0);
155
 
    return ptr[i];
156
 
  }
157
 
 
158
 
  T* get() const {
159
 
    return ptr;
160
 
  }
161
 
 
162
 
  void swap(scoped_array & b) {
163
 
    T* tmp = b.ptr;
164
 
    b.ptr = ptr;
165
 
    ptr = tmp;
166
 
  }
167
 
 
168
 
  T* release() {
169
 
    T* tmp = ptr;
170
 
    ptr = NULL;
171
 
    return tmp;
172
 
  }
173
 
 
174
 
  T** accept() {
175
 
    if (ptr) {
176
 
      delete [] ptr;
177
 
      ptr = NULL;
178
 
    }
179
 
    return &ptr;
180
 
  }
181
 
};
182
 
 
183
 
template<class T> inline
184
 
void swap(scoped_array<T>& a, scoped_array<T>& b) {
185
 
  a.swap(b);
186
 
}
187
 
 
188
 
// scoped_ptr_malloc<> is similar to scoped_ptr<>, but it accepts a
189
 
// second template argument, the function used to free the object.
190
 
 
191
 
template<typename T, void (*FF)(void*) = free> class scoped_ptr_malloc {
192
 
 private:
193
 
 
194
 
  T* ptr;
195
 
 
196
 
  scoped_ptr_malloc(scoped_ptr_malloc const &);
197
 
  scoped_ptr_malloc & operator=(scoped_ptr_malloc const &);
198
 
 
199
 
 public:
200
 
 
201
 
  typedef T element_type;
202
 
 
203
 
  explicit scoped_ptr_malloc(T* p = 0): ptr(p) {}
204
 
 
205
 
  ~scoped_ptr_malloc() {
206
 
    FF(static_cast<void*>(ptr));
207
 
  }
208
 
 
209
 
  void reset(T* p = 0) {
210
 
    if (ptr != p) {
211
 
      FF(static_cast<void*>(ptr));
212
 
      ptr = p;
213
 
    }
214
 
  }
215
 
 
216
 
  T& operator*() const {
217
 
    ASSERT(ptr != 0);
218
 
    return *ptr;
219
 
  }
220
 
 
221
 
  T* operator->() const {
222
 
    ASSERT(ptr != 0);
223
 
    return ptr;
224
 
  }
225
 
 
226
 
  T* get() const {
227
 
    return ptr;
228
 
  }
229
 
 
230
 
  void swap(scoped_ptr_malloc & b) {
231
 
    T* tmp = b.ptr;
232
 
    b.ptr = ptr;
233
 
    ptr = tmp;
234
 
  }
235
 
 
236
 
  T* release() {
237
 
    T* tmp = ptr;
238
 
    ptr = 0;
239
 
    return tmp;
240
 
  }
241
 
 
242
 
  T** accept() {
243
 
    if (ptr) {
244
 
      FF(static_cast<void*>(ptr));
245
 
      ptr = 0;
246
 
    }
247
 
    return &ptr;
248
 
  }
249
 
};
250
 
 
251
 
template<typename T, void (*FF)(void*)> inline
252
 
void swap(scoped_ptr_malloc<T,FF>& a, scoped_ptr_malloc<T,FF>& b) {
253
 
  a.swap(b);
254
 
}
255
 
 
256
 
} // namespace talk_base
257
 
 
258
 
#endif  // #ifndef TALK_BASE_SCOPED_PTR_H__