eRPC Generator (erpcgen)  Rev. 1.12.0
NXP Semiconductors
smart_ptr.hpp
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 
51  smart_ptr() : _p(nullptr) {}
52 
54  smart_ptr(ptr_type p) : _p(p) {}
55 
57  smart_ptr(smart_ptr<T> &&other) : _p(other._p) { other._p = nullptr; }
58 
61  {
62  set(other._p);
63  other._p = nullptr;
64  return *this;
65  }
66 
68  smart_ptr<T> &operator=(ptr_type p)
69  {
70  set(p);
71  return *this;
72  }
73 
76  virtual ~smart_ptr() { safe_delete(); }
77 
79  ptr_type get() { return _p; }
80 
82  const_ptr_type get() const { return _p; }
83 
88  void set(ptr_type p)
89  {
90  if (_p && p != _p)
91  {
92  safe_delete();
93  }
94  _p = p;
95  }
96 
98  void reset() { _p = nullptr; }
99 
101  void clear() { safe_delete(); }
102 
106  virtual void safe_delete()
107  {
108  if (_p)
109  {
110  delete_policy::del(_p);
111  _p = nullptr;
112  }
113  }
114 
116 
117 
119  operator ptr_type() { return _p; }
120 
122  operator const_ptr_type() const { return _p; }
123 
125  operator ref_type() { return *_p; }
126 
128  operator const_ref_type() const { return *_p; }
129 
131  operator bool() const { return _p != nullptr; }
132 
134  ptr_type operator->() { return _p; }
135 
137  const_ptr_type operator->() const { return _p; }
139 
140 protected:
141  ptr_type _p;
142 
144  smart_ptr(const smart_ptr<T> &) = delete;
145 
147  smart_ptr<T> &operator=(const smart_ptr<T> &) = delete;
148 };
149 
151 template <typename T>
153 
155 template <typename T>
157 
158 #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.hpp:137
smart_ptr(smart_ptr< T > &&other)
Move copy constructor.
Definition: smart_ptr.hpp:57
void clear()
Dissociates a previously set pointer value, deleting it at the same time.
Definition: smart_ptr.hpp:101
Delete policy using free() to delete objects.
Definition: smart_ptr.hpp:23
ptr_type operator->()
Another operator to allow you to treat the object just like a pointer.
Definition: smart_ptr.hpp:134
ptr_type _p
The wrapped pointer.
Definition: smart_ptr.hpp:141
smart_ptr()
Default constructor. Initializes with no pointer set.
Definition: smart_ptr.hpp:51
Delete policy for arrays.
Definition: smart_ptr.hpp:30
Simple, standard smart pointer class.
Definition: smart_ptr.hpp:41
smart_ptr< T > & operator=(ptr_type p)
To allow setting the pointer directly. Equivalent to a call to set().
Definition: smart_ptr.hpp:68
virtual ~smart_ptr()
Definition: smart_ptr.hpp:76
smart_ptr< T > & operator=(smart_ptr< T > &&other)
Move assignment operator.
Definition: smart_ptr.hpp:60
Delete policy for regular objects.
Definition: smart_ptr.hpp:16
void reset()
Dissociates any previously set pointer value without deleting it.
Definition: smart_ptr.hpp:98
smart_ptr(ptr_type p)
This constructor takes a pointer to the object to be deleted.
Definition: smart_ptr.hpp:54
virtual void safe_delete()
Definition: smart_ptr.hpp:106