Compiler Explorer

Source code

#include <iostream>
#include <utility>

template<int N, class T>
struct state_t {
    static constexpr int n = N;
    using type = T;
};

template<
    int N,
    auto tag
>
struct reader {
    friend auto inject_state_func(reader<N, tag>);
};

template<
    int N,
    class T,
    auto tag
>
struct setter {
    friend auto inject_state_func(reader<N, tag>) {
        return T{};
    }

static constexpr state_t<N, T> state{};
};

template<
    auto tag, 
    auto eval, 
    int N = 0
>
consteval auto get_last_state() {
    constexpr bool counted_past_n = requires(reader<N, tag> r) {
        inject_state_func(r);
    };

if constexpr (counted_past_n) {
        return get_last_state<tag, eval, N + 1>();
    }
    else {
        constexpr reader<N - 1, tag> r;
        return state_t<N - 1, decltype(inject_state_func(r))>{};
    }
}

template<
    auto tag,
    auto eval = [] {},
    auto State = get_last_state<tag, eval>()
>
using get_state = typename std::remove_cvref_t<decltype(State)>;

template<
    typename T,
    auto tag,
    auto eval
>
consteval auto set_state_impl() {
    using cur_state = decltype(get_last_state<tag, eval>());
    setter<cur_state::n + 1, T, tag> s;
    return s.state;
}

template<
    class T,
    auto tag,
    auto eval = [] {},
    auto state = set_state_impl<T, tag, eval>()
>
constexpr auto set_state = [] { return state; };

struct none {};

template<class Init = none, auto tag = [] {} >
class meta_state {
public:
    template<
        typename T,
        auto eval = [] {} 
    >
    using set = decltype(set_state<T, tag, eval>());

template<auto eval = [] {}>
    using get = typename get_state<tag, eval>::type;

template<auto eval = [] {}>
    constexpr auto type() const -> meta_state::get<eval>;
private:
    static constexpr setter<0, Init, tag> init = {};
};

template<class... Ts>
struct type_list {
    template<class T>
    using push = type_list<Ts..., T>;

template<class T>
    using push_front = type_list<T, Ts...>;
};

template<class T>
struct type_wrapper {
    constexpr T get() const;
};

template<auto V>
struct value_wrapper {
    constexpr auto get() const { return V; }

template<class F>
    constexpr auto modify(F) const { return value_wrapper<F{}(V)>(); }
};

template<class F, class... Ts>
inline constexpr void for_each(F&& func, Ts&&... args){
    (func(args), ...);
}

template<class F, class... Ts>
inline constexpr void for_each_type(F func, type_list<Ts...>) {
    for_each(func, type_wrapper<Ts>{}...);
}

template<class T>
struct scope_guard {
private:
    T func;

public:
    scope_guard(T&& func) : func(std::forward<T>(func)) {}
    ~scope_guard() {
        func();
    }
};

constexpr auto reverse(type_list<>) {
    return type_list<>{};
}

template<class T, class... Ts> 
constexpr auto reverse(type_list<T, Ts...>) {
    using reversed = decltype(reverse(type_list<Ts...>{}))::template push<T>;
    return reversed{};
}

template<auto teval = [] {} >
struct defer {
	using state = meta_state<type_list<>, teval>;

template<		
        auto eval = [] {},
        class F,
        class v = typename state::template set<typename state::template get<eval>::template push_front<F>, eval> 
    >
	constexpr auto push(F arg) const {
		return 0;
	}

template<
        auto tteval = [] {}>
	constexpr auto apply() const {
		using List = typename state::template get<tteval>;
		constexpr auto value = [] {
            #ifdef __clang__
                auto list = reverse(List{});
            #else
                auto list = List{};
            #endif

for_each_type([]<class T>(type_wrapper<T>) {
				constexpr auto eval = [] {};
                T{}.template apply<std::pair(eval, teval)>();
			}, list);
			return 0;
		}();

return value;
	}
};

template<class state, class V>
struct defer_set {
	template<
		auto eval = [] {},
		class v = state::template set<V, eval> 
	>
	constexpr auto apply() {
		return v{};
	}
};

template<class state, class T>
struct defer_assert {
	template<
		auto eval = [] {} >
	constexpr auto apply() {
		static_assert(std::is_same_v<typename state::template get<eval>, T>, "");
	}
};

template<class state, class F, auto teval = []{}>
struct defer_modify {
	template<
		auto eval = [] {},
        class prev_state = decltype(state{}.template type<eval>()),
        class next_state = decltype(std::declval<F>()(std::declval<prev_state>())),
		class v = state::template set<next_state, eval>
	>
	constexpr auto apply() const {}

constexpr defer_modify() = default;

constexpr defer_modify(state, F, value_wrapper<teval> arg = {}) {}
};

#define DEFER_PUSH(defer, ...) typename defer::state::template set<\
            typename defer::state::template get<>::template push_front<\
                __VA_ARGS__>>

struct destroyed {};

template<
    class T, 
    auto teval = [] {} 
>
class handle {
private:
    using state = meta_state<none, teval>;

template<class... Ts>
    handle(Ts&&... args) :
        value(std::forward<Ts>(args)...) {
    }

public:
    template<
        class defer,
        auto eval = [] {},
        class v = DEFER_PUSH(defer, defer_assert<state, destroyed>),
        class... Ts 
    >
    static auto make(defer, Ts&&... args) {
        return handle(std::forward<Ts>(args)...);
    }

template<
        auto eval = [] {},
        class prev = state::template get<eval>,
        class v = state::template set<destroyed, std::pair(eval, teval)>,
        class... Ts 
    >
    void destroy(Ts&&... args) {
        static_assert(!std::is_same_v<prev, destroyed>, "destroy was called twice");
        value.destroy(std::forward<Ts>(args)...);
    }

template<class... Ts>
    void raw_destroy(Ts&&... args) {
        value.destroy(std::forward<Ts>(args)...);
    }

template<
        auto eval = [] {},
        class prev = state::template get<eval >
    >
    auto& get() {
        static_assert(!std::is_same_v<prev, destroyed>, "already destroyed");
        return value;
    }

template<
        auto eval = [] {},
        class defer,
        class v = DEFER_PUSH(defer, defer_set<state, destroyed>),
        class v1 = DEFER_PUSH(defer, defer_assert<state, none>),
        class... Ts 
    >
    auto make_scope_guard(defer, Ts&&... args) {
        return scope_guard([&, this] {
            this->raw_destroy(std::forward<Ts>(args)...);
        });
    }

private:
    T value;
};

template<
    auto eval = [] {}, 
    class defer_scope, 
    class T 
>
constexpr auto make_handle(defer_scope, const T& value) {
    using handle_t = handle<T, eval>;
    return handle_t::template make<defer_scope, eval>(defer_scope{}, value);
}

struct lifetime {
	int counter = 0;
	int depth = 0;

constexpr bool outlives(const lifetime other) const {
		if (depth < other.depth) {
			return true;
		}
		else if (other.depth < depth) {
			return false;
		}

return counter > other.counter;
	}

constexpr auto inc() const{
        auto self = *this;
        self.counter++;
        return self;
    }

constexpr auto push() const{
        auto self = *this;
        self.depth++;
        return self;
    }

constexpr auto pop() const{
        auto self = *this;
        self.depth--;
        return self;
    }
};

template<auto teval = [] {} >
class lifetime_factory {
	using state = meta_state<value_wrapper<lifetime{}>, teval>;

template<auto eval>
    using pop_depth = decltype(defer_modify(state{}, [](auto type) {
			return type.modify([](auto value) {
				value.depth--;
				return value;
			});
		}, value_wrapper<eval>{}));
public:
	template<
		auto eval = [] {},
		auto next_lifetime = decltype(state{}.template type<eval>()){}.get().inc(),
		class v = state::template set<value_wrapper<next_lifetime>, std::pair(eval, teval)> >
	constexpr v::type add_lifetime() const {
		return {};
	}

template<
		auto eval = [] {},
        class defer_scope = defer<eval>,
        auto next_lifetime = decltype(state{}.template type<eval>()){}.get().push(),
		class v = state::template set<value_wrapper<next_lifetime>, std::pair(eval, teval)>,
		class action = pop_depth<eval>,
        class v1 = DEFER_PUSH(defer_scope, action)>
	constexpr auto begin_scope(defer_scope arg = {}) const {
		return defer_scope{};
	}
};

template<
    class T, 
    auto lifetime
>
class ptr {
public:
	ptr(T& value, value_wrapper<lifetime>) : m_value(&value) {}

template<auto other_lifetime>
	ptr& operator=(ptr<T, other_lifetime> other) {
		static_assert(other_lifetime.outlives(lifetime), "life time not long enough");
		m_value = other.get();
		return *this;
	}

auto get() const { return m_value; }
private:
	T* m_value;
};

struct borrow_state {
    int read_count = 0;
    int write_count = 0;

constexpr auto read() const {
        auto self = *this;
        self.read_count++;
        return self;
    }

constexpr auto write() const {
        auto self = *this;
        self.write_count++;
        return self;
    }
};

template<class T, auto teval = [] {} >
class borrowable {
    using state = meta_state<value_wrapper<borrow_state{}>,teval>;

template<auto eval>
    using end_write = decltype(defer_modify(state{}, [](auto type) {
            return type.modify([](auto value) {
                value.write_count--;
                return value;
            });
    }, value_wrapper<eval>{}));

template<auto eval>
    using end_read = decltype(defer_modify(state{}, [](auto type) {
            return type.modify([](auto value) {
                value.read_count--;
                return value;
            });
        }, value_wrapper<eval>{}));
public:
    template<class... Ts>
    explicit borrowable(Ts&&... args) : value(std::forward<Ts>(args)...) {}

explicit borrowable(const T& value) : value(value) {}

template<
        auto eval = [] {},
        class defer,
        auto next_state = decltype(state{}.template type<eval>()){}.get().write(),
        class v = state::template set<value_wrapper<next_state>, std::pair(eval, teval)>,
        class action = end_write<eval>,
        class v1 = DEFER_PUSH(defer, action)>
    auto& mut(defer) {
        static_assert(next_state.read_count == 0 && next_state.write_count == 1, "");
        return value;
    }

template<
        auto eval = [] {},
        class defer,
        auto next_state = decltype(state{}.template type<std::pair(eval, teval)>()){}.get().read(),
        class v = state::template set<value_wrapper<next_state>, std::pair(eval, teval)>,
        class action = end_read<eval>,
        class v1 = DEFER_PUSH(defer, action)>
    auto& ref(defer) const {
        static_assert(next_state.write_count == 0, "");
        return value;
    }

private:
    T value;
};

struct device{};
struct texture {
    explicit texture(device){
        std::cout << "creating texture\n";
    }

void destroy(device){
        std::cout << "destroying texture\n";
    }
};
struct texture_view {
    explicit texture_view(device, texture){
        std::cout << "creating texture view\n";
    }
    void destroy(device, texture){
        std::cout << "destroying texture view\n";
    }
};

auto handle_test() {
    using defer_scope = defer<>;
    auto my_device = device{};
    auto my_texture = make_handle(defer_scope{}, texture(my_device));
    auto my_texture_view = make_handle(defer_scope{}, texture_view(my_device, my_texture.get<[]{}>()));

my_texture_view.destroy<[]{}>(my_device, my_texture.get<[]{}>());
    my_texture.destroy<[]{}>(my_device);
    /*
        remove or changing the order of the destroy calls will cause a static assert
    */

defer_scope{}.apply<[]{}>();
    return 0;
};

int handle_test_result = handle_test();

auto scope_guard_test() {
    using defer_scope = defer<>;
    auto my_device = device{};

auto my_texture = make_handle(defer_scope{}, texture(my_device));
    auto texture_scope_guard = my_texture.make_scope_guard<[]{}>(defer_scope{}, my_device);

auto my_texture_view = make_handle(defer_scope{}, texture_view(my_device, my_texture.get<[]{}>()));
    auto texture_view_scope_guard = my_texture_view.make_scope_guard<[]{}>(defer_scope{}, my_device, my_texture.get<[]{}>());

defer_scope{}.apply<[]{}>();
    return 0;
}

int scope_guard_test_result = scope_guard_test();

auto lifetime_test() {
    constexpr auto lifetimes = lifetime_factory<>{};
    using defer_scope = decltype(lifetimes.begin_scope<[]{}>());

int outer_value = 42;
    ptr outer_ptr(outer_value, lifetimes.add_lifetime<[]{}>());
    {
        using defer_scope = decltype(lifetimes.begin_scope<[]{}>());

int inner_value = 3;
        ptr inner_ptr(inner_value, lifetimes.add_lifetime<[]{}>());

inner_ptr = outer_ptr;

// outer_ptr = inner_ptr;
        // uncommenting the above line will cause a static_assert

defer_scope{}.apply<[]{}>();
    }

defer_scope{}.apply<[]{}>();
    return 0;
}

int lifetime_test_result = lifetime_test();

auto borrow_test() {
    using defer_scope = defer<>;
    auto value = borrowable(42);

{
        using defer_scope = defer<>;

auto& ref1 = value.ref<[]{}>(defer_scope{});
        auto& ref2 = value.ref<[]{}>(defer_scope{});
        auto& ref3 = value.ref<[]{}>(defer_scope{});

// auto& mut1 = value.mut<[]{}>(defer_scope{});
        // uncommenting the line above will cause a static assert

defer_scope{}.apply<[]{}>();
    }

{
        using defer_scope = defer<>;

auto& mut1 = value.mut<[]{}>(defer_scope{});
        
        // auto& ref1 = value.ref(defer_scope{});
        // auto& mut2 = value.mut(defer_scope{});
        // uncommenting any of the lines above will cause a static assert

defer_scope{}.apply<[]{}>();
    }

defer_scope{}.apply<[]{}>();
    return 0;
}

int borrow_test_result = borrow_test();

int main(){
    return 0;
}