delegatedCountPtr.h

//
// Copyright 2024 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
 
#ifndef PXR_BASE_TF_DELEGATED_COUNT_PTR_H
#define PXR_BASE_TF_DELEGATED_COUNT_PTR_H
 
#include "pxr/pxr.h"
#include "pxr/base/tf/tf.h"
#include "pxr/base/tf/api.h"
 
#include "pxr/base/tf/diagnosticLite.h"
 
#include <memory>
#include <type_traits>
#include <utility>
 
PXR_NAMESPACE_OPEN_SCOPE
 
constexpr struct TfDelegatedCountIncrementTagType{}
    TfDelegatedCountIncrementTag{};
 
constexpr struct TfDelegatedCountDoNotIncrementTagType{}
    TfDelegatedCountDoNotIncrementTag{};
 
template <typename ValueType>
class TfDelegatedCountPtr {
public:
    using RawPtrType = std::add_pointer_t<ValueType>;
    using ReferenceType = std::add_lvalue_reference_t<ValueType>;
    using element_type = ValueType;
 
    static_assert(
        std::is_same_v<
            void,
            decltype(TfDelegatedCountIncrement(std::declval<RawPtrType>()))>);
    static_assert(
        std::is_same_v<
            void,
            decltype(TfDelegatedCountDecrement(std::declval<RawPtrType>()))>);
 
    using IncrementIsNoExcept =
        std::integral_constant<
            bool,
            noexcept(TfDelegatedCountIncrement(std::declval<RawPtrType>()))>;
    using DecrementIsNoExcept =
        std::integral_constant<
            bool,
            noexcept(TfDelegatedCountDecrement(std::declval<RawPtrType>()))>;
    using IncrementAndDecrementAreNoExcept =
        std::integral_constant<
            bool, IncrementIsNoExcept() && DecrementIsNoExcept()>;
    using DereferenceIsNoExcept =
        std::integral_constant<bool, noexcept(*std::declval<RawPtrType>())>;
 
private:
    template <typename ConvertibleType>
    using _IsPtrConvertible = std::is_convertible<
        std::add_pointer_t<ConvertibleType>, RawPtrType>;
 
public:
    TfDelegatedCountPtr() noexcept = default;
 
    TfDelegatedCountPtr(TfDelegatedCountDoNotIncrementTagType,
                        RawPtrType rawPointer) noexcept :
        _pointer{rawPointer} {
    }
 
    TfDelegatedCountPtr(TfDelegatedCountIncrementTagType,
                        RawPtrType rawPointer)
    noexcept(IncrementIsNoExcept()) :
        _pointer{rawPointer} {
        _IncrementIfValid();
    }
 
    TfDelegatedCountPtr(const TfDelegatedCountPtr& ptr)
    noexcept(IncrementIsNoExcept()) :
        _pointer{ptr.get()} {
        _IncrementIfValid();
    }
 
    template <typename OtherType>
    explicit TfDelegatedCountPtr(
        const TfDelegatedCountPtr<OtherType>& ptr,
        std::enable_if_t<_IsPtrConvertible<OtherType>::value, int> = 0)
    noexcept(IncrementIsNoExcept()) :
        _pointer(ptr.get()) {
        _IncrementIfValid();
    }
 
    TfDelegatedCountPtr(TfDelegatedCountPtr&& ptr) noexcept :
        _pointer(ptr.get()) {
        ptr._pointer = nullptr;
    }
 
    TfDelegatedCountPtr& operator=(const TfDelegatedCountPtr& ptr)
    noexcept(IncrementAndDecrementAreNoExcept()) {
        // Implement copy assigment in terms of move assignment
        return (*this = TfDelegatedCountPtr{ptr});
    }
 
    template <typename OtherType>
    TfDelegatedCountPtr& operator=(
        const TfDelegatedCountPtr<OtherType>& ptr)
    noexcept(IncrementAndDecrementAreNoExcept()) {
        static_assert(_IsPtrConvertible<OtherType>::value);
        // Implement copy assigment in terms of move assignment
        return (*this = TfDelegatedCountPtr{ptr});
    }
 
    TfDelegatedCountPtr& operator=(TfDelegatedCountPtr&& ptr)
    noexcept(DecrementIsNoExcept()) {
        _DecrementIfValid();
        _pointer = ptr.get();
        ptr._pointer = nullptr;
        return *this;
    }
 
    TfDelegatedCountPtr& operator=(std::nullptr_t)
    noexcept(DecrementIsNoExcept()) {
        reset();
        return *this;
    }
 
    ~TfDelegatedCountPtr() noexcept(DecrementIsNoExcept::value) {
        _DecrementIfValid();
    }
 
    ReferenceType operator*() const noexcept(DereferenceIsNoExcept()) {
        return *get();
    }
 
    RawPtrType operator->() const noexcept {
        return get();
    }
 
    explicit operator bool() const noexcept { return get(); }
 
    template <typename OtherType>
    bool operator==(
        const TfDelegatedCountPtr<OtherType>& other) const noexcept {
        return get() == other.get();
    }
 
    template <typename OtherType>
    bool operator!=(
        const TfDelegatedCountPtr<OtherType>& other) const noexcept {
        return get() != other.get();
    }
 
    template <typename OtherType>
    bool operator<(
        const TfDelegatedCountPtr<OtherType>& other) const noexcept {
        return get() < other.get();
    }
 
    RawPtrType get() const noexcept { return _pointer; }
 
    void reset() noexcept(DecrementIsNoExcept()) {
        _DecrementIfValid();
        _pointer = nullptr;
    }
 
    void swap(TfDelegatedCountPtr& other) noexcept {
        std::swap(other._pointer, _pointer);
    }
 
private:
    void _IncrementIfValid() noexcept(IncrementIsNoExcept()) {
        if (_pointer) {
             TfDelegatedCountIncrement(_pointer);
        }
    }
 
    void _DecrementIfValid() noexcept(DecrementIsNoExcept()) {
        if (_pointer) {
            TfDelegatedCountDecrement(_pointer);
        }
    }
 
    ValueType* _pointer{nullptr};    
};
 
template <typename ValueType, typename... Args>
TfDelegatedCountPtr<ValueType>
TfMakeDelegatedCountPtr(Args&&... args) {
    return TfDelegatedCountPtr<ValueType>(
        TfDelegatedCountIncrementTag,
        new ValueType(std::forward<Args>(args)...)
    );
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif