C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 4

daal_shared_ptr.h
1 /* file: daal_shared_ptr.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 /*
17 //++
18 // Declaration and implementation of the shared pointer class.
19 //--
20 */
21 
22 #ifndef __DAAL_SHARED_PTR_H__
23 #define __DAAL_SHARED_PTR_H__
24 
25 #include "services/base.h"
26 #include "services/daal_memory.h"
27 #include "services/error_id.h"
28 #include "services/daal_atomic_int.h"
29 
30 namespace daal
31 {
32 namespace services
33 {
34 
35 namespace interface1
36 {
47 class DeleterIface
48 {
49 public:
53  virtual ~DeleterIface() {}
54 
59  virtual void operator() (const void *ptr) = 0;
60 };
61 
68 template<class T>
69 class ObjectDeleter : public DeleterIface
70 {
71 public:
72  void operator() (const void *ptr) DAAL_C11_OVERRIDE
73  {
74  delete (const T *)(ptr);
75  }
76 };
77 
84 class ServiceDeleter : public DeleterIface
85 {
86 public:
87  void operator() (const void *ptr) DAAL_C11_OVERRIDE
88  {
89  daal::services::daal_free((void *)ptr);
90  }
91 };
92 
99 class EmptyDeleter : public DeleterIface
100 {
101 public:
102  void operator() (const void *ptr) DAAL_C11_OVERRIDE
103  {
104  }
105 };
106 
112 class DAAL_EXPORT RefCounter: public AtomicInt
113 {
114 public:
118  RefCounter() : AtomicInt(1){}
120  virtual ~RefCounter() {}
121  virtual void operator() (const void *ptr) = 0;
122 };
123 
130 template<class Deleter>
131 class RefCounterImp: public RefCounter
132 {
133 public:
137  RefCounterImp(){}
138  RefCounterImp(const Deleter& d) : _deleter(d){}
140  virtual ~RefCounterImp() {}
141  void operator() (const void *ptr) DAAL_C11_OVERRIDE
142  {
143  _deleter(ptr);
144  }
145 protected:
146  Deleter _deleter;
147 };
148 
160 template<class T>
161 class SharedPtr
162 {
163 public:
164  DAAL_NEW_DELETE();
165 
166  typedef T ElementType;
167 
171  SharedPtr() : _ownedPtr(NULL), _ptr(NULL), _refCount(NULL)
172  {
173  }
174 
179  template<class U>
180  explicit SharedPtr(U *ptr) : _ownedPtr(ptr), _ptr(ptr), _refCount(NULL)
181  {
182  if(_ownedPtr)
183  _refCount = new RefCounterImp<ObjectDeleter<U> >();
184  }
185 
193  template<class U, class D>
194  explicit SharedPtr(U *ptr, const D& deleter) : _ownedPtr(ptr), _ptr(ptr), _refCount(NULL)
195  {
196  if(_ownedPtr)
197  _refCount = new RefCounterImp<D>(deleter);
198  }
199 
200  SharedPtr(const SharedPtr<T> &ptr);
201 
202  SharedPtr(const SharedPtr<T> &ptr, T* shiftedPtr);
203 
208  template<class U>
209  SharedPtr(const SharedPtr<U> &other);
210 
221  template<class U>
222  SharedPtr(const SharedPtr<U> &r, T *ptr, T *shiftedPtr);
223 
228  ~SharedPtr() { _remove(); }
229 
234  SharedPtr<T> &operator=(const SharedPtr<T> &ptr);
235 
239  void reset()
240  {
241  _remove();
242  _ownedPtr = NULL;
243  _refCount = NULL;
244  _ptr = NULL;
245  }
246 
252  template<class U>
253  void reset(U* ptr);
254 
262  template<class U, class D>
263  void reset(U* ptr, const D& deleter);
264 
269  template<class U>
270  SharedPtr<T> &operator=(const SharedPtr<U> &ptr)
271  {
272  if (((void *)&ptr != (void *)this) && ((void *)(ptr.get()) != (void *)(this->_ownedPtr)))
273  {
274  _remove();
275  _ownedPtr = ptr._ownedPtr;
276  _refCount = ptr._refCount;
277  _ptr = ptr._ptr;
278  if(_refCount)
279  _refCount->inc();
280  }
281  return *this;
282  }
283 
288  T *operator->() const { return _ptr; }
289 
294  T &operator* () const { return *_ptr; }
295 
300  operator bool() const { return (_ptr != NULL); }
301 
306  T *get() const { return _ptr; }
307 
312  T *getStartPtr() const { return _ownedPtr; }
313 
318  int useCount() const { return _refCount ? _refCount->get() : 0; }
319 
320 protected:
321  T *_ownedPtr; /* Pointer to the beginning of the owned memory */
322  T *_ptr; /* Pointer to return */
323  RefCounter *_refCount; /* Reference count */
324 
329  void _remove();
330 
331  template<class U> friend class SharedPtr;
332 }; // class SharedPtr
333 
334 template<class T>
335 template<class U>
336 SharedPtr<T>::SharedPtr(const SharedPtr<U> &other) : _ownedPtr(other._ownedPtr), _ptr(other._ptr), _refCount(other._refCount)
337 {
338  if(_refCount)
339  _refCount->inc();
340 }
341 
342 template<class T>
343 SharedPtr<T>::SharedPtr(const SharedPtr<T> &other) : _ownedPtr(other._ownedPtr), _ptr(other._ptr), _refCount(other._refCount)
344 {
345  if(_refCount)
346  _refCount->inc();
347 }
348 
349 template<class T>
350 SharedPtr<T>::SharedPtr(const SharedPtr<T> &other, T* shiftedPtr) : _ownedPtr(other._ownedPtr), _ptr(shiftedPtr), _refCount(other._refCount)
351 {
352  if(_refCount)
353  _refCount->inc();
354 }
355 
356 template<class T>
357 template<class U>
358 SharedPtr<T>::SharedPtr(const SharedPtr<U> &other, T *ptr, T* shiftedPtr) : _ownedPtr(ptr), _ptr(shiftedPtr), _refCount(other._refCount)
359 {
360  if(_refCount)
361  _refCount->inc();
362 }
363 
364 template<class T>
365 void SharedPtr<T>::_remove()
366 {
367  if(_refCount && (_refCount->dec() <= 0))
368  {
369  (*_refCount)(_ownedPtr);
370  delete _refCount;
371  _ptr = NULL;
372  }
373 }
374 
375 template<class T>
376 SharedPtr<T> &SharedPtr<T>::operator=(const SharedPtr<T> &ptr)
377 {
378  if (&ptr != this || ptr._ownedPtr != this->_ownedPtr || ptr._ptr != this->_ptr)
379  {
380  _remove();
381  _ownedPtr = ptr._ownedPtr;
382  _refCount = ptr._refCount;
383  _ptr = ptr._ptr;
384  if(_refCount)
385  _refCount->inc();
386  }
387  return *this;
388 }
389 
390 template<class T>
391 template<class U>
392 void SharedPtr<T>::reset(U* ptr)
393 {
394  if(ptr != this->_ownedPtr)
395  {
396  _remove();
397  _ownedPtr = ptr;
398  _ptr = ptr;
399  _refCount = (ptr ? new RefCounterImp<ObjectDeleter<U> >() : NULL);
400  }
401 }
402 
403 template<class T>
404 template<class U, class D>
405 void SharedPtr<T>::reset(U* ptr, const D& deleter)
406 {
407  if(ptr != this->_ownedPtr)
408  {
409  _remove();
410  _ownedPtr = ptr;
411  _ptr = ptr;
412  _refCount = (ptr ? new RefCounterImp<D>(deleter) : NULL);
413  }
414 }
415 
421 template<class T, class U>
422 SharedPtr<T> staticPointerCast(const SharedPtr<U> &r)
423 {
424  T *shifted = static_cast<T *>(r.get());
425  T *start = static_cast<T *>(r.getStartPtr());
426  return SharedPtr<T>(r, start, shifted);
427 }
428 
434 template<class T, class U>
435 SharedPtr<T> reinterpretPointerCast(const SharedPtr<U> &r)
436 {
437  T *shifted = reinterpret_cast<T *>(r.get());
438  T *start = reinterpret_cast<T *>(r.getStartPtr());
439  return SharedPtr<T>(r, start, shifted);
440 }
441 
447 template<class T, class U>
448 SharedPtr<T> dynamicPointerCast(const SharedPtr<U> &r)
449 {
450  T *shifted = dynamic_cast<T *>(r.get());
451  T *start = dynamic_cast<T *>(r.getStartPtr());
452  if (!r.get() || start)
453  {
454  return SharedPtr<T>(r, start, shifted);
455  }
456  else
457  {
458  return SharedPtr<T>();
459  }
460 }
462 } // namespace interface1
463 using interface1::DeleterIface;
464 using interface1::ObjectDeleter;
465 using interface1::EmptyDeleter;
466 using interface1::ServiceDeleter;
467 using interface1::RefCounter;
468 using interface1::RefCounterImp;
469 using interface1::SharedPtr;
470 using interface1::staticPointerCast;
471 using interface1::dynamicPointerCast;
472 using interface1::reinterpretPointerCast;
473 
474 } // namespace services;
475 } // namespace daal
476 
477 #endif
daal::services::interface1::dynamicPointerCast
SharedPtr< T > dynamicPointerCast(const SharedPtr< U > &r)
Definition: daal_shared_ptr.h:448
daal::services::interface1::DeleterIface
Interface for a utility class used within SharedPtr to delete an object when the object owner is dest...
Definition: daal_shared_ptr.h:47
daal::services::interface1::ServiceDeleter::operator()
void operator()(const void *ptr) DAAL_C11_OVERRIDE
Definition: daal_shared_ptr.h:87
daal::services::interface1::SharedPtr::useCount
int useCount() const
Definition: daal_shared_ptr.h:318
daal
Definition: algorithm_base_common.h:31
daal::services::interface1::RefCounterImp
Provides implementations of the operator() method of the RefCounter class.
Definition: daal_shared_ptr.h:131
daal::services::interface1::DeleterIface::operator()
virtual void operator()(const void *ptr)=0
daal::services::interface1::SharedPtr::SharedPtr
SharedPtr(U *ptr, const D &deleter)
Definition: daal_shared_ptr.h:194
daal::services::interface1::RefCounter::~RefCounter
virtual ~RefCounter()
Definition: daal_shared_ptr.h:120
daal::services::interface1::DeleterIface::~DeleterIface
virtual ~DeleterIface()
Definition: daal_shared_ptr.h:53
daal::services::interface1::EmptyDeleter::operator()
void operator()(const void *ptr) DAAL_C11_OVERRIDE
Definition: daal_shared_ptr.h:102
daal::services::interface1::SharedPtr::SharedPtr
SharedPtr(U *ptr)
Definition: daal_shared_ptr.h:180
daal::services::interface1::SharedPtr::operator*
T & operator*() const
Definition: daal_shared_ptr.h:294
daal::services::interface1::ObjectDeleter::operator()
void operator()(const void *ptr) DAAL_C11_OVERRIDE
Definition: daal_shared_ptr.h:72
daal::services::interface1::ObjectDeleter
Implementation of DeleterIface to destroy a pointer by the delete operator.
Definition: daal_shared_ptr.h:69
daal::services::interface1::SharedPtr
Shared pointer that retains shared ownership of an object through a pointer. Several SharedPtr object...
Definition: daal_shared_ptr.h:161
daal::services::interface1::RefCounter
Implementation of reference counter.
Definition: daal_shared_ptr.h:112
daal::services::interface1::SharedPtr::reset
void reset()
Definition: daal_shared_ptr.h:239
daal::services::interface1::RefCounterImp::RefCounterImp
RefCounterImp()
Definition: daal_shared_ptr.h:137
daal::services::interface1::SharedPtr::SharedPtr
SharedPtr()
Definition: daal_shared_ptr.h:171
daal::services::interface1::SharedPtr::_remove
void _remove()
Definition: daal_shared_ptr.h:365
daal::services::interface1::reinterpretPointerCast
SharedPtr< T > reinterpretPointerCast(const SharedPtr< U > &r)
Definition: daal_shared_ptr.h:435
daal::services::daal_free
DAAL_EXPORT void daal_free(void *ptr)
daal::services::interface1::ServiceDeleter
Implementation of DeleterIface to destroy a pointer by the daal_free function.
Definition: daal_shared_ptr.h:84
daal::services::interface1::SharedPtr::~SharedPtr
~SharedPtr()
Definition: daal_shared_ptr.h:228
daal::services::interface1::SharedPtr::operator->
T * operator->() const
Definition: daal_shared_ptr.h:288
daal::services::interface1::SharedPtr::operator=
SharedPtr< T > & operator=(const SharedPtr< T > &ptr)
Definition: daal_shared_ptr.h:376
daal::services::interface1::RefCounter::RefCounter
RefCounter()
Definition: daal_shared_ptr.h:118
daal::services::interface1::RefCounterImp::~RefCounterImp
virtual ~RefCounterImp()
Definition: daal_shared_ptr.h:140
daal::services::interface1::SharedPtr::getStartPtr
T * getStartPtr() const
Definition: daal_shared_ptr.h:312
daal::services::interface1::SharedPtr::operator=
SharedPtr< T > & operator=(const SharedPtr< U > &ptr)
Definition: daal_shared_ptr.h:270
daal::services::interface1::EmptyDeleter
Implementation of DeleterIface without pointer destroying.
Definition: daal_shared_ptr.h:99
daal::services::interface1::staticPointerCast
SharedPtr< T > staticPointerCast(const SharedPtr< U > &r)
Definition: daal_shared_ptr.h:422
daal::services::interface1::SharedPtr::get
T * get() const
Definition: daal_shared_ptr.h:306

For more complete information about compiler optimizations, see our Optimization Notice.