| eRPC Generator (erpcgen) Rev. 1.8.1 NXP Semiconductors

- Main Page
- Classes
- Files

- File List

smart_ptr.h
1 /*
2 * Copyright (c) 2013-2014, Freescale Semiconductor, Inc.
3 * Copyright 2016 NXP
4 * All rights reserved.
5 *
6 *
7 * SPDX-License-Identifier: BSD-3-Clause
8 */
9 #if !defined(_smart_ptr_h_)
10 #define _smart_ptr_h_
11
12 #include <cstdlib>
13
15 template <typename T>
16 struct smart_ptr_delete
17 {
18 static inline void del(T *v) { delete v; }
19 };
20
22 template <typename T>
23 struct smart_ptr_free
24 {
25 static inline void del(T *v) { free(v); }
26 };
27
29 template <typename T>
30 struct smart_ptr_delete_array
31 {
32 static inline void del(T *v) { delete[] v; }
33 };
34
40 template <typename T, class delete_policy = smart_ptr_delete<T> >
41 class smart_ptr
42 {
43 public:
44 typedef T data_type;
45 typedef T *ptr_type;
46 typedef const T *const_ptr_type;
47 typedef T &ref_type;
48 typedef const T &const_ref_type;
49
51 smart_ptr()
52 : _p(nullptr)
53 {
54 }
55
57 smart_ptr(ptr_type p)
58 : _p(p)
59 {
60 }
61
63 smart_ptr(smart_ptr<T> &&other)
64 : _p(other._p)
65 {
66 other._p = nullptr;
67 }
68
70 smart_ptr<T> &operator=(smart_ptr<T> &&other)
71 {
72 set(other._p);
73 other._p = nullptr;
74 return *this;
75 }
76
79 virtual ~smart_ptr() { safe_delete(); }
80
82 ptr_type get() { return _p; }
83
85 const_ptr_type get() const { return _p; }
86
91 void set(ptr_type p)
92 {
93 if (_p && p != _p)
94 {
95 safe_delete();
96 }
97 _p = p;
98 }
99
101 void reset() { _p = nullptr; }
102
104 void clear() { safe_delete(); }
105
109 virtual void safe_delete()
110 {
111 if (_p)
112 {
113 delete_policy::del(_p);
114 _p = nullptr;
115 }
116 }
117
119
120
122 operator ptr_type() { return _p; }
123
125 operator const_ptr_type() const { return _p; }
126
128 operator ref_type() { return *_p; }
129
131 operator const_ref_type() const { return *_p; }
132
134 operator bool() const { return _p != nullptr; }
135
137 smart_ptr<T> &operator=(ptr_type p)
138 {
139 set(p);
140 return *this;
141 }
142
144 ptr_type operator->() { return _p; }
145
147 const_ptr_type operator->() const { return _p; }
149
150 protected:
151 ptr_type _p;
152
154 smart_ptr(const smart_ptr<T> &) = delete;
155
157 smart_ptr<T> &operator=(const smart_ptr<T> &) = delete;
158 };
159
161 template <typename T>
162 using smart_array_ptr = smart_ptr<T, smart_ptr_delete_array<T> >;
163
165 template <typename T>
166 using smart_free_ptr = smart_ptr<T, smart_ptr_free<T> >;
167
168 #endif // _smart_ptr_h_
smart_ptr::operator->
const_ptr_type operator->() const
Another operator to allow you to treat the object just like a pointer.
Definition: smart_ptr.h:147
smart_ptr::smart_ptr
smart_ptr(smart_ptr< T > &&other)
Move copy constructor.
Definition: smart_ptr.h:63
smart_ptr::clear
void clear()
Dissociates a previously set pointer value, deleting it at the same time.
Definition: smart_ptr.h:104
smart_ptr_free
Delete policy using free() to delete objects.
Definition: smart_ptr.h:23
smart_ptr::operator->
ptr_type operator->()
Another operator to allow you to treat the object just like a pointer.
Definition: smart_ptr.h:144
smart_ptr::_p
ptr_type _p
The wrapped pointer.
Definition: smart_ptr.h:151
smart_ptr::smart_ptr
smart_ptr()
Default constructor. Initializes with no pointer set.
Definition: smart_ptr.h:51
smart_ptr_delete_array
Delete policy for arrays.
Definition: smart_ptr.h:30
smart_ptr
Simple, standard smart pointer class.
Definition: smart_ptr.h:41
smart_ptr::operator=
smart_ptr< T > & operator=(ptr_type p)
To allow setting the pointer directly. Equivalent to a call to set().
Definition: smart_ptr.h:137
smart_ptr::~smart_ptr
virtual ~smart_ptr()
Definition: smart_ptr.h:79
smart_ptr::operator=
smart_ptr< T > & operator=(smart_ptr< T > &&other)
Move assignment operator.
Definition: smart_ptr.h:70
smart_ptr_delete
Delete policy for regular objects.
Definition: smart_ptr.h:16
smart_ptr::reset
void reset()
Dissociates any previously set pointer value without deleting it.
Definition: smart_ptr.h:101
smart_ptr::smart_ptr
smart_ptr(ptr_type p)
This constructor takes a pointer to the object to be deleted.
Definition: smart_ptr.h:57
smart_ptr::safe_delete
virtual void safe_delete()
Definition: smart_ptr.h:109