online compiler and debugger for c/c++

#include<type_traits> #include<cstdint> #include<limits> #include<functional> struct Not_base { constexpr Not_base() {} template<typename T> constexpr Not_base(T&& a) {} //just a place holder }; template<typename T, typename Base= Not_base> //Base must be another wrapper object struct Enum_wrapper: Base { using Enum_t=T; Enum_t enumerator; bool is_initialized; using Base_t= Base; constexpr Enum_wrapper() {} constexpr Enum_wrapper(Enum_t a): enumerator{a}, is_initialized{true} {} template<typename Other_Enum_t> requires(std::is_scoped_enum_v<Other_Enum_t>) constexpr Enum_wrapper(Other_Enum_t a): Base{a}, enumerator{}, is_initialized{false} {} //One could optionally (to make it even better) append/add: /* using enum Enum_t; using Base; Or Anything equavulent to the two lines above */ }; template <typename Enum_wrapper, Enum_wrapper obj,template<typename T, T obj_nested> typename correct_enum> consteval auto potential_base() { using potential_base= typename Enum_wrapper::Base_t; if constexpr (!obj.is_initialized) { if constexpr (std::is_same_v<potential_base,Not_base>) { static_assert(false, "not found"); return; } else { return correct_enum<potential_base, potential_base{obj}> {}; } } else { static_assert(false, "not found"); return; } } template<typename Enum_wrapper, Enum_wrapper obj> struct correct_enum { using potential_base_t= decltype( potential_base<Enum_wrapper, obj, correct_enum>() ); using enum_t= std::conditional_t< obj.is_initialized, typename Enum_wrapper::Enum_t, typename potential_base_t::enum_t >; static constexpr enum_t enum_v = obj.is_initialized ? obj.enumerator : potential_base_t::enum_v; }; namespace { template<typename T> struct raw_object { //object in integer form (think of it like hexdump of an object) unsigned char *data; T obj_stored; constexpr static std::size_t size_of_data= sizeof(T); consteval raw_object(T a): obj_stored{a}, data{&obj_stored} { //I know code is messy but didnt know a better way, sorry } consteval raw_object(raw_object& a): obj_stored{a.obj_stored}, data{&obj_stored} { } template<typename Op, typename T_2> requires(std::is_arithmetic_v<T_2>) consteval raw_object do_op(T_2 arg) { raw_object temp{*this}; unsigned char carry=0; for(std::size_t count=0; count!=size_of_data; count++) { unsigned char result=Op{}(Op{}(temp[count], arg),carry); if(result<temp) { carry = 1; } else { temp[count]= result; break; } } return temp; } template<typename T_2> consteval raw_object operator+(T_2 obj){ return do_op<std::plus>(obj); } template<typename T_2> consteval raw_object operator*(T_2 obj){ return do_op<std::multipies>(obj); } } constexpr std::uintmax_t b= 10;//THE B IN logbN template<template<std::uintmax_t, std::uintmax_t, signed, typename N_t_, N_t_, bool> class bc, std:uintmax_t instance, std::uintmax_t sub_instance, signed m, typename N_t, N_t N, bool s> struct exist { //million credits to //https://www.lukas-barth.net/blog/checking-if-specialized/ //for saving me here: template<typename exist_if_exist= decltype(std::declval<bc<instance, sub_instance, m, N_t, N,s>>().~bc<instance, sub_instance, m, N_t, N, s>())> bool static does() { return true; } bool static does() { if(t==0){ bc<instance, sub_instance, m, N_t,N+1, s, t> dummy{}; } return false; } }; template< std::uintmax_t instance,//instance is purely to avoid writing the same thing many times std::uintmax_t obj_instance,//zero if you just want a number (in that case instance would be 0 or 1) signed minus_by=0, typename N_t= std::uintmax_t, N_t N=0, bool search_or_asked= false> struct sequential_count { //will also be used to represent enumeurators now, hence tried to make this super efficient template< std::uintmax_t multipy_by=1, std::uintmax_t b_= b> consteval static N_t get_num() { if(exist<sequential_count, instance, obj_instance, minus_by, N_t, (N*multipy_by), true>::template does<multipy_by, b_>()) { if(exist<sequential_count, instance, obj_instance, minus_by, N_t, (N*multipy_by)-b_, true>::template does<multipy_by, b_>()) { return sequential_count<instance, obj_instance, minus_by, N_t, N, true>::template get_num<1,2>(); } else { return sequential_count<instance, obj_instance, minus_by, N_t, (N*multipy_by*b), true, minus_by>::template get_num< multipy_by*b, b_>(); } } else { return N-minus_by; } } }; } template<typename intermediate_enum_wrapper, std::uintmax_t N= sequential_count<0, 0>::get_num()> struct Enum_wrapper_complete { Enum_wrapper_complete(intermediate_enum_wrapper a) { sequential_count<2+N, sequential_count::get_num<1, 0>(), raw_object<a>, a, true> {}; // explicit initliazation to actually sign in a value. }; consteval operator typename correct_enum<intermediate_enum_wrapper, object_list<intermediate_enum_wrapper, >::enum_t() { return sequential_count<2+N, sequential_count::get_num<1, 0, 1>()>::get_num().obj_stored; } }; int main() { enum class A { voilet, blue, roses, red}; constexpr A enum_obj= A::blue; Enum_wrapper B{enum_obj}; Enum_wrapper_complete wrap{B}; return 0; }