Movatterモバイル変換

localpointer.h

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>

68 classLocalPointerBase {

69 public:

70 // No heap allocation. Use only on the stack.

71 staticvoid* U_EXPORT2operatornew(size_t) =delete;

72 staticvoid* U_EXPORT2operatornew[](size_t) =delete;

73 #if U_HAVE_PLACEMENT_NEW

74 staticvoid* U_EXPORT2operatornew(size_t,void*) =delete;

75 #endif

76 

82 explicitLocalPointerBase(T *p=nullptr) : ptr(p) {}

88 ~LocalPointerBase() {/* delete ptr; */ }

94 UBoolisNull() const{return ptr==nullptr; }

100 UBoolisValid() const{return ptr!=nullptr; }

108 booloperator==(const T *other) const{return ptr==other; }

116 booloperator!=(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=nullptr;

144 return p;

145  }

153 voidadoptInstead(T *p) {

154 // delete ptr;

155  ptr=p;

156  }

157 protected:

162  T *ptr;

163 private:

164 // No comparison operators with other LocalPointerBases.

165 booloperator==(constLocalPointerBase<T> &other) =delete;

166 booloperator!=(constLocalPointerBase<T> &other) =delete;

167 // No ownership sharing: No copy constructor, no assignment operator.

168 LocalPointerBase(constLocalPointerBase<T> &other) =delete;

169 void operator=(constLocalPointerBase<T> &other) =delete;

170 };

171 

190 template<typename T>

191 classLocalPointer :publicLocalPointerBase<T> {

192 public:

193 usingLocalPointerBase<T>::operator*;

194 usingLocalPointerBase<T>::operator->;

200 explicitLocalPointer(T *p=nullptr) :LocalPointerBase<T>(p) {}

214 LocalPointer(T *p,UErrorCode &errorCode) :LocalPointerBase<T>(p) {

215 if(p==nullptr &&U_SUCCESS(errorCode)) {

216  errorCode=U_MEMORY_ALLOCATION_ERROR;

217  }

218  }

224 LocalPointer(LocalPointer<T> &&src) noexcept :LocalPointerBase<T>(src.ptr) {

225  src.ptr=nullptr;

226  }

227 

238 explicitLocalPointer(std::unique_ptr<T> &&p)

239  :LocalPointerBase<T>(p.release()) {}

240 

245 ~LocalPointer() {

246 deleteLocalPointerBase<T>::ptr;

247  }

255 LocalPointer<T> &operator=(LocalPointer<T> &&src) noexcept {

256 deleteLocalPointerBase<T>::ptr;

257 LocalPointerBase<T>::ptr=src.ptr;

258  src.ptr=nullptr;

259 return *this;

260  }

261 

270 LocalPointer<T> &operator=(std::unique_ptr<T> &&p) noexcept {

271  adoptInstead(p.release());

272 return *this;

273  }

274 

280 voidswap(LocalPointer<T> &other) noexcept {

281  T *temp=LocalPointerBase<T>::ptr;

282 LocalPointerBase<T>::ptr=other.ptr;

283  other.ptr=temp;

284  }

291 friendinlinevoidswap(LocalPointer<T> &p1,LocalPointer<T> &p2) noexcept {

292  p1.swap(p2);

293  }

300 voidadoptInstead(T *p) {

301 deleteLocalPointerBase<T>::ptr;

302 LocalPointerBase<T>::ptr=p;

303  }

319 voidadoptInsteadAndCheckErrorCode(T *p,UErrorCode &errorCode) {

320 if(U_SUCCESS(errorCode)) {

321 deleteLocalPointerBase<T>::ptr;

322 LocalPointerBase<T>::ptr=p;

323 if(p==nullptr) {

324  errorCode=U_MEMORY_ALLOCATION_ERROR;

325  }

326  }else {

327 delete p;

328  }

329  }

330 

342 operator std::unique_ptr<T> () && {

343 return std::unique_ptr<T>(LocalPointerBase<T>::orphan());

344  }

345 };

346 

365 template<typename T>

366 classLocalArray :publicLocalPointerBase<T> {

367 public:

368 usingLocalPointerBase<T>::operator*;

369 usingLocalPointerBase<T>::operator->;

375 explicitLocalArray(T *p=nullptr) :LocalPointerBase<T>(p) {}

389 LocalArray(T *p,UErrorCode &errorCode) :LocalPointerBase<T>(p) {

390 if(p==nullptr &&U_SUCCESS(errorCode)) {

391  errorCode=U_MEMORY_ALLOCATION_ERROR;

392  }

393  }

399 LocalArray(LocalArray<T> &&src) noexcept :LocalPointerBase<T>(src.ptr) {

400  src.ptr=nullptr;

401  }

402 

413 explicitLocalArray(std::unique_ptr<T[]> &&p)

414  :LocalPointerBase<T>(p.release()) {}

415 

420 ~LocalArray() {

421 delete[]LocalPointerBase<T>::ptr;

422  }

430 LocalArray<T> &operator=(LocalArray<T> &&src) noexcept {

431 delete[]LocalPointerBase<T>::ptr;

432 LocalPointerBase<T>::ptr=src.ptr;

433  src.ptr=nullptr;

434 return *this;

435  }

436 

445 LocalArray<T> &operator=(std::unique_ptr<T[]> &&p) noexcept {

446  adoptInstead(p.release());

447 return *this;

448  }

449 

455 voidswap(LocalArray<T> &other) noexcept {

456  T *temp=LocalPointerBase<T>::ptr;

457 LocalPointerBase<T>::ptr=other.ptr;

458  other.ptr=temp;

459  }

466 friendinlinevoidswap(LocalArray<T> &p1,LocalArray<T> &p2) noexcept {

467  p1.swap(p2);

468  }

475 voidadoptInstead(T *p) {

476 delete[]LocalPointerBase<T>::ptr;

477 LocalPointerBase<T>::ptr=p;

478  }

494 voidadoptInsteadAndCheckErrorCode(T *p,UErrorCode &errorCode) {

495 if(U_SUCCESS(errorCode)) {

496 delete[]LocalPointerBase<T>::ptr;

497 LocalPointerBase<T>::ptr=p;

498 if(p==nullptr) {

499  errorCode=U_MEMORY_ALLOCATION_ERROR;

500  }

501  }else {

502 delete[] p;

503  }

504  }

512  T &operator[](ptrdiff_t i) const{returnLocalPointerBase<T>::ptr[i]; }

513 

525 operator std::unique_ptr<T[]> () && {

526 return std::unique_ptr<T[]>(LocalPointerBase<T>::orphan());

527  }

528 };

529 

550 #define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction) \

551  using LocalPointerClassName = internal::LocalOpenPointer<Type, closeFunction>

552 

553 #ifndef U_IN_DOXYGEN

554 namespaceinternal {

561 template <typename Type, auto closeFunction>

562 classLocalOpenPointer :public LocalPointerBase<Type> {

563 using LocalPointerBase<Type>::ptr;

564 public:

565 using LocalPointerBase<Type>::operator*;

566 using LocalPointerBase<Type>::operator->;

567 explicit LocalOpenPointer(Type *p=nullptr) : LocalPointerBase<Type>(p) {}

568  LocalOpenPointer(LocalOpenPointer &&src) noexcept

569  : LocalPointerBase<Type>(src.ptr) {

570  src.ptr=nullptr;

571  }

572 /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */

573 explicit LocalOpenPointer(std::unique_ptr<Type, decltype(closeFunction)> &&p)

574  : LocalPointerBase<Type>(p.release()) {}

575  ~LocalOpenPointer() {if (ptr !=nullptr) { closeFunction(ptr); } }

576  LocalOpenPointer &operator=(LocalOpenPointer &&src) noexcept {

577 if (ptr !=nullptr) { closeFunction(ptr); }

578  LocalPointerBase<Type>::ptr=src.ptr;

579  src.ptr=nullptr;

580 return *this;

581  }

582 /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */

583  LocalOpenPointer &operator=(std::unique_ptr<Type, decltype(closeFunction)> &&p) {

584  adoptInstead(p.release());

585 return *this;

586  }

587 void swap(LocalOpenPointer &other) noexcept {

588  Type *temp=LocalPointerBase<Type>::ptr;

589  LocalPointerBase<Type>::ptr=other.ptr;

590  other.ptr=temp;

591  }

592 friendinlinevoid swap(LocalOpenPointer &p1, LocalOpenPointer &p2) noexcept {

593  p1.swap(p2);

594  }

595 void adoptInstead(Type *p) {

596 if (ptr !=nullptr) { 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 }// namespace internal

604 #endif

605 

606 U_NAMESPACE_END

607 

608 #endif/* U_SHOW_CPLUSPLUS_API */

609 #endif/* __LOCALPOINTER_H__ */