| // Copyright 2016 The PDFium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #ifndef CORE_FXCRT_MAYBE_OWNED_H_ | |
| #define CORE_FXCRT_MAYBE_OWNED_H_ | |
| #include <memory> | |
| #include <utility> | |
| #include "core/fxcrt/unowned_ptr.h" | |
| #include "third_party/abseil-cpp/absl/types/variant.h" | |
| namespace fxcrt { | |
| // A template that can hold either owned or unowned references, and cleans up | |
| // appropriately. Possibly the most pernicious anti-pattern imaginable, but | |
| // it crops up throughout the codebase due to a desire to avoid copying-in | |
| // objects or data. | |
| template <typename T, typename D = std::default_delete<T>> | |
| class MaybeOwned { | |
| public: | |
| using OwnedType = std::unique_ptr<T, D>; | |
| using UnownedType = UnownedPtr<T>; | |
| MaybeOwned() = default; | |
| explicit MaybeOwned(T* ptr) : ptr_(UnownedType(ptr)) {} | |
| explicit MaybeOwned(const UnownedType& ptr) : ptr_(ptr) {} | |
| explicit MaybeOwned(OwnedType ptr) : ptr_(std::move(ptr)) {} | |
| MaybeOwned(const MaybeOwned& that) = delete; | |
| MaybeOwned(MaybeOwned&& that) noexcept = default; | |
| MaybeOwned& operator=(const MaybeOwned& that) = delete; | |
| MaybeOwned& operator=(MaybeOwned&& that) noexcept = default; | |
| ~MaybeOwned() = default; | |
| void Reset(T* ptr = nullptr) { ptr_ = UnownedType(ptr); } | |
| void Reset(OwnedType ptr) { ptr_ = std::move(ptr); } | |
| bool IsOwned() const { return absl::holds_alternative<OwnedType>(ptr_); } | |
| // Helpful for untangling a collection of intertwined MaybeOwned<>. | |
| void ResetIfUnowned() { | |
| if (!IsOwned()) | |
| Reset(); | |
| } | |
| T* Get() const& { | |
| return absl::visit([](const auto& obj) { return obj.get(); }, ptr_); | |
| } | |
| T* Get() && { | |
| auto local_variable_preventing_move_elision = std::move(ptr_); | |
| return absl::visit([](const auto& obj) { return obj.get(); }, | |
| local_variable_preventing_move_elision); | |
| } | |
| // Downgrades to unowned, caller takes ownership. | |
| OwnedType Release() { | |
| auto result = std::move(absl::get<OwnedType>(ptr_)); | |
| ptr_ = UnownedType(result.get()); | |
| return result; | |
| } | |
| // Downgrades to empty, caller takes ownership. | |
| OwnedType ReleaseAndClear() { | |
| auto result = std::move(absl::get<OwnedType>(ptr_)); | |
| ptr_ = UnownedType(); | |
| return result; | |
| } | |
| MaybeOwned& operator=(T* ptr) { | |
| Reset(ptr); | |
| return *this; | |
| } | |
| MaybeOwned& operator=(const UnownedType& ptr) { | |
| Reset(ptr); | |
| return *this; | |
| } | |
| MaybeOwned& operator=(OwnedType ptr) { | |
| Reset(std::move(ptr)); | |
| return *this; | |
| } | |
| bool operator==(const MaybeOwned& that) const { return Get() == that.Get(); } | |
| bool operator==(const OwnedType& ptr) const { return Get() == ptr.get(); } | |
| bool operator==(T* ptr) const { return Get() == ptr; } | |
| bool operator!=(const MaybeOwned& that) const { return !(*this == that); } | |
| bool operator!=(const OwnedType ptr) const { return !(*this == ptr); } | |
| bool operator!=(T* ptr) const { return !(*this == ptr); } | |
| explicit operator bool() const { return !!Get(); } | |
| T& operator*() const { return *Get(); } | |
| T* operator->() const { return Get(); } | |
| private: | |
| absl::variant<UnownedType, OwnedType> ptr_; | |
| }; | |
| } // namespace fxcrt | |
| using fxcrt::MaybeOwned; | |
| #endif // CORE_FXCRT_MAYBE_OWNED_H_ |