libassa
3.5.1
Main Page
Namespaces
Classes
Files
File List
File Members
All
Classes
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Macros
assa
AutoPtr.h
Go to the documentation of this file.
1
// -*- c++ -*-
2
//------------------------------------------------------------------------------
3
// AutoPtr.h
4
//------------------------------------------------------------------------------
5
// Copyright (C) 1999,2005 Vladislav Grinchenko
6
//
7
// This library is free software; you can redistribute it and/or
8
// modify it under the terms of the GNU Library General Public
9
// License as published by the Free Software Foundation; either
10
// version 2 of the License, or (at your option) any later version.
11
//------------------------------------------------------------------------------
12
#ifndef AUTO_PTR_H
13
#define AUTO_PTR_H
14
15
#include <cstdlib>
// NULL definition
16
23
namespace
ASSA {
24
32
template
<
typename
R>
class
AutoPtrRef
{
33
public
:
34
explicit
AutoPtrRef
(R* p_) :
m_ptr
(p_) {
/* no-op */
}
35
36
R*
m_ptr
;
37
};
38
49
template
<
class
X>
class
AutoPtr
{
50
private
:
52
X*
m_ptr
;
53
54
public
:
61
explicit
AutoPtr
(X* p_ = 0) :
m_ptr
(p_) {
/* no-op */
}
62
67
AutoPtr
(
AutoPtr
& a_) :
m_ptr
(a_.
release
()) {
/* no-op */
}
68
75
template
<
typename
T>
76
AutoPtr
(
AutoPtr<T>
& a_) :
m_ptr
(a_.
release
()) {
/* no-op */
}
77
83
AutoPtr
&
operator=
(
AutoPtr
& a_) {
84
reset
(a_.
release
());
85
return
*
this
;
86
}
87
93
template
<
class
T>
AutoPtr
&
operator=
(
AutoPtr<T>
& a_) {
94
reset
(a_.
release
());
95
return
*
this
;
96
}
97
102
~AutoPtr
() {
103
if
(
m_ptr
) {
104
delete
m_ptr
;
105
}
106
}
107
111
X&
operator*
()
const
{
return
*
m_ptr
; }
112
116
X*
operator->
()
const
{
return
m_ptr
; }
117
123
X*
get
()
const
{
return
m_ptr
; }
124
130
X*
release
() {
131
X* tmp =
m_ptr
;
132
m_ptr
= NULL;
133
return
tmp;
134
}
135
140
void
reset
(X* p_ = 0) {
141
if
(p_ !=
m_ptr
) {
142
delete
m_ptr
;
143
m_ptr
= p_;
144
}
145
}
146
159
AutoPtr
(
AutoPtrRef<X>
ref_) :
m_ptr
(ref_.
m_ptr
) {
/* no-op */
}
160
161
AutoPtr
&
operator=
(
AutoPtrRef<X>
ref_) {
162
if
(ref_.
m_ptr
!=
get
()) {
163
delete
m_ptr
;
164
m_ptr
= ref_.
m_ptr
;
165
}
166
return
*
this
;
167
}
168
169
template
<
typename
T>
170
operator
AutoPtrRef<T>
() {
return
AutoPtrRef<T>
(
release
()); }
171
172
template
<
typename
T>
173
operator
AutoPtr<T>
() {
return
AutoPtr<T>
(
release
()); }
174
176
};
177
185
template
<
typename
R>
class
AutoPtrArrayRef
{
186
public
:
187
explicit
AutoPtrArrayRef
(R* p_) :
m_ptr
(p_) {
/* no-op */
}
188
189
R*
m_ptr
;
190
};
191
198
template
<
class
X>
class
AutoPtrArray
{
199
private
:
201
X*
m_ptr
;
202
203
public
:
210
explicit
AutoPtrArray
(X* p_ = 0) :
m_ptr
(p_) {
/* no-op */
}
211
216
AutoPtrArray
(
AutoPtrArray
& a_) :
m_ptr
(a_.
release
()) {
/* no-op */
}
217
225
template
<
typename
T>
226
AutoPtrArray
(
AutoPtrArray<T>
& a_)
227
:
m_ptr
(a_.
release
()) {
/* no-op */
}
228
235
AutoPtrArray
&
operator=
(
AutoPtrArray
& a_) {
236
reset
(a_.
release
());
237
return
*
this
;
238
}
239
245
template
<
class
T>
246
AutoPtrArray
&
operator=
(
AutoPtrArray<T>
& a_) {
247
reset
(a_.
release
());
248
return
*
this
;
249
}
250
255
~AutoPtrArray
() {
256
if
(
m_ptr
) {
257
delete
[]
m_ptr
;
258
}
259
}
260
264
X&
operator*
()
const
{
return
*
m_ptr
; }
265
269
X*
operator->
()
const
{
return
m_ptr
; }
270
274
X&
operator[]
(
int
i)
const
{
275
X* array =
get
();
276
return
(array [i]);
277
}
278
284
X*
get
()
const
{
return
m_ptr
; }
285
291
X*
release
() {
292
X* tmp =
m_ptr
;
293
m_ptr
= NULL;
294
return
tmp;
295
}
296
301
void
reset
(X* p_ = 0) {
302
if
(p_ !=
m_ptr
) {
303
delete
[]
m_ptr
;
304
m_ptr
= p_;
305
}
306
}
307
320
AutoPtrArray
(
AutoPtrArrayRef<X>
ref_) :
m_ptr
(ref_.
m_ptr
) {
/* no-op */
}
321
322
AutoPtrArray
&
operator=
(
AutoPtrArrayRef<X>
ref_) {
323
if
(ref_.
m_ptr
!=
get
()) {
324
delete
[]
m_ptr
;
325
m_ptr
= ref_.
m_ptr
;
326
}
327
return
*
this
;
328
}
329
330
template
<
typename
T>
331
operator
AutoPtrArrayRef<T>
() {
return
AutoPtrArrayRef<T>
(
release
()); }
332
333
template
<
typename
T>
334
operator
AutoPtrArray<T>
() {
return
AutoPtrArray<T>
(
release
()); }
335
337
};
338
339
}
// end namespace ASSA
340
341
#endif
/* AUTO_PTR_H */
342
343
Generated on Tue Jun 19 2012 07:33:37 for libassa by
1.8.1.1