propagate_const.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include <type_traits>
#include <utility>
#include <memory>
namespace Arp { namespace Base { namespace Core
{
 
template<class T>
class propagate_const
{
public:
    using element_type = typename std::pointer_traits<T>::element_type;
 
private:
    template <class U>
    struct is_propagate_const : std::false_type
    {
    };
 
    template <class U>
    struct is_propagate_const<propagate_const<U>> : std::true_type
    {
    };
 
public:
    constexpr propagate_const() = default;
    propagate_const(const propagate_const& other) = delete;
    constexpr propagate_const(propagate_const&& other) noexcept = default;
 
    template < class U, class = std::enable_if_t < std::is_constructible_v < T, U && >>>
               explicit constexpr propagate_const(propagate_const<U>&& other)
                   : t(std::move(other.t))
    {
    }
 
    template < class U, class = std::enable_if_t < std::is_constructible_v < T, U && > && !is_propagate_const<std::decay_t<U>>::value >>
    explicit constexpr propagate_const(U && other)
        : t(std::forward<U>(other))
    {
    }
 
    propagate_const& operator=(const propagate_const& other) = delete;
 
    propagate_const& operator=(propagate_const&& other) noexcept = default;
 
    template<class U, class = std::enable_if_t<std::is_convertible_v<U, T>>>
             propagate_const & operator=(propagate_const<U>&& other)
    {
        this->t = std::move<U>(other.t);
        return *this;
    }
 
    template < class U, class = std::enable_if_t < std::is_convertible_v<U, T>&& !is_propagate_const<std::decay_t<U>>::value >>
    propagate_const & operator=(U && other)
    {
        this->t = std::forward<U>(other);
        return *this;
    }
 
    void swap(propagate_const& other)noexcept
    {
        std::swap(this->t, other.t);
    }
 
    element_type* get()
    {
        return GetPointer(this->t);
    }
 
    const element_type* get()const
    {
        return GetPointer(this->t);
    }
 
    explicit operator bool()const
    {
        return this->get() != nullptr;
    }
 
    element_type& operator*()
    {
        return *this->get();
    }
 
    const element_type& operator*()const
    {
        return *this->get();
    }
 
    element_type* operator->()
    {
        return this->get();
    }
 
    const element_type* operator->()const
    {
        return this->get();
    }
 
    template <class T_ = T, class U = std::enable_if_t<std::is_convertible_v<const T_, const element_type*>>>
              operator element_type * ()
    {
        return this->get();
    }
 
    template <class T_ = T, class U = std::enable_if_t<std::is_convertible_v<const T_, const element_type*>>>
              operator const element_type * ()const
    {
        return this->get();
    }
 
    friend constexpr bool operator==(const propagate_const& lhs, std::nullptr_t)
    {
        return lhs.t == nullptr;
    }
 
    friend constexpr bool operator==(std::nullptr_t, const propagate_const& rhs)
    {
        return nullptr == rhs.t;
    }
 
    friend constexpr bool operator!=(const propagate_const& lhs, std::nullptr_t)
    {
        return lhs.t != nullptr;
    }
 
    friend constexpr bool operator!=(std::nullptr_t, const propagate_const& rhs)
    {
        return nullptr != rhs.t;
    }
 
    template<class U>
    friend constexpr bool operator==(const propagate_const& lhs, const propagate_const<U>& rhs)
    {
        return lhs.t == rhs.t;
    }
 
    template<class U>
    friend constexpr bool operator!=(const propagate_const& lhs, const propagate_const<U>& rhs)
    {
        return lhs.t != rhs.t;
    }
 
    template<class U>
    friend constexpr bool operator==(const propagate_const& lhs, const U& rhs)
    {
        return lhs.t == rhs;
    }
 
    template<class U>
    friend constexpr bool operator!=(const propagate_const& lhs, const U& rhs)
    {
        return lhs.t != rhs;
    }
 
    template<class U>
    friend constexpr bool operator==(const U& lhs, const propagate_const& rhs)
    {
        return lhs.t == rhs;
    }
 
    template<class U>
    friend constexpr bool operator!=(const U& lhs, const propagate_const& rhs)
    {
        return lhs.t != rhs;
    }
 
private: // methods
    template <class U>
    static constexpr element_type* GetPointer(U* u)
    {
        return u;
    }
 
    template <class U>
    static constexpr element_type* GetPointer(U& u)
    {
        return GetPointer(u.get());
    }
 
    template <class U>
    static constexpr const element_type* GetPointer(const U* u)
    {
        return u;
    }
 
    template <class U>
    static constexpr const element_type* GetPointer(const U& u)
    {
        return GetPointer(u.get());
    }
 
private: // fields
    T t{};
};
 
}}} // end of namespace Arp::Base::Core
 
namespace Arp {
using Arp::Base::Core::propagate_const;
}