Owner.h

Go to the documentation of this file.

//-
// ================================================================================================
// Copyright 2025 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license agreement provided
// at the time of installation or download, or which otherwise accompanies this software in
// either electronic or hard copy form.
// ================================================================================================
//+
 
 
#ifndef BIFROSTGRAPH_EXECUTOR_OWNER_H
#define BIFROSTGRAPH_EXECUTOR_OWNER_H
 
#include <BifrostGraph/Executor/internal/OwnerRep.h>
#include <BifrostGraph/Executor/internal/PointeeTraits.h>
 
#include <type_traits>
#include <utility>
 
namespace BifrostGraph {
namespace Executor {
 
 
template <typename T>
class Owner : private Internal::OwnerRep<T> {
private:
    template <typename P>
    using if_convertible_from =
        typename std::enable_if<std::is_convertible<P*, T*>::value>::type;
 
    template <typename P>
    using if_compliant_and_convertible_from =
        typename std::enable_if<std::is_convertible<P*, T*>::value &&
                                Internal::PointeeTraits::is_compliant<P>::value>::type;
 
    using OwnerRep = Internal::OwnerRep<T>;
 
public:
    // Requirements
    static_assert(Internal::PointeeTraits::is_compliant<T>::value,
                  "Owner class template requires an object type T, "
                  "and T cannot be a pointer or a reference or an array (e.g. int[]), "
                  "and T must not include `const` nor `volatile` qualifiers.");
 
    Owner() noexcept : OwnerRep() {}
 
    template <typename P, typename = if_compliant_and_convertible_from<P>>
    Owner(P* p) noexcept {
        OwnerRep::template init<P>(p);
    }
 
    template <typename P>
    using DeleterFunc = void (*)(P* p);
 
    template <typename P, typename = if_compliant_and_convertible_from<P>>
    Owner(P* p, DeleterFunc<P> d) noexcept {
        OwnerRep::template init<P>(p, d);
    }
 
    ~Owner() noexcept = default;
 
    Owner(Owner&& rhs) noexcept = default;
 
    template <typename P, typename = if_convertible_from<P>>
    Owner(Owner<P>&& rhs) noexcept : OwnerRep(std::move(rhs)) {}
 
    Owner& operator=(Owner&& rhs) noexcept = default;
 
    explicit constexpr operator bool() const noexcept { return OwnerRep::operator bool(); }
 
    const T& operator*() const noexcept { return OwnerRep::operator*(); }
 
    T& operator*() noexcept { return OwnerRep::operator*(); }
 
    const T* operator->() const noexcept { return OwnerRep::operator->(); }
 
    T* operator->() noexcept { return OwnerRep::operator->(); }
 
    const T* get() const noexcept { return OwnerRep::get(); }
 
    T* get() noexcept { return OwnerRep::get(); }
 
    Owner& reset() noexcept {
        OwnerRep::reset();
        return *this;
    }
 
    void swap(Owner& other) noexcept { OwnerRep::swap(other); }
 
private:
    Owner(const Owner&) = delete;
    Owner& operator=(const Owner&) = delete;
 
    template <class P>
    friend class Owner;
};
 
} // namespace Executor
} // namespace BifrostGraph
 
#endif // BIFROSTGRAPH_EXECUTOR_OWNER_H