Compiler Explorer

Source code

#include <string>
#include <span>
#include <deque>
#include <iostream>
#include <set>
#include <boost/core/span.hpp>
#include <boost/array.hpp>
#include <boost/container/vector.hpp>
#include <boost/type_index.hpp>
#include <array>
#include <list>
#include <fmt/std.h>
#include <fmt/ranges.h>
#include <vector>
#include <optional>

template<typename T>
concept has_size = 
    requires(T t) {
        {t.size()} -> std::same_as<typename T::size_type>;
    };
template <typename T>
concept has_push_back = 
    requires(T t, typename T::value_type v) {
        t.push_back(v);
    };

template <typename T>
concept has_push_front = 
    requires(T t, typename T::value_type v) {
        t.push_front(v);
    };

template <typename T>
concept has_insert = 
    requires(T t, typename T::value_type v) {
        t.insert(v);
    };

template <typename T>
concept constant_size_range = 
    has_size<T> &&  
    !has_push_front<T> && !has_insert<T> && !has_push_back<T>;

static_assert(!constant_size_range<int>);
static_assert(constant_size_range<std::span<int>>);
static_assert(constant_size_range<std::span<int,2>>);
static_assert(constant_size_range<std::array<int, 5>>);
static_assert(!constant_size_range<std::set<int>>);
static_assert(!constant_size_range<std::vector<int>>);
static_assert(!constant_size_range<std::list<int>>);

template<class Lambda, int=(Lambda{}(), 0)>
constexpr bool is_constexpr(Lambda) { return true; }
constexpr bool is_constexpr(...) { return false; }

template<typename OurElementType, typename R>
struct GuessExtentHelper {
    template<typename>
    struct ExtractArgInfo;
    template<template<typename, auto, typename...> typename V, std::integral auto Extent, typename... Tail>
    struct ExtractArgInfo<V<OurElementType, Extent,Tail...>> {
        static constexpr auto extent = Extent;
    };
    template<template<auto, typename, typename...> typename V, std::integral auto  Extent, typename... Tail>
    struct ExtractArgInfo<V<Extent,OurElementType, Tail...>> {
        static constexpr auto extent = Extent;
    };    
    static constexpr std::optional<size_t> get() {
        if constexpr(requires{ExtractArgInfo<std::remove_reference_t<R>>::extent;}) {
            if (ExtractArgInfo<std::remove_reference_t<R>>::extent < 0) {
                return std::nullopt;
            }
            return ExtractArgInfo<std::remove_reference_t<R>>::extent;

} else {
            return std::nullopt;
        }
    }
};

// Just a hacky way to avoid doing enum conversions to string, we want "enums" since
// just returning bool is not descriptive enough.
constexpr const char* kCouldNotGuessExtent = "can not guess extent of argument";
constexpr const char* kCouldNotGuessExtentBecauseZero = "can not guess extent of argument since 0 might signal resizable container";
constexpr const char* kElementArrayUnconstructible = "can not construct element array";
constexpr const char* kInputUnconstructibleFromPointers = "can not construct input from pointer pair";
constexpr const char* kSizeProbablyCompatible = "size probably compatible";
constexpr const char* kSizeProbablyNotCompatible = "size probably not compatible";
constexpr const char* kSizeNotConstexprFriendly = "size not constexpr friendly";

static constexpr size_t kOurExtent = 4;

template<typename T, size_t N = kOurExtent> 
struct MySpan {
    template<typename R>
    static constexpr const char* test (R&&) {
        using PureR = std::remove_cvref_t<R>;
        // We do not check constant_size_range concept here since for our examples we want them to go further to 
        // showcase other logic, in real code we would say that all containers with variable size are fine.

// easy case when we deal, with something like boost::array that is default
        // constructible in constexpr context and provides .size()        
        if constexpr(std::is_constructible_v<PureR> && has_size<PureR>) {
            constexpr auto get_default_constructed_size = []{
                PureR r{};
                return r.size();
            };
            if constexpr(is_constexpr(get_default_constructed_size)) {
                static constexpr bool default_constructed_size_is_useless  = get_default_constructed_size() == 0;
                // Important this is first in case our extent is 0
                if (default_constructed_size_is_useless) {
                    return kCouldNotGuessExtentBecauseZero;
                }
                static constexpr bool extents_match  = get_default_constructed_size() == N;                
                return extents_match ? kSizeProbablyCompatible : kSizeProbablyNotCompatible;
            }
        }        
        static constexpr auto maybe_other_extent = GuessExtentHelper<T,PureR>::get();
        if constexpr(!maybe_other_extent.has_value()) {
                return kCouldNotGuessExtent;
        }
        // to make compiler happy we can not just deref
        static constexpr size_t other_extent = maybe_other_extent.value_or(0);
        static constexpr size_t our_extent = N;
        if constexpr(is_constexpr([] {
            // we could live with any of two lines, but we mimic what we do later
            [[maybe_unused]] T arr[other_extent]{};
            [[maybe_unused]] T arr2[our_extent]{};
        })) {
            // TODO: maybe add checks for other common flavors or this constructor, e.g. (T*, size_t)
            if constexpr(std::is_constructible_v<PureR, T*, T*>) {
                constexpr auto construct_other_from_other_extent = [] {
                    T arr[other_extent]{};
                    [[maybe_unused]] PureR r{&arr[0], &arr[0]+other_extent};
                    };
                constexpr auto construct_other_from_our_extent = [] {
                    T arr[our_extent]{};
                    [[maybe_unused]] PureR r{&arr[0], &arr[0]+our_extent};
                    };                    
                
                static constexpr bool other_constructible_from_other_extent = is_constexpr(construct_other_from_other_extent);
                static constexpr bool other_constructible_from_our_extent = is_constexpr(construct_other_from_our_extent);
                if constexpr(other_constructible_from_other_extent && !other_constructible_from_our_extent) {
                    return kSizeProbablyNotCompatible;
                } else if constexpr (other_constructible_from_other_extent && other_constructible_from_our_extent)  {
                    return kSizeProbablyCompatible;
                } else {
                    // other can not be constructed in constexpr context so we
                    // can not learn anything
                    return kSizeNotConstexprFriendly;
                }
            } {
              return kInputUnconstructibleFromPointers;
            }
        }
        else {
           return kElementArrayUnconstructible;  
        }
    }
};

template<int64_t N, typename T> 
struct MyArray{
    using size_type = size_t;
    constexpr size_type size() {
        return N;
    }
};

template<int64_t N, typename T> 
struct MyArrayWithPtrsCtor{
    using size_type = size_t;
    constexpr size_type size() {
        return N;
    }
    constexpr MyArrayWithPtrsCtor() = delete;
    constexpr MyArrayWithPtrsCtor(T* b, T* e) {
        if (std::distance(b,e)!=N) {
            throw std::length_error("ups"); 
        }
    }
};

// silly example where N lies
template<int64_t N, typename T> 
struct MyArrayWithPtrsCtorWrongCheck{
    using size_type = size_t;
    constexpr size_type size() {
        return N;
    }
    constexpr MyArrayWithPtrsCtorWrongCheck() = delete;
    constexpr MyArrayWithPtrsCtorWrongCheck(T* b, T* e) {
        if (std::distance(b,e)!=1) {
            throw std::length_error("ups"); 
        }
    }
};

struct Vec3 
{
};

template<typename T>
auto type_str(const T&) {
    return boost::typeindex::type_id<T>().pretty_name();
}

int main() {
    std::vector<int> vec {1,2,3};
    std::span<int> sp_dyn{vec};
    std::span<int, 0> sp0{vec};
    std::span<int, 2> sp2{vec};
    std::span<int, 4> sp4{vec};
    std::span<int, 6> sp6{vec};
    boost::container::vector<int> bvec{1,2,3};
    boost::array<int, 2> barr2{1,2};
    boost::array<int, 4> barr4{1,2,3,4};
    std::array<int, 2> arr2{1,2};
    std::array<int, 4> arr4{1,2,3,4};

fmt::println("\nOur extent {}", kOurExtent);
    auto check = [](const auto& range) {
        fmt::println("{}:  {}",type_str(range), MySpan<int>::test(range));        
    };
    check(sp0);
    check(sp2);
    check(sp4);
    check(sp6);
    check(bvec);
    check(MyArray<0,int>{});
    check(MyArray<1,int>{});
    check(MyArray<4,int>{});
    {
        MyArrayWithPtrsCtor<1,int> my_arr1{sp4.data(), sp4.data()+1};
        MyArrayWithPtrsCtor<2,int> my_arr2{sp4.data(), sp4.data()+2};
        MyArrayWithPtrsCtor<4,int> my_arr4{sp4.data(), sp4.data()+4};
        check(my_arr1);   
        check(my_arr2);   
        check(my_arr4);
        MyArrayWithPtrsCtorWrongCheck<42, int>my_lying_arr{sp4.data(), sp4.data()+1};
        check(my_lying_arr);
    }
    check(Vec3{});
    check(barr2);
    check(barr4);
    check(arr2);
    check(arr4);
    fmt::println("\nOur extent {}", 0);
    fmt::println("{}:  {}",type_str(sp0), MySpan<int, 0>::test(sp0));
    fmt::println("\nOur extent {}", 2);
    fmt::println("{}:  {}",type_str(sp2), MySpan<int, 2>::test(sp2));
    fmt::println("\nOur extent {}", kOurExtent);
    fmt::println("{}:  {}",type_str(std::vector<std::thread>{}), MySpan<std::thread>::test(std::vector<std::thread>{}));
    fmt::println("{}:  {}",type_str(std::array<std::thread,2>{}), MySpan<std::thread>::test(std::array<std::thread,2>{}));

// force constexpr use
    [[maybe_unused]]constexpr auto a = MySpan<int, 2>::test(sp2);
    // TODO: this shows we only check size, not type
    [[maybe_unused]]constexpr auto b = MySpan<int, 2>::test(std::array<float, 2>{});
}