Dear All

I have trivial proposal: a function similar to the std::optional.value_or: it returns the first parameter not null, if it does not find it, then it returns a default value. It is very similar to a coalesce SQL function.

The input parameters can be raw pointers, std::unique_ptr, std::shared_ptr, std::weak_ptr or std::optional.

My idea is something like:

/**

     * Concept that define a pointer of type PointerType that points to

     * ValueType.

     * It covers: raw pointers, std::unique_ptr, std:shared_ptr,

     * std::weak_ptr, std::optional, std::null_ptr, NULL, 0 and any other

     * class that has the operators * and bool.

     */

    template<typename PointerType, typename ValueType>

    concept PointerTo = requires(PointerType pointer, ValueType)  // pointer must behave like a raw pointer that points to a ValueType

    {

        {*pointer} -> std::convertible_to<ValueType>;

        {!pointer} noexcept;

    }

    || requires(PointerType pointer, ValueType) // pointer must behave like a weak_ptr that points to a ValueType

    {

        {*pointer.lock()} noexcept -> std::convertible_to<ValueType>;

    }

    || std::same_as<std::nullptr_t, PointerType> // to cover the case of null_ptr

    || std::same_as<int, PointerType>;  // for NULL (in VS) and 0

    /**

    * It looks for a not null value in to_test_v. If it does not find it,

    * then value_or returns a default value.

    *

    * \param default_value Value to return if all the values of to_test_v are null

    * \param ...to_test_v The values to test for not null

    * \return The first value not null of to_test_v, if no value of to_test_v is not null then default_value

    */

    template<typename T, PointerTo<T>... Args>

    constexpr decltype(auto) value_or(T&& default_value, Args&&... to_test_v) noexcept;

There is the concept PointerTo that defines a class that behave like a raw pointer, and then there is the function value_or that tales a default value and then a list of “pointers” to check.

In PointerType I have included also the possibility the pointer is an int in order to support the values 0 and NULL, I am not sure that it is needed.

I have declared value_or noexcept, I think it makes sense but I do not think it is possible to guarantee it in a formal way.

I think a function like this may help to manage object that can be null in structured form.

Here you can find a possible implementation: https://github.com/roroberto/cpp_small_simple_stupid_stuff/blob/main/value_or/value_or.h

Best Regards

Roberto