Subversion Repositories Games.Descent

/*

 * This file is part of the DXX-Rebirth project <https://www.dxx-rebirth.com/>.

 * It is copyright by its individual contributors, as recorded in the

 * project's Git history.  See COPYING.txt at the top level for license

 * terms and a link to the Git history.

 */

#pragma once

#include <stdexcept>

#include <string>

#include <type_traits>

#include "fwd-valptridx.h"

#include "pack.h"

#include "compiler-poison.h"

#include "selfiter.h"

#include <array>

#ifdef DXX_CONSTANT_TRUE

#define DXX_VALPTRIDX_STATIC_CHECK(SUCCESS_CONDITION,FAILURE_FUNCTION,FAILURE_STRING)   \

                static_cast<void>(DXX_CONSTANT_TRUE(!SUCCESS_CONDITION) &&      \

                        (DXX_ALWAYS_ERROR_FUNCTION(FAILURE_FUNCTION, FAILURE_STRING), 0)        \

                )       \

#ifdef DXX_HAVE_ATTRIBUTE_WARNING

/* This causes many warnings because some conversions are not checked for

 * safety.  Eliminating the warnings by changing the call sites to check first

 * would be a useful improvement.

 */

//#define DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT __attribute__((__warning__("call not eliminated")))

#endif

#else

#define DXX_VALPTRIDX_STATIC_CHECK(E,F,S)

#endif

#define DXX_VALPTRIDX_CHECK(SUCCESS_CONDITION,ERROR,FAILURE_STRING,...) \

        ( DXX_BEGIN_COMPOUND_STATEMENT {        \

                const bool dxx_valptridx_check_success_condition = (SUCCESS_CONDITION); \

                DXX_VALPTRIDX_STATIC_CHECK(dxx_valptridx_check_success_condition, dxx_trap_##ERROR, FAILURE_STRING);    \

                static_cast<void>(      \

                        dxx_valptridx_check_success_condition || (ERROR::report(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VA(__VA_ARGS__)), 0)  \

                );      \

        } DXX_END_COMPOUND_STATEMENT )

#ifndef DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

#define DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

#endif

template <typename managed_type>

class valptridx<managed_type>::array_base_count_type

{

protected:

        union {

                unsigned count;

                /*

                 * Use DXX_VALPTRIDX_FOR_EACH_PPI_TYPE to generate empty union

                 * members based on basic_{i,v}val_member_factory

                 * specializations.

                 */

#define DXX_VALPTRIDX_DEFINE_MEMBER_FACTORIES(MANAGED_TYPE, DERIVED_TYPE_PREFIX, CONTEXT, PISUFFIX, IVPREFIX, MCPREFIX) \

                valptridx<MANAGED_TYPE>::f ## IVPREFIX ## MCPREFIX ## PISUFFIX  \

                        IVPREFIX ## MCPREFIX ## PISUFFIX

                DXX_VALPTRIDX_FOR_EACH_PPI_TYPE(DXX_VALPTRIDX_DEFINE_MEMBER_FACTORIES, managed_type,,);

#undef DXX_VALPTRIDX_DEFINE_MEMBER_FACTORIES

        };

        constexpr array_base_count_type() :

                count(0)

        {

        }

public:

        unsigned get_count() const

        {

                return count;

        }

        void set_count(const unsigned c)

        {

                count = c;

        }

};

template <

        typename INTEGRAL_TYPE,

        std::size_t array_size_value,

        valptridx_detail::untyped_utilities::report_error_style report_const_error_value,

        valptridx_detail::untyped_utilities::report_error_style report_mutable_error_value

        >

constexpr std::integral_constant<std::size_t, array_size_value> valptridx_detail::specialized_type_parameters<INTEGRAL_TYPE, array_size_value, report_const_error_value, report_mutable_error_value>::array_size;

class valptridx_detail::untyped_utilities::report_error_undefined

{

public:

        __attribute_cold

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(...)

        {

        }

};

class valptridx_detail::untyped_utilities::report_error_trap_terse

{

public:

        __attribute_cold

        __attribute_noreturn

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(...)

        {

                __builtin_trap();

        }

};

class valptridx_detail::untyped_utilities::index_mismatch_trap_verbose

{

public:

        __attribute_cold

        __attribute_noreturn

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const void *const array, const unsigned long supplied_index, const void *const expected_pointer, const void *const actual_pointer)

        {

                __asm__ __volatile__("" :: DXX_VALPTRIDX_REPORT_STANDARD_ASM_LOAD_COMMA_R_VARS "rm" (array), "rm" (supplied_index), "rm" (expected_pointer), "rm" (actual_pointer));

                __builtin_trap();

        }

};

class valptridx_detail::untyped_utilities::index_range_trap_verbose

{

public:

        __attribute_cold

        __attribute_noreturn

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const void *const array, const unsigned long supplied_index)

        {

                __asm__ __volatile__("" :: DXX_VALPTRIDX_REPORT_STANDARD_ASM_LOAD_COMMA_R_VARS "rm" (array), "rm" (supplied_index));

                __builtin_trap();

        }

};

class valptridx_detail::untyped_utilities::null_pointer_trap_verbose

{

public:

        __attribute_cold

        __attribute_noreturn

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_N_DEFN_VARS)

        {

                __asm__ __volatile__("" :: DXX_VALPTRIDX_REPORT_STANDARD_ASM_LOAD_COMMA_N_VARS);

                __builtin_trap();

        }

        __attribute_cold

        __attribute_noreturn

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const void *const array)

        {

                __asm__ __volatile__("" :: DXX_VALPTRIDX_REPORT_STANDARD_ASM_LOAD_COMMA_R_VARS "rm" (array));

                __builtin_trap();

        }

};

template <typename P>

class valptridx<P>::index_mismatch_exception :

        public std::logic_error

{

        DXX_INHERIT_CONSTRUCTORS(index_mismatch_exception, logic_error);

public:

        __attribute_cold

        __attribute_noreturn

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const array_managed_type *, index_type, const_pointer_type, const_pointer_type);

};

template <typename P>

class valptridx<P>::index_range_exception :

        public std::out_of_range

{

        DXX_INHERIT_CONSTRUCTORS(index_range_exception, out_of_range);

public:

        __attribute_cold

        __attribute_noreturn

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const array_managed_type *, long);

};

template <typename P>

class valptridx<P>::null_pointer_exception :

        public std::logic_error

{

        DXX_INHERIT_CONSTRUCTORS(null_pointer_exception, logic_error);

public:

        __attribute_cold

        __attribute_noreturn

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_N_DEFN_VARS);

        __attribute_cold

        __attribute_noreturn

        DXX_VALPTRIDX_WARN_CALL_NOT_OPTIMIZED_OUT

        static void report(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const array_managed_type *);

};

template <typename managed_type>

template <typename handle_index_mismatch>

void valptridx<managed_type>::check_index_match(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const_reference_type r, index_type i, const array_managed_type &a __attribute_unused)

{

        const auto pi = &a[i];

        DXX_VALPTRIDX_CHECK(pi == &r, handle_index_mismatch, "pointer/index mismatch", &a, i, pi, &r);

}

template <typename managed_type>

template <typename handle_index_range_error, template <typename> class Compare>

typename valptridx<managed_type>::index_type valptridx<managed_type>::check_index_range(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const index_type i, const array_managed_type *const a)

{

        const std::size_t ss = i;

        DXX_VALPTRIDX_CHECK(Compare<std::size_t>()(ss, array_size), handle_index_range_error, "invalid index used in array subscript", a, ss);

        return i;

}

template <typename managed_type>

template <typename handle_null_pointer>

void valptridx<managed_type>::check_null_pointer_conversion(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const_pointer_type p)

{

        DXX_VALPTRIDX_CHECK(p, handle_null_pointer, "NULL pointer converted");

}

template <typename managed_type>

template <typename handle_null_pointer>

void valptridx<managed_type>::check_null_pointer(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const_pointer_type p, const array_managed_type &a __attribute_unused)

{

        DXX_VALPTRIDX_CHECK(p, handle_null_pointer, "NULL pointer used", &a);

}

template <typename managed_type>

template <typename handle_index_mismatch, typename handle_index_range_error>

void valptridx<managed_type>::check_implicit_index_range_ref(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const managed_type &r, const array_managed_type &a)

{

        check_explicit_index_range_ref<handle_index_mismatch, handle_index_range_error>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS r, static_cast<const_pointer_type>(&r) - static_cast<const_pointer_type>(&a.front()), a);

}

template <typename managed_type>

template <typename handle_index_mismatch, typename handle_index_range_error>

void valptridx<managed_type>::check_explicit_index_range_ref(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS const_reference_type &r, std::size_t i, const array_managed_type &a)

{

        check_index_match<handle_index_mismatch>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS r, i, a);

        check_index_range<handle_index_range_error>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, &a);

}

template <typename managed_type>

class valptridx<managed_type>::partial_policy::require_valid

{

public:

        static constexpr std::false_type allow_nullptr{};

        static constexpr std::false_type check_allowed_invalid_index(index_type) { return {}; }

        static constexpr bool check_nothrow_index(index_type i)

        {

                return std::less<std::size_t>()(i, array_size);

        }

};

template <typename managed_type>

class valptridx<managed_type>::partial_policy::allow_invalid

{

public:

        static constexpr std::true_type allow_nullptr{};

        static constexpr bool check_allowed_invalid_index(index_type i)

        {

                return i == static_cast<index_type>(~0);

        }

        static constexpr bool check_nothrow_index(index_type i)

        {

                return check_allowed_invalid_index(i) || require_valid::check_nothrow_index(i);

        }

};

template <typename managed_type>

constexpr std::false_type valptridx<managed_type>::partial_policy::require_valid::allow_nullptr;

template <typename managed_type>

constexpr std::true_type valptridx<managed_type>::partial_policy::allow_invalid::allow_nullptr;

template <typename managed_type>

template <template <typename> class policy>

class valptridx<managed_type>::partial_policy::apply_cv_policy

{

        template <typename T>

                using apply_cv_qualifier = typename policy<T>::type;

public:

        using array_managed_type = apply_cv_qualifier<valptridx<managed_type>::array_managed_type>;

        using pointer_type = apply_cv_qualifier<managed_type> *;

        using reference_type = apply_cv_qualifier<managed_type> &;

};

template <typename managed_type>

class valptridx<managed_type>::vc :

        public partial_policy::require_valid,

        public partial_policy::template apply_cv_policy<std::add_const>

{

};

template <typename managed_type>

class valptridx<managed_type>::vm :

        public partial_policy::require_valid,

        public partial_policy::template apply_cv_policy<std::remove_const>

{

};

template <typename managed_type>

class valptridx<managed_type>::ic :

        public partial_policy::allow_invalid,

        public partial_policy::template apply_cv_policy<std::add_const>

{

};

template <typename managed_type>

class valptridx<managed_type>::im :

        public partial_policy::allow_invalid,

        public partial_policy::template apply_cv_policy<std::remove_const>

{

};

template <typename managed_type>

template <typename policy>

class valptridx<managed_type>::idx :

        public policy

{

        using containing_type = valptridx<managed_type>;

public:

        using policy::allow_nullptr;

        using policy::check_allowed_invalid_index;

        using index_type = typename containing_type::index_type;

        using integral_type = typename containing_type::integral_type;

        using typename policy::array_managed_type;

        idx() = delete;

        idx(const idx &) = default;

        idx(idx &&) = default;

        idx &operator=(const idx &) & = default;

        idx &operator=(idx &&) & = default;

        idx &operator=(const idx &) && = delete;

        idx &operator=(idx &&) && = delete;

        index_type get_unchecked_index() const { return m_idx; }

        /* If moving from allow_invalid to allow_invalid, no check is

         * needed.

         * If moving from require_valid to anything, no check is needed.

         */

        template <typename rpolicy, typename std::enable_if<policy::allow_nullptr || !rpolicy::allow_nullptr, int>::type = 0>

                idx(const idx<rpolicy> &rhs) :

                        m_idx(rhs.get_unchecked_index())

        {

        }

        template <typename rpolicy, typename std::enable_if<!(policy::allow_nullptr || !rpolicy::allow_nullptr), int>::type = 0>

                idx(const idx<rpolicy> &rhs DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS) :

                        m_idx(rhs.get_unchecked_index())

        {

                /* If moving from allow_invalid to require_valid, check range.

                 */

                check_index_range<index_range_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS m_idx, nullptr);

        }

        template <typename rpolicy>

                idx(idx<rpolicy> &&rhs) :

                        m_idx(rhs.get_unchecked_index())

        {

                /* Prevent move from allow_invalid into require_valid.  The

                 * right hand side must be saved and checked for validity before

                 * being used to initialize a require_valid type.

                 */

                static_assert(policy::allow_nullptr || !rpolicy::allow_nullptr, "cannot move from allow_invalid to require_valid");

        }

        idx(index_type i DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS) :

                m_idx(check_allowed_invalid_index(i) ? i : check_index_range<index_range_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, nullptr))

        {

        }

        idx(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS index_type i, array_managed_type &a) :

                m_idx(check_allowed_invalid_index(i) ? i : check_index_range<index_range_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, &a))

        {

        }

protected:

        template <integral_type v>

                idx(const magic_constant<v> &, const allow_none_construction *) :

                        m_idx(v)

        {

                static_assert(!allow_nullptr, "allow_none_construction used where nullptr was already legal");

                static_assert(static_cast<std::size_t>(v) >= array_size, "allow_none_construction used with valid index");

        }

        idx(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS index_type i, array_managed_type &a, const allow_end_construction *) :

                m_idx(check_index_range<index_range_error_type<array_managed_type>, std::less_equal>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, &a))

        {

        }

        idx(index_type i, array_managed_type &, const assume_nothrow_index *) :

                m_idx(i)

        {

        }

public:

        template <integral_type v>

                constexpr idx(const magic_constant<v> &) :

                        m_idx(v)

        {

                static_assert(allow_nullptr || static_cast<std::size_t>(v) < array_size, "invalid magic index not allowed for this policy");

        }

        template <typename rpolicy>

                bool operator==(const idx<rpolicy> &rhs) const

                {

                        return m_idx == rhs.get_unchecked_index();

                }

        bool operator==(const index_type &i) const

        {

                return m_idx == i;

        }

        template <integral_type v>

                bool operator==(const magic_constant<v> &) const

                {

                        static_assert(allow_nullptr || static_cast<std::size_t>(v) < array_size, "invalid magic index not allowed for this policy");

                        return m_idx == v;

                }

        template <typename R>

                bool operator!=(const R &rhs) const

                {

                        return !(*this == rhs);

                }

        operator index_type() const

        {

                return m_idx;

        }

protected:

        index_type m_idx;

        idx &operator++()

        {

                ++ m_idx;

                return *this;

        }

};

template <typename managed_type>

template <typename policy>

class valptridx<managed_type>::ptr :

        public policy

{

        using containing_type = valptridx<managed_type>;

public:

        using policy::allow_nullptr;

        using policy::check_allowed_invalid_index;

        using index_type = typename containing_type::index_type;

        using const_pointer_type = typename containing_type::const_pointer_type;

        using mutable_pointer_type = typename containing_type::mutable_pointer_type;

        using allow_none_construction = typename containing_type::allow_none_construction;

        using typename policy::array_managed_type;

        using typename policy::pointer_type;

        using typename policy::reference_type;

        ptr() = delete;

        /* Override template matches to make same-type copy/move trivial */

        ptr(const ptr &) = default;

        ptr(ptr &&) = default;

        ptr &operator=(const ptr &) & = default;

        ptr &operator=(ptr &&) & = default;

        ptr &operator=(const ptr &) && = delete;

        ptr &operator=(ptr &&) && = delete;

        pointer_type get_unchecked_pointer() const { return m_ptr; }

        pointer_type get_nonnull_pointer(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_N_DECL_VARS) const

        {

                /* If !allow_nullptr, assume nullptr was caught at construction.  */

                if (allow_nullptr)

                        check_null_pointer_conversion<null_pointer_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS m_ptr);

                return m_ptr;

        }

        reference_type get_checked_reference(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_N_DECL_VARS) const

        {

                return *get_nonnull_pointer(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VA());

        }

        ptr(std::nullptr_t) :

                m_ptr(nullptr)

        {

                static_assert(allow_nullptr, "nullptr construction not allowed for this policy");

        }

        template <integral_type v>

                ptr(const magic_constant<v> &) :

                        m_ptr(nullptr)

        {

                static_assert(static_cast<std::size_t>(v) >= array_size, "valid magic index requires an array");

                static_assert(allow_nullptr || static_cast<std::size_t>(v) < array_size, "invalid magic index not allowed for this policy");

        }

        template <integral_type v>

                ptr(const magic_constant<v> &, array_managed_type &a) :

                        m_ptr(&a[v])

        {

                static_assert(static_cast<std::size_t>(v) < array_size, "valid magic index required when using array");

        }

        template <typename rpolicy, typename std::enable_if<policy::allow_nullptr || !rpolicy::allow_nullptr, int>::type = 0>

                ptr(const ptr<rpolicy> &rhs) :

                        m_ptr(rhs.get_unchecked_pointer())

        {

        }

        template <typename rpolicy, typename std::enable_if<!(policy::allow_nullptr || !rpolicy::allow_nullptr), int>::type = 0>

                ptr(const ptr<rpolicy> &rhs DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS) :

                        m_ptr(rhs.get_unchecked_pointer())

        {

                check_null_pointer_conversion<null_pointer_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS m_ptr);

        }

        template <typename rpolicy>

                ptr(ptr<rpolicy> &&rhs) :

                        m_ptr(rhs.get_unchecked_pointer())

        {

                /* Prevent move from allow_invalid into require_valid.  The

                 * right hand side must be saved and checked for validity before

                 * being used to initialize a require_valid type.

                 */

                static_assert(policy::allow_nullptr || !rpolicy::allow_nullptr, "cannot move from allow_invalid to require_valid");

        }

        ptr(index_type i) = delete;

        ptr(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS index_type i, array_managed_type &a) :

                m_ptr(check_allowed_invalid_index(i) ? nullptr : &a[check_index_range<index_range_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, &a)])

        {

        }

        ptr(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS index_type i, array_managed_type &a, const allow_end_construction *) :

                m_ptr(&a[check_index_range<index_range_error_type<array_managed_type>, std::less_equal>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, &a)])

        {

        }

        ptr(index_type i, array_managed_type &a, const assume_nothrow_index *) :

                m_ptr(&a[i])

        {

        }

        ptr(pointer_type p) = delete;

        ptr(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS pointer_type p, array_managed_type &a) :

                /* No array consistency check here, since some code incorrectly

                 * defines instances of `object` outside the Objects array, then

                 * passes pointers to those instances to this function.

                 */

                m_ptr(p)

        {

                if (!allow_nullptr)

                        check_null_pointer<null_pointer_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS p, a);

        }

        ptr(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS reference_type r, array_managed_type &a) :

                m_ptr((check_implicit_index_range_ref<index_mismatch_error_type<array_managed_type>, index_range_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS r, a), &r))

        {

        }

        ptr(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS reference_type r, index_type i, array_managed_type &a) :

                m_ptr((check_explicit_index_range_ref<index_mismatch_error_type<array_managed_type>, index_range_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS r, i, a), &r))

        {

        }

        operator mutable_pointer_type() const { return m_ptr; } // implicit pointer conversion deprecated

        operator const_pointer_type() const { return m_ptr; }   // implicit pointer conversion deprecated

        template <typename rpolicy>

                typename std::enable_if<!std::is_same<policy, rpolicy>::value, ptr>::type rebind_policy(ptr<rpolicy> &&rhs) const

        {

                /* This method could be marked as `static`, but is non-static so

                 * that callers must possess an instance of the target type.

                 * This serves as a basic check against casts that could remove

                 * `const` incorrectly.

                 */

                return ptr(std::move(rhs), static_cast<const typename containing_type::rebind_policy *>(nullptr));

        }

        pointer_type operator->() const &

        {

                return get_nonnull_pointer();

        }

        operator reference_type() const &

        {

                return get_checked_reference();

        }

        reference_type operator*() const &

        {

                return get_checked_reference();

        }

        explicit operator bool() const &

        {

                return !(*this == nullptr);

        }

        pointer_type operator->() const &&

        {

                static_assert(!allow_nullptr, "operator-> not allowed with allow_invalid policy");

                return operator->();

        }

        operator reference_type() const &&

        {

                static_assert(!allow_nullptr, "implicit reference not allowed with allow_invalid policy");

                return *this;

        }

        reference_type operator*() const &&

        {

                static_assert(!allow_nullptr, "operator* not allowed with allow_invalid policy");

                return *this;

        }

        explicit operator bool() const && = delete;

        bool operator==(std::nullptr_t) const

        {

                static_assert(allow_nullptr, "nullptr comparison not allowed: value is never null");

                return m_ptr == nullptr;

        }

        bool operator==(const_pointer_type p) const

        {

                return m_ptr == p;

        }

        bool operator==(mutable_pointer_type p) const

        {

                return m_ptr == p;

        }

        template <typename rpolicy>

                bool operator==(const ptr<rpolicy> &rhs) const

                {

                        return *this == rhs.get_unchecked_pointer();

                }

        template <typename R>

                bool operator!=(const R &rhs) const

                {

                        return !(*this == rhs);

                }

        template <typename U>

                long operator-(U) const = delete;

        template <typename R>

                bool operator<(R) const = delete;

        template <typename R>

                bool operator>(R) const = delete;

        template <typename R>

                bool operator<=(R) const = delete;

        template <typename R>

                bool operator>=(R) const = delete;

protected:

        pointer_type m_ptr;

        ptr &operator++()

        {

                ++ m_ptr;

                return *this;

        }

        ptr(const allow_none_construction *) :

                m_ptr(nullptr)

        {

                static_assert(!allow_nullptr, "allow_none_construction used where nullptr was already legal");

        }

        template <typename rpolicy>

                ptr(ptr<rpolicy> &&rhs, const typename containing_type::rebind_policy *) :

                        m_ptr(const_cast<managed_type *>(rhs.get_unchecked_pointer()))

        {

                static_assert(allow_nullptr || !rpolicy::allow_nullptr, "cannot rebind from allow_invalid to require_valid");

        }

};

#if DXX_VALPTRIDX_ENFORCE_STRICT_PI_SEPARATION

template <typename T>

struct strong_typedef : T

{

        using T::T;

        template <typename O, typename std::enable_if<std::is_constructible<T, O &&>::value, int>::type = 0>

                strong_typedef(O &&o) :

                        T(std::forward<O>(o))

        {

        }

        strong_typedef() = default;

        strong_typedef(const strong_typedef &) = default;

        strong_typedef(strong_typedef &&) = default;

        strong_typedef &operator=(const strong_typedef &) & = default;

        strong_typedef &operator=(strong_typedef &&) & = default;

        strong_typedef &operator=(const strong_typedef &) && = delete;

        strong_typedef &operator=(strong_typedef &&) && = delete;

};

#endif

template <typename managed_type>

template <typename policy>

class valptridx<managed_type>::ptridx :

        public prohibit_void_ptr<ptridx<policy>>,

        public ptr<policy>,

        public idx<policy>

{

        using containing_type = valptridx<managed_type>;

public:

        using vptr_type = ptr<policy>;

        using vidx_type = idx<policy>;

        using typename vidx_type::array_managed_type;

        using index_type = typename vidx_type::index_type;

        using typename vidx_type::integral_type;

        using typename vptr_type::pointer_type;

        using vidx_type::operator==;

        using vptr_type::operator==;

        ptridx(const ptridx &) = default;

        ptridx(ptridx &&) = default;

        ptridx &operator=(const ptridx &) & = default;

        ptridx &operator=(ptridx &&) & = default;

        ptridx &operator=(const ptridx &) && = delete;

        ptridx &operator=(ptridx &&) && = delete;

        ptridx(std::nullptr_t) = delete;

        /* Prevent implicit conversion.  Require use of the factory function.

         */

        ptridx(pointer_type p) = delete;

        template <typename rpolicy, typename std::enable_if<policy::allow_nullptr || !rpolicy::allow_nullptr, int>::type = 0>

                ptridx(const ptridx<rpolicy> &rhs) :

                        vptr_type(static_cast<const typename ptridx<rpolicy>::vptr_type &>(rhs)),

                        vidx_type(static_cast<const typename ptridx<rpolicy>::vidx_type &>(rhs))

        {

        }

        template <typename rpolicy, typename std::enable_if<!(policy::allow_nullptr || !rpolicy::allow_nullptr), int>::type = 0>

                ptridx(const ptridx<rpolicy> &rhs DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS) :

                        vptr_type(static_cast<const typename ptridx<rpolicy>::vptr_type &>(rhs) DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_PASS_VARS),

                        vidx_type(static_cast<const typename ptridx<rpolicy>::vidx_type &>(rhs) DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_PASS_VARS)

        {

        }

        template <typename rpolicy>

                ptridx(ptridx<rpolicy> &&rhs) :

                        vptr_type(static_cast<typename ptridx<rpolicy>::vptr_type &&>(rhs)),

                        vidx_type(static_cast<typename ptridx<rpolicy>::vidx_type &&>(rhs))

        {

        }

        template <integral_type v>

                ptridx(const magic_constant<v> &m) :

                        vptr_type(m),

                        vidx_type(m)

        {

        }

        template <integral_type v>

                ptridx(const magic_constant<v> &m, array_managed_type &a) :

                        vptr_type(m, a),

                        vidx_type(m)

        {

        }

        template <integral_type v>

                ptridx(const magic_constant<v> &m, const allow_none_construction *const n) :

                        vptr_type(n),

                        vidx_type(m, n)

        {

        }

        ptridx(index_type i) = delete;

        ptridx(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS index_type i, array_managed_type &a) :

                vptr_type(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, a),

                vidx_type(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, a)

        {

        }

        ptridx(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS index_type i, array_managed_type &a, const allow_end_construction *e) :

                vptr_type(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, a, e),

                vidx_type(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, a, e)

        {

        }

        ptridx(index_type i, array_managed_type &a, const assume_nothrow_index *e) :

                vptr_type(i, a, e),

                vidx_type(i, a, e)

        {

        }

        ptridx(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS pointer_type p, array_managed_type &a) :

                /* Null pointer is never allowed when an index must be computed.

                 * Check for null, then use the reference constructor for

                 * vptr_type to avoid checking again.

                 */

                vptr_type(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS (check_null_pointer<null_pointer_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS p, a), *p), a),