TransientConstSharedPtr.h

Go to the documentation of this file.

 
/*
 * Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration.
 */
#ifndef GEOMODELUTILITIES_TRANSIENTCONSTSHAREDPTR_H
#define GEOMODELUTILITIES_TRANSIENTCONSTSHAREDPTR_H
 
#include <memory>
namespace GeoModel {
    template <typename Obj> class TransientConstSharedPtr {
    public:
        template <typename DerivType> friend class GeoModel::TransientConstSharedPtr;
        using element_type = Obj;
        Obj* get() { return m_ptr.get(); }
        Obj* operator->() { return get(); }
        const Obj* get() const { return m_ptr.get(); }
        const Obj* operator->() const { return get(); }
        const Obj& operator*() const { return *m_ptr; }
        Obj& operator*() { return *m_ptr; }

        template <typename DerivType>
        TransientConstSharedPtr(std::unique_ptr<DerivType> ptr) 
        requires(std::is_base_of_v<Obj, DerivType>): m_ptr{std::move(ptr)} {}

        template <typename DerivType>
        TransientConstSharedPtr(std::shared_ptr<DerivType> ptr) 
            requires(std::is_base_of_v<Obj, DerivType>) : m_ptr{std::move(ptr)} {}

        TransientConstSharedPtr(Obj* ptr) : m_ptr{ptr} {}

        TransientConstSharedPtr() = default;
        template <typename DerivType>
        TransientConstSharedPtr(const TransientConstSharedPtr<DerivType>& other)
            requires(std::is_base_of_v<Obj, DerivType>) :
             m_ptr{other.m_ptr}{}

        template <typename DerivType>
        TransientConstSharedPtr(TransientConstSharedPtr<DerivType>&& other)
            requires(std::is_base_of_v<Obj, DerivType>) :
                m_ptr{std::move(other.m_ptr)}{}

        template <typename DerivType>
        TransientConstSharedPtr& operator=(const TransientConstSharedPtr<DerivType>& other)
            requires(std::is_base_of_v<Obj, DerivType>) {
            if (&other != this) {
                m_ptr = other.m_ptr;
            }
            return *this;
        }
        template <typename DerivType>
        TransientConstSharedPtr& operator=(const std::shared_ptr<DerivType>& other)
            requires(std::is_base_of_v<Obj, DerivType>) {
            m_ptr = other.m_ptr;
            return *this;
        }

        template <typename DerivType>
        TransientConstSharedPtr& operator=(TransientConstSharedPtr<DerivType>&& other)
            requires(std::is_base_of_v<Obj, DerivType>) {
            m_ptr = std::move(other.m_ptr);
            return *this;
        }
        template <typename DerivType>
        TransientConstSharedPtr& operator=(std::unique_ptr<DerivType>&& other) 
            requires(std::is_base_of_v<Obj, DerivType>) {
            m_ptr = std::move(other);
            return *this;
        }
        template <typename DerivType>
        TransientConstSharedPtr& operator=(std::shared_ptr<DerivType>&& other)
            requires(std::is_base_of_v<Obj, DerivType>) {
            m_ptr = std::move(other);
            return *this;
        }

        template <typename DerivType>
        void reset(std::unique_ptr<DerivType> newObj) 
            requires(std::is_base_of_v<Obj, DerivType>) { 
                m_ptr = std::move(newObj); 
        }
        template <typename DerivType>
        void reset(std::shared_ptr<DerivType>&& newObj) 
            requires(std::is_base_of_v<Obj, DerivType>) { 
                m_ptr = std::move(newObj); 
        }
        template <typename DerivType>
        void reset(const std::shared_ptr<DerivType>& newObj) 
            requires(std::is_base_of_v<Obj, DerivType>) { 
                m_ptr = std::move(newObj); 
        }
        void reset() { m_ptr.reset(); }
        std::shared_ptr<const Obj> release() { return std::move(m_ptr); }
        operator bool() const { return m_ptr.get() != nullptr; }
        bool operator!() const { return !m_ptr; }
        size_t use_count() const { return m_ptr.use_count(); }

        bool operator<(const TransientConstSharedPtr& other) const { 
            return get() < other.get(); 
        }

        bool operator ==(const TransientConstSharedPtr& other) const {
            return other.get() == get();
        }
        bool operator !=(const TransientConstSharedPtr& other) const {
            return other.get() != get();
        }
 
    private:
        std::shared_ptr<Obj> m_ptr{};
    };
}  // namespace GeoModel
#endif