TemplateTraits.hpp

//
// Created by Hamza El-Kebir on 12/22/21.
//
 
#ifndef LODESTAR_TEMPLATETRAITS_HPP
#define LODESTAR_TEMPLATETRAITS_HPP
 
#include <type_traits>
 
#define RETURNS(...) \
  noexcept(noexcept(__VA_ARGS__)) \
    ->decltype(__VA_ARGS__) { \
      return (__VA_ARGS__); \
  }
 
namespace ls {
    namespace aux {
        class TemplateTraits {
        public:
            // See https://stackoverflow.com/a/44013030
            template<class, template<class...> class>
            struct isInstance : public ::std::false_type {
                static const bool value = false;
            };
 
            template<class... T, template<class...> class U>
            struct isInstance<U<T...>, U> : public ::std::true_type {
                static const bool value = true;
            };
 
            // https://stackoverflow.com/a/29671981
            template<bool...>
            struct bool_pack;
            template<bool... bs>
            using allTrue = ::std::is_same<bool_pack<bs..., true>, bool_pack<true, bs...>>;
 
            template<bool... bs>
            using allFalse = ::std::is_same<bool_pack<bs..., false>, bool_pack<false, bs...>>;
 
            template<class R, class... Ts>
            using allConvertible = allTrue<::std::is_convertible<Ts, R>::value...>;
 
            template<class R, class... Ts>
            using allSame = allTrue<::std::is_same<Ts, R>::value...>;
 
            template<class R, class... Ts>
            using allBasedOf = allTrue<::std::is_base_of<R, Ts>::value...>;
 
            template<bool... bs>
            using anyTrue = ::std::integral_constant<bool, !allFalse<bs...>::value>;
 
            template<class R, class... Ts>
            using anyConvertible = anyTrue<::std::is_convertible<Ts, R>::value...>;
 
            class BinaryOperators {
            protected:
                struct addable {
                    template<class T, class U>
                    auto operator()(T t, U u) RETURNS(t + u)
                };
 
                struct subtractable {
                    template<class T, class U>
                    auto operator()(T t, U u) RETURNS(t - u)
                };
 
                struct multiplicable {
                    template<class T, class U>
                    auto operator()(T t, U u) RETURNS(t * u)
                };
 
                struct divisible {
                    template<class T, class U>
                    auto operator()(T t, U u) RETURNS(t / u)
                };
 
            public:
                // See https://stackoverflow.com/a/29014938
                template<class...>
                struct voider {
                    using type = void;
                };
                template<class...Ts>
                using void_t = typename voider<Ts...>::type;
 
                template<class T, class U, class BinaryOperation, class Enable = void>
                struct isBinopableImpl : ::std::false_type {
                    using returnType = void;
                };
 
                template<class T, class U, class BinOp>
                struct isBinopableImpl<T, U, BinOp, void_t<
                        decltype(::std::declval<BinOp>()(
                                ::std::declval<T>(), ::std::declval<U>()))>> :
                        ::std::true_type {
                    using returnType = typename ::std::decay<decltype(::std::declval<BinOp>()(
                            ::std::declval<T>(), ::std::declval<U>()))>::type;
                };
 
                template<typename T>
                struct parseMatrixLike : ::std::false_type {
                    using scalar = T;
 
                    enum {
                        rows = 0,
                        cols = 0
                    };
                };
 
                template<template<typename, int, int, int...> class TWrapper, typename TScalar, int TRows, int TCols, int... TOtherParams>
                struct parseMatrixLike<TWrapper<TScalar, TRows, TCols, TOtherParams...>>
                        : ::std::true_type {
                    using scalar = TScalar;
                    enum {
                        rows = TRows,
                        cols = TCols
                    };
 
                    template<typename UScalar, int URows, int UCols, int... UOtherParams>
                    using wrapper = TWrapper<UScalar, URows, UCols, UOtherParams...>;
                };
 
                template<typename T, class BinOp>
                struct sanitizeTypeBinop : ::std::false_type {
                    using returnType = T;
                };
 
                template<class BinOp,
                        template<typename, typename, int...> class TWrapper,
                        int... TWrapperInts,
                        template<typename, int...> class TWrapperChild1,
                        template<typename, int...> class TWrapperChild2,
                        typename TScalar,
                        typename UScalar,
                        int... TInts,
                        int... UInts>
                struct sanitizeTypeBinop<TWrapper<
                        TWrapperChild1<TScalar, TInts...>,
                        TWrapperChild2<UScalar, UInts...>,
                        TWrapperInts...>, BinOp>
                        :
                                ::std::true_type {
                    using condition1 = typename ::std::conditional<
                            isBinopableImpl<TScalar, UScalar, BinOp>::value,
                            ::std::true_type,
                            ::std::false_type>::type;
 
                    using condition2 = typename ::std::conditional<
                            parseMatrixLike<TWrapperChild1<TScalar, TInts...>>::value &&
                            parseMatrixLike<TWrapperChild2<UScalar, UInts...>>::value,
                            ::std::true_type,
                            ::std::false_type
                    >::type;
 
                    using input = TWrapper<TWrapperChild1<TScalar, TInts...>, TWrapperChild2<UScalar, UInts...>>;
                    // TODO: Investigate if TOtherParams or UOtherParams matter.
                    using sanitized = TWrapperChild1<typename ::std::decay<typename isBinopableImpl<TScalar, UScalar, BinOp>::returnType>::type, parseMatrixLike<TWrapperChild1<TScalar, TInts...>>::rows, parseMatrixLike<TWrapperChild2<UScalar, UInts...>>::cols>;
 
                    using returnType = typename ::std::conditional<
                            (allSame<::std::true_type, condition1, condition2>::value),
                            sanitized,
                            input
                    >::type;
                };
 
                template<typename T>
                using sanitizeTypeMultiplicable = sanitizeTypeBinop<T, multiplicable>;
 
                template<class T, class U, class BinOp>
                using isBinopable = isBinopableImpl<T, U, BinOp>;
 
                template<class T, class U = T>
                using isAddable = isBinopable<T, U, addable>;
 
                template<class T, class U = T>
                using isSubtractable = isBinopable<T, U, subtractable>;
 
                template<class T, class U = T>
                using isMultiplicable = isBinopable<T, U, multiplicable>;
 
                template<class T, class U = T>
                using isDivisble = isBinopable<T, U, divisible>;
            };
        };
    }
}
 
#undef RETURNS
 
#endif //LODESTAR_TEMPLATETRAITS_HPP