121 lines
3.3 KiB
C++
121 lines
3.3 KiB
C++
/*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <memory>
|
|
|
|
namespace folly {
|
|
|
|
/**
|
|
* MaybeManagedPtr stores either a raw pointer or a shared_ptr. It provides
|
|
* normal pointer operations on the underlying raw pointer/shared_ptr.
|
|
*
|
|
* When storing a raw pointer, MaybeManagedPtr does not manage the pointer's
|
|
* lifetime, i.e. never calls `free` on the pointer.
|
|
*
|
|
* When storing a shared_ptr, MaybeManagedPtr will release the shared_ptr
|
|
* upon its own destruction.
|
|
*/
|
|
template <typename T>
|
|
class MaybeManagedPtr {
|
|
public:
|
|
/* implicit */ MaybeManagedPtr(T* t)
|
|
: t_(std::shared_ptr<T>(std::shared_ptr<void>(), t)) {}
|
|
/* implicit */ MaybeManagedPtr(std::shared_ptr<T> t) : t_(t) {}
|
|
|
|
/**
|
|
* Get pointer to the element contained in MaybeManagedPtr.
|
|
*
|
|
* @return Pointer to the element contained in MaybeManagedPtr.
|
|
*/
|
|
[[nodiscard]] T* get() const { return t_.get(); }
|
|
|
|
/**
|
|
* Return use count of the underlying shared pointer.
|
|
*
|
|
* @return Use count of the underlying shared pointer.
|
|
*/
|
|
[[nodiscard]] long useCount() const { return t_.use_count(); }
|
|
|
|
/**
|
|
* Member of pointer operator
|
|
*
|
|
* @return Pointer to the element contained in MaybeManagedPtr.
|
|
*/
|
|
constexpr T* operator->() const { return t_.get(); }
|
|
|
|
/**
|
|
* Indirection operator
|
|
*
|
|
* @return Reference to the element contained in MaybeManagedPtr.
|
|
*/
|
|
constexpr T& operator*() const& { return *t_.get(); }
|
|
|
|
/**
|
|
* Boolean type conversion operator
|
|
*
|
|
* @return Returns true if the underlying shared pointer is not
|
|
* null.
|
|
*/
|
|
operator bool() const { return (t_.get() != nullptr); }
|
|
|
|
/**
|
|
* Boolean equal to operator
|
|
*
|
|
* @return Returns true if the underlying shared pointer is equal
|
|
* to rhs.
|
|
*/
|
|
bool operator==(T* rhs) const { return t_.get() == rhs; }
|
|
|
|
/**
|
|
* Boolean equal to operator
|
|
*
|
|
* @return Returns true if the underlying shared pointer is equal
|
|
* to rhs.
|
|
*/
|
|
bool operator==(const std::shared_ptr<T>& rhs) const { return t_ == rhs; }
|
|
|
|
/**
|
|
* Boolean not equal to operator
|
|
*
|
|
* @return Returns true if the underlying shared pointer is not
|
|
* equal to rhs.
|
|
*/
|
|
bool operator!=(T* rhs) const { return !(t_.get() == rhs); }
|
|
|
|
/**
|
|
* Boolean not equal to operator
|
|
*
|
|
* @return Returns true if the underlying shared pointer is not
|
|
* equal to rhs.
|
|
*/
|
|
bool operator!=(const std::shared_ptr<T>& rhs) const { return !(t_ == rhs); }
|
|
|
|
/**
|
|
* Pointer type conversion operator
|
|
*
|
|
* @return Returns a pointer to the element contained in
|
|
* MaybeManagedPtr.
|
|
*/
|
|
operator T*() const { return t_.get(); }
|
|
|
|
private:
|
|
std::shared_ptr<T> t_;
|
|
};
|
|
|
|
} // namespace folly
|