SQLStruct.hpp

// Type your code here, or load an example.
#include <memory> 
#include <vector> 
#include <type_traits>
#include <map>
#include <string>
#include <iostream>
#include <variant>
#include <cstdint>
#include <cmath>
#include <math.h>
#include <algorithm>
#include <any>
#include <charconv>
#include <utility>
#include <array>
#include <concepts>
#include <string>

using namespace std::literals;

struct empty{};

template <typename Specialization, template <typename...> typename Basetype>
concept specialization_of_types_only = requires (Specialization s) { 
    []()-> decltype(Basetype(s))* {return nullptr;}.operator()();
};


//evil and ugly code , maybe i will find a better solution in the future 
#define create_specialization_concept(Name, Basetype)                          \
template <typename Specialization>                                             \
concept specialization_##Name = requires (Specialization s){                   \
    []()-> decltype(Basetype(s))* {return nullptr;}.operator()();                              \
}

#define create_specialization_type_name(Basetype) create_specialization_concept(Basetype, Basetype)

template <typename T>
concept is_empty = std::same_as<T, empty>;


static constexpr std::size_t get_integral_size(std::integral auto i){
    std::size_t count{0};
    auto num = i;
    while (num > 0) {
        count++;
        num /= 10;
    }

    return count; 
}

template <std::size_t Size>
struct fixed_string {
    char _data[Size + 1]{0};
    static constexpr std::size_t _size = Size;

    constexpr explicit(false) fixed_string(char const* str) {
        std::copy_n(str, Size + 1, _data);
    }

    template <std::integral Integral> 
    constexpr explicit(false) fixed_string(Integral i){
        number_to_string(i, get_integral_size(i));
    }

    constexpr explicit(false) fixed_string() {
    }

    constexpr explicit(false) operator std::string_view() const {
        return {_data, _size};
    }

    constexpr std::size_t size() const {
        return _size;
    }

    constexpr const char* data() const {
        return _data;
    }

    constexpr auto operator<=>(const fixed_string&) const = default;

    private: 
    
//constexpr algorithm ro turn numbers to strings 
// in c++23 we will be able to use to_chars
constexpr void number_to_string(std::integral auto i, std::size_t count){
    auto num = i; 

    while (count > 0){
        count--;
        char c = '0' + num % 10; 
        _data[count] = c; 
        num /= 10;
    }
}
};

create_specialization_type_name(fixed_string);


//helper for empty fixed_string
fixed_string() -> fixed_string<0>;

template <unsigned int Size> 
fixed_string(char const (&)[Size]) -> fixed_string<Size - 1>;

template <auto i> requires std::integral<decltype(i)>
constexpr auto make_integral_fixed_string() {
    return fixed_string<get_integral_size(i)>(i);
}

template <std::size_t N>
struct IDXWrapper{
    static constexpr std::size_t IDX = N;

};


template <typename T>
concept IDXWrapperable = requires (T) { T::IDX; }; 

template<auto Key, typename Val>
struct alignas(alignof(int)) schema_field {
    using ArgType = Val;
    static constexpr auto key_ = Key;
    using Pure_Key_Type = std::decay_t<decltype(Key)>; 
    Val val_{};
     

    template<typename T>
    constexpr auto operator=(const T& val) const {
        return schema_field<Key, T>{.val_ = val};
    }

    constexpr explicit(false) operator std::string_view() const {
        return _strKey;
    }

    private:
    static constexpr auto get_str_key() requires specialization_fixed_string<Pure_Key_Type> and 
    (not std::integral<Pure_Key_Type>){
        return Key;
    }

    static constexpr auto get_str_key() requires std::integral<Pure_Key_Type>{
        return make_integral_fixed_string<Key>();
    }

    static constexpr auto get_str_key() requires std::convertible_to<Pure_Key_Type, std::string_view> and 
    (not std::integral<Pure_Key_Type>) and (not specialization_fixed_string<Pure_Key_Type>){
        return fixed_string<Key.size()>(Key.data());
    }

    static constexpr auto _strKey = get_str_key();
    static constexpr std::size_t _size = _strKey.size();
};


create_specialization_type_name(schema_field);

constexpr std::size_t integral_pow(std::integral auto base, std::integral auto exp){
    auto ret{base};
    for (decltype(base) i = 1; i < static_cast<decltype(base)>(exp); i++){
        ret*=base;
    }

    return exp > 0 ? ret : 1;
}

//again only in c++23 we will be able to use from_chars as a constexpr 
//this funcion will produce an error if a number of size greater then std::numeric_limits<std::size_t>::max() will be used 
template<char... data> 
requires (sizeof...(data) < get_integral_size(std::numeric_limits<std::size_t>::max()))
constexpr std::size_t to_number(){ 
    constexpr auto size_of_pack = sizeof...(data)-1;
    return []<std::size_t... Idxs>(std::index_sequence<Idxs...>){
        return (... + ((data-'0')*integral_pow(10, size_of_pack-Idxs)));
    }(std::make_index_sequence<sizeof...(data)>());
}

template<fixed_string Name>
constexpr auto operator""_sf() { return schema_field<Name, empty>{}; };

template<fixed_string Name>
constexpr auto operator""_fs() { return Name; };

template<char... data> 
constexpr auto operator""_isf(){
    constexpr std::size_t idx = to_number<data...>();
    return schema_field<idx, schema_field<""_fs, empty>>{};
}

template <char... data>
constexpr auto operator""_IDX(){
   return IDXWrapper<to_number<data...>()>();
}


template<specialization_schema_field... schema_fields> 
struct schema : public schema_fields...{}; 

namespace impl{
    //if we cant get the type use this function to return the default type 
    template<typename Default, auto Key, template <auto, typename> typename>
    auto find_sliced_type(...) -> Default;

    //if we can deduce the argument type then this function will return the correct argument type that was inhereted from 
    // this works due to the fact that sqlstruct inherits all arguments 
    template<typename, auto Key, template <auto, typename> typename Arg, typename Val>
    requires (std::integral<decltype(Key)> || std::convertible_to<decltype(Key), std::string_view>)
    auto find_sliced_type(Arg<Key, Val>*) -> Arg<Key, Val>;  
}

template<typename MultiStruct, typename Default, auto Key, template <auto, typename> typename Arg>
using find_sliced_type = decltype(impl::find_sliced_type<Default, Key, Arg>(static_cast<MultiStruct*>(nullptr)));

template <specialization_schema_field... schema_fields> 
struct SQLRow : public schema_fields... {
    template<std::size_t... Ns>
    static constexpr decltype(auto) get_type_for_ind(std::index_sequence<Ns...>){
        return schema<
        schema_field<static_cast<std::size_t>(Ns), schema_fields>...>{};
    }

    constexpr explicit(true) SQLRow(schema_fields... fields): schema_fields{fields}...
    {};

    //default constructor that allocates nothing
    //TODO: maybe we need to do something here so that users wont be able to use it 
    constexpr explicit(true) SQLRow() {};

    //this is just amazing we are passing non template parameters and the deduction rules 
    //just know how to complete them!!!!
    template <typename T, typename ARG = find_sliced_type<SQLRow, empty, T::key_, schema_field>>
    requires (!std::same_as<empty, ARG>)
    constexpr const auto& operator[](const T) const {
        return static_cast<const ARG*>(this)->val_;
    }

    template <typename T, typename ARG = find_sliced_type<SQLRow, empty, T::key_, schema_field>>
    requires (!std::same_as<empty, ARG>)
    constexpr auto& operator[](const T) {
        return static_cast<ARG*>(this)->val_;
    }

    template <IDXWrapperable T>
    constexpr const auto& operator[](const T) const {
        return get<T::IDX>().val_;
    }

    template <IDXWrapperable T>
    constexpr auto& operator[](const T) {
        return get<T::IDX>().val_;
    }

    template <std::size_t N, 
    typename ArgMap = std::decay_t<decltype(get_type_for_ind(std::make_index_sequence<sizeof...(schema_fields)>{}))>,
    typename Arg = find_sliced_type<ArgMap, empty, N, schema_field>>
    auto& get() requires (!std::same_as<empty, Arg>) {
        return *static_cast<typename Arg::ArgType*>(this);
    }

    template <std::size_t N, 
    typename ArgMap = std::decay_t<decltype(get_type_for_ind(std::make_index_sequence<sizeof...(schema_fields)>{}))>,
    typename Arg = find_sliced_type<ArgMap, empty, N, schema_field>>
    const auto& get() const requires (!std::same_as<empty, Arg>) {
        return *static_cast<const typename Arg::ArgType*>(this);
    }

    static constexpr std::size_t size = sizeof...(schema_fields);
};

template <specialization_schema_field... schema_fields>
SQLRow(schema_fields...) -> SQLRow<schema_fields...>; 

create_specialization_type_name(SQLRow);

namespace std{

    template<specialization_schema_field... schema_fields>
    struct tuple_size<SQLRow<schema_fields...>>{
        static constexpr size_t value = SQLRow<schema_fields...>::size;
    };

    template <size_t IDX, specialization_schema_field... schema_fields>
    struct tuple_element<IDX, SQLRow<schema_fields...>>{
        using SQL = SQLRow<schema_fields...>;
        using ArgMap = decltype(SQL::get_type_for_ind(std::make_index_sequence<sizeof...(schema_fields)>{}));
        using type = typename find_sliced_type<ArgMap, ::empty, IDX, schema_field>::ArgType;
        static_assert(!is_same_v<type, ::empty>);
    };

    template <size_t IDX, specialization_SQLRow Row>
    auto& get(Row& sql){
        return sql.template get<IDX>();
    } 

    template <size_t IDX, specialization_SQLRow Row>
    const auto& get(const Row& sql){
        return sql.template get<IDX>();
    } 
}
 

//for now we will hold the rows as an array to get constexpr p
template <std::size_t N, specialization_SQLRow Row>
class SQLTable{
    public: 
    constexpr SQLTable(specialization_SQLRow auto&&... rows) 
    requires std::conjunction_v<std::is_same<Row, std::decay_t<decltype(rows)>>...>{
        rows_ = std::to_array({rows...});
    }

    auto operator[](std::size_t row_idx){
        return rows_[row_idx];
    }

    private: 
    std::array<Row, N> rows_;
};

template <specialization_SQLRow Head, specialization_SQLRow... Tail>
SQLTable(Head, Tail...) -> SQLTable<sizeof...(Tail)+1, Head>;

int main(){
    constexpr auto key = (158_isf).key_;
    std::cout << key << "\n";
    constexpr auto fs = "Itai"_fs;
    static_assert(fs == "Itai"sv);
    static_assert("Ari"sv == "Ari"_sf);
    auto arg1 = ("Ari"_sf = 10);
    constexpr auto sql1 = SQLRow("x"_sf = 10, "y"_sf = 20.05f);
    static_assert(10 == sql1["x"_sf]);
    auto sql2 = SQLRow("x"_sf = 10, "y"_sf = 20.05f, "Itay"_sf = std::array<int, 3>{{1, 2, 3}});
    sql2["x"_sf] = 11;
    sql2["y"_sf] = 20.11f;
    sql2["Itay"_sf][2] = 5; 
    auto arg3 = std::get<0>(sql2);
    auto& [a1, a2, a3] = sql2;
    auto table = SQLTable(SQLRow("x"_sf = 10, "y"_sf = 20.05f), SQLRow("x"_sf = 1, "y"_sf = 20.15f));
    auto test3 = std::get<0>(table[0]);
    auto test4 = table[0][1_IDX];
    return arg3.val_ + a1.val_;
}