"Fossies" - the Fresh Open Source Software Archive

Member "localpointer_8h_source.html" (3 Oct 2019, 75155 Bytes) of package /linux/misc/icu4c-65_1-docs.zip:


Caution: In this restricted "Fossies" environment the current HTML page may not be correctly presentated and may have some non-functional links. You can here alternatively try to browse the pure source code or just view or download the uninterpreted raw source code. If the rendering is insufficient you may try to find and view the page on the project site itself.

ICU 65.1  65.1
localpointer.h
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 *
6 * Copyright (C) 2009-2016, International Business Machines
7 * Corporation and others. All Rights Reserved.
8 *
9 *******************************************************************************
10 * file name: localpointer.h
11 * encoding: UTF-8
12 * tab size: 8 (not used)
13 * indentation:4
14 *
15 * created on: 2009nov13
16 * created by: Markus W. Scherer
17 */
18 
19 #ifndef __LOCALPOINTER_H__
20 #define __LOCALPOINTER_H__
21 
41 #include "unicode/utypes.h"
42 
43 #if U_SHOW_CPLUSPLUS_API
44 
45 #include <memory>
46 
47 U_NAMESPACE_BEGIN
48 
67 template<typename T>
69 public:
70  // No heap allocation. Use only on the stack.
71  static void* U_EXPORT2 operator new(size_t) = delete;
72  static void* U_EXPORT2 operator new[](size_t) = delete;
73 #if U_HAVE_PLACEMENT_NEW
74  static void* U_EXPORT2 operator new(size_t, void*) = delete;
75 #endif
76 
82  explicit LocalPointerBase(T *p=NULL) : ptr(p) {}
88  ~LocalPointerBase() { /* delete ptr; */ }
94  UBool isNull() const { return ptr==NULL; }
100  UBool isValid() const { return ptr!=NULL; }
108  bool operator==(const T *other) const { return ptr==other; }
116  bool operator!=(const T *other) const { return ptr!=other; }
122  T *getAlias() const { return ptr; }
128  T &operator*() const { return *ptr; }
134  T *operator->() const { return ptr; }
141  T *orphan() {
142  T *p=ptr;
143  ptr=NULL;
144  return p;
145  }
153  void adoptInstead(T *p) {
154  // delete ptr;
155  ptr=p;
156  }
157 protected:
162  T *ptr;
163 private:
164  // No comparison operators with other LocalPointerBases.
165  bool operator==(const LocalPointerBase<T> &other);
166  bool operator!=(const LocalPointerBase<T> &other);
167  // No ownership sharing: No copy constructor, no assignment operator.
169  void operator=(const LocalPointerBase<T> &other);
170 };
171 
190 template<typename T>
191 class LocalPointer : public LocalPointerBase<T> {
192 public:
200  explicit LocalPointer(T *p=NULL) : LocalPointerBase<T>(p) {}
214  LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase<T>(p) {
215  if(p==NULL && U_SUCCESS(errorCode)) {
216  errorCode=U_MEMORY_ALLOCATION_ERROR;
217  }
218  }
225  src.ptr=NULL;
226  }
227 
228 #ifndef U_HIDE_DRAFT_API
229 
239  explicit LocalPointer(std::unique_ptr<T> &&p)
240  : LocalPointerBase<T>(p.release()) {}
241 #endif /* U_HIDE_DRAFT_API */
242 
249  }
260  src.ptr=NULL;
261  return *this;
262  }
263 
264 #ifndef U_HIDE_DRAFT_API
265 
273  LocalPointer<T> &operator=(std::unique_ptr<T> &&p) U_NOEXCEPT {
274  adoptInstead(p.release());
275  return *this;
276  }
277 #endif /* U_HIDE_DRAFT_API */
278 
285  T *temp=LocalPointerBase<T>::ptr;
287  other.ptr=temp;
288  }
295  friend inline void swap(LocalPointer<T> &p1, LocalPointer<T> &p2) U_NOEXCEPT {
296  p1.swap(p2);
297  }
304  void adoptInstead(T *p) {
307  }
323  void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode) {
324  if(U_SUCCESS(errorCode)) {
327  if(p==NULL) {
328  errorCode=U_MEMORY_ALLOCATION_ERROR;
329  }
330  } else {
331  delete p;
332  }
333  }
334 
335 #ifndef U_HIDE_DRAFT_API
336 
347  operator std::unique_ptr<T> () && {
348  return std::unique_ptr<T>(LocalPointerBase<T>::orphan());
349  }
350 #endif /* U_HIDE_DRAFT_API */
351 };
352 
371 template<typename T>
372 class LocalArray : public LocalPointerBase<T> {
373 public:
381  explicit LocalArray(T *p=NULL) : LocalPointerBase<T>(p) {}
395  LocalArray(T *p, UErrorCode &errorCode) : LocalPointerBase<T>(p) {
396  if(p==NULL && U_SUCCESS(errorCode)) {
397  errorCode=U_MEMORY_ALLOCATION_ERROR;
398  }
399  }
406  src.ptr=NULL;
407  }
408 
409 #ifndef U_HIDE_DRAFT_API
410 
420  explicit LocalArray(std::unique_ptr<T[]> &&p)
421  : LocalPointerBase<T>(p.release()) {}
422 #endif /* U_HIDE_DRAFT_API */
423 
429  delete[] LocalPointerBase<T>::ptr;
430  }
439  delete[] LocalPointerBase<T>::ptr;
441  src.ptr=NULL;
442  return *this;
443  }
444 
445 #ifndef U_HIDE_DRAFT_API
446 
454  LocalArray<T> &operator=(std::unique_ptr<T[]> &&p) U_NOEXCEPT {
455  adoptInstead(p.release());
456  return *this;
457  }
458 #endif /* U_HIDE_DRAFT_API */
459 
466  T *temp=LocalPointerBase<T>::ptr;
468  other.ptr=temp;
469  }
476  friend inline void swap(LocalArray<T> &p1, LocalArray<T> &p2) U_NOEXCEPT {
477  p1.swap(p2);
478  }
485  void adoptInstead(T *p) {
486  delete[] LocalPointerBase<T>::ptr;
488  }
504  void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode) {
505  if(U_SUCCESS(errorCode)) {
506  delete[] LocalPointerBase<T>::ptr;
508  if(p==NULL) {
509  errorCode=U_MEMORY_ALLOCATION_ERROR;
510  }
511  } else {
512  delete[] p;
513  }
514  }
522  T &operator[](ptrdiff_t i) const { return LocalPointerBase<T>::ptr[i]; }
523 
524 #ifndef U_HIDE_DRAFT_API
525 
536  operator std::unique_ptr<T[]> () && {
537  return std::unique_ptr<T[]>(LocalPointerBase<T>::orphan());
538  }
539 #endif /* U_HIDE_DRAFT_API */
540 };
541 
562 #define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction) \
563  class LocalPointerClassName : public LocalPointerBase<Type> { \
564  public: \
565  using LocalPointerBase<Type>::operator*; \
566  using LocalPointerBase<Type>::operator->; \
567  explicit LocalPointerClassName(Type *p=NULL) : LocalPointerBase<Type>(p) {} \
568  LocalPointerClassName(LocalPointerClassName &&src) U_NOEXCEPT \
569  : LocalPointerBase<Type>(src.ptr) { \
570  src.ptr=NULL; \
571  } \
572  /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */ \
573  explicit LocalPointerClassName(std::unique_ptr<Type, decltype(&closeFunction)> &&p) \
574  : LocalPointerBase<Type>(p.release()) {} \
575  ~LocalPointerClassName() { if (ptr != NULL) { closeFunction(ptr); } } \
576  LocalPointerClassName &operator=(LocalPointerClassName &&src) U_NOEXCEPT { \
577  if (ptr != NULL) { closeFunction(ptr); } \
578  LocalPointerBase<Type>::ptr=src.ptr; \
579  src.ptr=NULL; \
580  return *this; \
581  } \
582  /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */ \
583  LocalPointerClassName &operator=(std::unique_ptr<Type, decltype(&closeFunction)> &&p) { \
584  adoptInstead(p.release()); \
585  return *this; \
586  } \
587  void swap(LocalPointerClassName &other) U_NOEXCEPT { \
588  Type *temp=LocalPointerBase<Type>::ptr; \
589  LocalPointerBase<Type>::ptr=other.ptr; \
590  other.ptr=temp; \
591  } \
592  friend inline void swap(LocalPointerClassName &p1, LocalPointerClassName &p2) U_NOEXCEPT { \
593  p1.swap(p2); \
594  } \
595  void adoptInstead(Type *p) { \
596  if (ptr != NULL) { closeFunction(ptr); } \
597  ptr=p; \
598  } \
599  operator std::unique_ptr<Type, decltype(&closeFunction)> () && { \
600  return std::unique_ptr<Type, decltype(&closeFunction)>(LocalPointerBase<Type>::orphan(), closeFunction); \
601  } \
602  }
603 
604 U_NAMESPACE_END
605 
606 #endif /* U_SHOW_CPLUSPLUS_API */
607 #endif /* __LOCALPOINTER_H__ */
LocalPointer< T > & operator=(LocalPointer< T > &&src) U_NOEXCEPT
Move assignment operator, leaves src with isNull().
Definition: localpointer.h:257
void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode)
Deletes the array it owns, and adopts (takes ownership of) the one passed in.
Definition: localpointer.h:504
T & operator[](ptrdiff_t i) const
Array item access (writable).
Definition: localpointer.h:522
T * getAlias() const
Access without ownership change.
Definition: localpointer.h:122
void adoptInstead(T *p)
Deletes the object it owns, and adopts (takes ownership of) the one passed in.
Definition: localpointer.h:304
#define U_SUCCESS(x)
Does the error code indicate success?
Definition: utypes.h:704
LocalPointer(T *p, UErrorCode &errorCode)
Constructor takes ownership and reports an error if NULL.
Definition: localpointer.h:214
LocalPointer(std::unique_ptr< T > &&p)
Constructs a LocalPointer from a C++11 std::unique_ptr.
Definition: localpointer.h:239
LocalArray(T *p=NULL)
Constructor takes ownership.
Definition: localpointer.h:381
"Smart pointer" class, deletes objects via the standard C++ delete operator.
Definition: localpointer.h:191
LocalArray(T *p, UErrorCode &errorCode)
Constructor takes ownership and reports an error if NULL.
Definition: localpointer.h:395
U_EXPORT UBool operator==(const StringPiece &x, const StringPiece &y)
Global operator == for StringPiece.
void swap(LocalPointer< T > &other) U_NOEXCEPT
Swap pointers.
Definition: localpointer.h:284
LocalPointer< T > & operator=(std::unique_ptr< T > &&p) U_NOEXCEPT
Move-assign from an std::unique_ptr to this LocalPointer.
Definition: localpointer.h:273
T * ptr
Actual pointer.
Definition: localpointer.h:162
Memory allocation error.
Definition: utypes.h:457
bool operator!=(const T *other) const
Comparison with a simple pointer, so that existing code with !=NULL need not be changed.
Definition: localpointer.h:116
LocalPointer(T *p=NULL)
Constructor takes ownership.
Definition: localpointer.h:200
friend void swap(LocalPointer< T > &p1, LocalPointer< T > &p2) U_NOEXCEPT
Non-member LocalPointer swap function.
Definition: localpointer.h:295
T * orphan()
Gives up ownership; the internal pointer becomes NULL.
Definition: localpointer.h:141
LocalPointerBase(T *p=NULL)
Constructor takes ownership.
Definition: localpointer.h:82
"Smart pointer" base class; do not use directly: use LocalPointer etc.
Definition: localpointer.h:68
UBool isNull() const
NULL check.
Definition: localpointer.h:94
LocalPointer(LocalPointer< T > &&src) U_NOEXCEPT
Move constructor, leaves src with isNull().
Definition: localpointer.h:224
LocalArray(std::unique_ptr< T[]> &&p)
Constructs a LocalArray from a C++11 std::unique_ptr of an array type.
Definition: localpointer.h:420
UBool operator!=(const StringPiece &x, const StringPiece &y)
Global operator != for StringPiece.
Definition: stringpiece.h:251
friend void swap(LocalArray< T > &p1, LocalArray< T > &p2) U_NOEXCEPT
Non-member LocalArray swap function.
Definition: localpointer.h:476
#define NULL
Define NULL if necessary, to nullptr for C++ and to ((void *)0) for C.
Definition: utypes.h:188
"Smart pointer" class, deletes objects via the C++ array delete[] operator.
Definition: localpointer.h:372
LocalArray(LocalArray< T > &&src) U_NOEXCEPT
Move constructor, leaves src with isNull().
Definition: localpointer.h:405
~LocalPointer()
Destructor deletes the object it owns.
Definition: localpointer.h:247
#define U_NOEXCEPT
"noexcept" if supported, otherwise empty.
Definition: platform.h:529
LocalArray< T > & operator=(LocalArray< T > &&src) U_NOEXCEPT
Move assignment operator, leaves src with isNull().
Definition: localpointer.h:438
void adoptInstead(T *p)
Deletes the array it owns, and adopts (takes ownership of) the one passed in.
Definition: localpointer.h:485
UBool isValid() const
NULL check.
Definition: localpointer.h:100
bool operator==(const T *other) const
Comparison with a simple pointer, so that existing code with ==NULL need not be changed.
Definition: localpointer.h:108
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition: utypes.h:415
void swap(LocalArray< T > &other) U_NOEXCEPT
Swap pointers.
Definition: localpointer.h:465
~LocalArray()
Destructor deletes the array it owns.
Definition: localpointer.h:428
T * operator->() const
Access without ownership change.
Definition: localpointer.h:134
void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode)
Deletes the object it owns, and adopts (takes ownership of) the one passed in.
Definition: localpointer.h:323
T & operator*() const
Access without ownership change.
Definition: localpointer.h:128
~LocalPointerBase()
Destructor deletes the object it owns.
Definition: localpointer.h:88
Basic definitions for ICU, for both C and C++ APIs.
void adoptInstead(T *p)
Deletes the object it owns, and adopts (takes ownership of) the one passed in.
Definition: localpointer.h:153
LocalArray< T > & operator=(std::unique_ptr< T[]> &&p) U_NOEXCEPT
Move-assign from an std::unique_ptr to this LocalPointer.
Definition: localpointer.h:454
int8_t UBool
The ICU boolean type.
Definition: umachine.h:261