eRPC Generator (erpcgen)  Rev. 1.7.2
NXP Semiconductors
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>
17 {
18  static inline void del(T *v) { delete v; }
19 };
20 
22 template <typename T>
24 {
25  static inline void del(T *v) { free(v); }
26 };
27 
29 template <typename T>
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 
52  : _p(nullptr)
53  {
54  }
55 
57  smart_ptr(ptr_type p)
58  : _p(p)
59  {
60  }
61 
64  : _p(other._p)
65  {
66  other._p = nullptr;
67  }
68 
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>
163 
165 template <typename T>
167 
168 #endif // _smart_ptr_h_
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< T > &&other)
Move copy constructor.
Definition: smart_ptr.h:63
void clear()
Dissociates a previously set pointer value, deleting it at the same time.
Definition: smart_ptr.h:104
Delete policy using free() to delete objects.
Definition: smart_ptr.h:23
ptr_type operator->()
Another operator to allow you to treat the object just like a pointer.
Definition: smart_ptr.h:144
ptr_type _p
The wrapped pointer.
Definition: smart_ptr.h:151
smart_ptr()
Default constructor. Initializes with no pointer set.
Definition: smart_ptr.h:51
Delete policy for arrays.
Definition: smart_ptr.h:30
Simple, standard smart pointer class.
Definition: smart_ptr.h:41
smart_ptr< T > & operator=(ptr_type p)
To allow setting the pointer directly. Equivalent to a call to set().
Definition: smart_ptr.h:137
virtual ~smart_ptr()
Definition: smart_ptr.h:79
smart_ptr< T > & operator=(smart_ptr< T > &&other)
Move assignment operator.
Definition: smart_ptr.h:70
Delete policy for regular objects.
Definition: smart_ptr.h:16
void reset()
Dissociates any previously set pointer value without deleting it.
Definition: smart_ptr.h:101
smart_ptr(ptr_type p)
This constructor takes a pointer to the object to be deleted.
Definition: smart_ptr.h:57
virtual void safe_delete()
Definition: smart_ptr.h:109