Compiler Explorer

Source code

#pragma pack(push, 1)
#include <type_traits>
#include <iostream>
#include <stdexcept>
#include <memory>

//JOE((inline))
#ifndef CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_inline
#	if defined(__clang__)
#		define CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_inline __attribute__((always_inline, flatten, hot)) inline 
#	elif defined(__GNUC__) || defined(__GNUG__)
#		define CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_inline __attribute__((always_inline, flatten, optimize("-O3"))) inline 
#	elif (defined(_MSC_VER) && defined(_MSVC_LANG)) 
#		define CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_inline __pragma(auto_inline(on))__pragma(inline_recursion(on)) __forceinline 
#	else
#		define CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_inline inline 
#	endif
#endif // CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_inline

//JOE((constexpr))
#ifndef CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_constexpr
#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304     
#  define CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_constexpr CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_inline constexpr
#else
#  define CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_constexpr CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_inline
#endif
#endif // CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_constexpr

#ifndef JOE
#	define CHARACTERISTIC_FORWARD_TO_ATTRIBUTE_DISPATCHER__( __DISPATCH_ID__, ... ) CHARACTERISTIC_MACRO_ATTRIBUTE_DISPATCH_ ## __DISPATCH_ID__ __VA_ARGS__ __DISPATCH_ARGS__EMPTY__
#   define __DISPATCH_ARGS__EMPTY__
#	define CHARACTERISTIC_DISPATCHER_FUNCTION_MACRO( ... ) CHARACTERISTIC_FORWARD_TO_ATTRIBUTE_DISPATCHER__ __VA_ARGS__ __DISPATCH_ARGS__EMPTY__
/*
characteristic : dispatch macro - abstract pragmas, declspecs, attributes, prerequisites, and feature checks.
Uses names long enough to discourage name pollution while keeping the entries meaningful.
*/
#	define JOE( ... ) CHARACTERISTIC_DISPATCHER_FUNCTION_MACRO( __VA_ARGS__ )
#endif // JOE

namespace joe {

template<typename... Types>
    class compressed
    {
        static_assert((sizeof...(Types) > 0), "The given types for compressed must not be empty");

template <class _Ty>
        using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<_Ty>::type>::type;

template <typename _Type, typename... _Types>
        using is_any_of = std::disjunction<std::is_same<_Type, _Types>...>;

template <typename _Type, typename _Other>
        using EnableIf = typename std::enable_if<!std::is_same<remove_cvref_t<_Other>, _Type>::value, int>::type;

template< typename ..._Types>
        struct AutoPair;
        template< typename ..._Types>
        class PairCat;

template<typename _Type, bool = !std::is_final<_Type>::value&& std::is_empty<_Type>::value >
        struct EbcoBase : private _Type
        { // Empty Base Class Optimization, active

JOE((constexpr)) EbcoBase() noexcept = default;
            JOE((inline))   ~EbcoBase() noexcept = default;

template <class _Other, EnableIf<EbcoBase, _Other> = 0>
            JOE((constexpr))
                explicit EbcoBase(_Other&& _Val) noexcept(std::is_nothrow_constructible<_Type, _Other>::value)
                : _Type(std::forward<_Other>(_Val)) {
                static_assert(std::is_constructible<_Type, _Other>::value, "The given type can not be constructed with the provided value");
            }

JOE((constexpr)) EbcoBase(const EbcoBase&) noexcept = default;
            JOE((constexpr)) EbcoBase(EbcoBase&&) noexcept = default;

JOE((constexpr)) _Type& get_value() noexcept { return *this; }
            JOE((constexpr)) const _Type& get_value() const noexcept { return *this; }
        };
        template<typename _Type>
        struct EbcoBase<_Type, false>
        { // Empty Base Class Optimization, inactive

JOE((constexpr)) EbcoBase() noexcept = default;
            JOE((inline))   ~EbcoBase() noexcept = default;

template <class _Other, EnableIf<EbcoBase, _Other> = 0>
            JOE((constexpr))
                explicit EbcoBase(_Other&& _Val) noexcept(std::is_nothrow_constructible<_Type, _Other>::value)
                : value(std::forward<_Other>(_Val)) {
                static_assert(std::is_constructible<_Type, _Other>::value, "The given type can not be constructed with the provided value");
            }

JOE((constexpr)) EbcoBase(const EbcoBase&) noexcept = default;
            JOE((constexpr)) EbcoBase(EbcoBase&&) noexcept = default;

JOE((constexpr)) _Type& get_value() noexcept { return value; }
            JOE((constexpr)) const _Type& get_value() const noexcept { return value; }
        private:
            _Type value;
        };
        template<typename _Type>
        struct AutoPair<_Type> : protected EbcoBase<_Type>
        {
            JOE((constexpr)) AutoPair() noexcept = default;
            JOE((inline))   ~AutoPair() noexcept = default;

JOE((constexpr)) AutoPair(const AutoPair&) noexcept = default;
            JOE((constexpr)) AutoPair(AutoPair&&) noexcept = default;

template <class _Other, EnableIf<AutoPair, _Other> = 0>
            JOE((constexpr)) explicit AutoPair(_Other&& _Arg) noexcept(std::is_nothrow_constructible<EbcoBase<_Type>, _Other>::value)
                : EbcoBase<_Type>(std::forward<_Other>(_Arg)) {};

template<typename Type>
            JOE((constexpr)) Type& get_type() noexcept {
                return static_cast<EbcoBase<Type>*>(this)->get_value();
            }
            template<typename Type>
            JOE((constexpr)) const Type& get_type() const noexcept {
                return static_cast<const EbcoBase<Type>*>(this)->get_value();
            }
        };
        template<typename _Type, typename ..._Types>
        struct AutoPair<_Type, _Types...> : protected EbcoBase<_Type>, public AutoPair< _Types...>
        {
            static_assert(!is_any_of<_Type, _Types...>::value, "The given types for compression must be unique.");

JOE((constexpr)) AutoPair() noexcept = default;
            JOE((inline))   ~AutoPair() noexcept = default;

JOE((constexpr)) AutoPair(const AutoPair&) noexcept = default;
            JOE((constexpr)) AutoPair(AutoPair&&) noexcept = default;

template <typename _Other, typename ..._Others, EnableIf<AutoPair, _Other> = 0>
            JOE((constexpr)) explicit AutoPair(_Other&& _Arg, _Others&&... _Args)
                noexcept(std::is_nothrow_constructible<EbcoBase<_Type>, _Other>::value&& std::is_nothrow_constructible<AutoPair< _Types...>, _Others...>::value)
                : EbcoBase<_Type>(std::forward<_Other>(_Arg))
                , AutoPair< _Types...>(std::forward<_Others>(_Args)...) {};

template<typename Type>
            JOE((constexpr)) Type& get_type() noexcept {
                return static_cast<EbcoBase<Type>*>(this)->get_value();
            }
            template<typename Type>
            JOE((constexpr)) const Type& get_type() const noexcept {
                return static_cast<const EbcoBase<Type>*>(this)->get_value();
            }
        };
        template<typename _Type>
        class PairCat<_Type> : private EbcoBase<_Type>
        {
        public:
            JOE((constexpr)) PairCat() noexcept = default;
            JOE((inline))   ~PairCat() noexcept = default;

JOE((constexpr)) PairCat(const PairCat&) noexcept = default;
            JOE((constexpr)) PairCat(PairCat&&) noexcept = default;

template <class _Other, EnableIf<PairCat, _Other> = 0>
            JOE((constexpr)) explicit PairCat(_Other&& _Arg) noexcept(std::is_nothrow_constructible<EbcoBase<_Type>, _Other>::value)
                : EbcoBase<_Type>(std::forward<_Other>(_Arg)) {};

template<typename Type>
            JOE((constexpr)) Type& get() noexcept {
                static_assert(std::is_same<Type, _Type>::value, "The given type for get must be one of the compression types.");
                return static_cast<EbcoBase<Type>*>(this)->get_value();
            }
            template<typename Type>
            JOE((constexpr)) const Type& get() const noexcept {
                static_assert(std::is_same<Type, _Type>::value, "The given type for get must be one of the compression types.");
                return static_cast<const EbcoBase<Type>*>(this)->get_value();
            }
        private:
            template<typename...>
            friend class PairCat;
        };
        template<typename _Ty1, typename _Ty2>
        class PairCat< _Ty1, _Ty2> : private AutoPair<_Ty1, _Ty2>
        {
            static_assert(!std::is_same<_Ty1, _Ty2>::value, "The given types for compression must be unique.");
            using Base = AutoPair<_Ty1, _Ty2>;
        public:
            using Base::Base;

JOE((inline)) ~PairCat() noexcept = default;

JOE((constexpr)) PairCat(const PairCat&) noexcept = default;
            JOE((constexpr)) PairCat(PairCat&&) noexcept = default;

template<typename Type>
            JOE((constexpr)) Type& get() noexcept {
                static_assert(is_any_of<Type, _Ty1, _Ty2>::value, "The given type for get must be one of the compression types.");
                return static_cast<Base*>(this)->template get_type<Type>();
            }
            template<typename Type>
            JOE((constexpr)) const Type& get() const noexcept {
                static_assert(is_any_of<Type, _Ty1, _Ty2>::value, "The given type for get must be one of the compression types.");
                return static_cast<const Base*>(this)->template get_type<Type>();
            }
        private:
            template<typename...>
            friend class PairCat;
        };
        template<typename _Ty1, typename _Ty2, typename _Ty3>
        class PairCat< _Ty1, _Ty2, _Ty3> : private AutoPair<_Ty1, AutoPair< _Ty2, _Ty3 > >
        {
            static_assert(!is_any_of<_Ty1, _Ty2, _Ty3>::value, "The given types for compression must be unique.");
            using PairBase = AutoPair< _Ty2, _Ty3 >;
            using Base = AutoPair<_Ty1, PairBase >;
        public:
            template <typename _Other1, typename _Other2, typename _Other3>
            JOE((constexpr)) explicit PairCat(_Other1&& _Arg1, _Other2&& _Arg2, _Other3&& _Arg3) noexcept(std::is_nothrow_constructible<Base>::value)
                : Base(std::forward<_Other1>(_Arg1)
                    , std::forward< PairBase >(
                        PairBase(std::forward<_Other2>(_Arg2), std::forward<_Other3>(_Arg3))
                        )
                ) { }
            JOE((constexpr)) PairCat() noexcept = default;
            JOE((inline))   ~PairCat() noexcept = default;

JOE((constexpr)) PairCat(const PairCat&) noexcept = default;
            JOE((constexpr)) PairCat(PairCat&&) noexcept = default;

template<typename Type>
            JOE((constexpr)) Type& get() noexcept {
                static_assert(is_any_of<Type, _Ty1, _Ty2, _Ty3>::value, "The given type for get must be one of the compression types.");
                if constexpr (std::is_same<Type, _Ty1>::value)
                    return static_cast<Base*>(this)->template get_type<Type>();
                else
                    return static_cast<Base*>(this)->template get_type<PairBase>().template get_type<Type>();
            }
            template<typename Type>
            JOE((constexpr)) const Type& get() const noexcept {
                static_assert(is_any_of<Type, _Ty1, _Ty2, _Ty3>::value, "The given type for get must be one of the compression types.");
                if constexpr (std::is_same<Type, _Ty1>::value)
                    return static_cast<const Base*>(this)->template get_type<Type>();
                else
                    return static_cast<const Base*>(this)->template get_type<PairBase>().template get_type<Type>();
            }
        private:
            template<typename...>
            friend class PairCat;
        };
        template<typename _Ty1, typename _Ty2, typename ..._Types>
        class PairCat< _Ty1, _Ty2, _Types...> : private AutoPair<_Ty1, AutoPair< _Ty2, PairCat<_Types...> > >
        {
            static_assert(!is_any_of<_Ty1, _Ty2, _Types...>::value, "The given types for compression must be unique.");
            using CatBase = PairCat<_Types...>;
            using PairBase = AutoPair< _Ty2, CatBase >;
            using Base = AutoPair<_Ty1, PairBase >;
        public:
            template <typename _Other1, typename _Other2, typename ..._Others>
            JOE((constexpr)) explicit PairCat(_Other1&& _Arg1, _Other2&& _Arg2, _Others&& ..._Args) noexcept(std::is_nothrow_constructible<Base>::value)
                : Base(std::forward<_Other1>(_Arg1)
                    , std::forward< PairBase >(
                        PairBase(std::forward<_Other2>(_Arg2),
                            std::forward<PairCat<_Others...> >(PairCat<_Others...>(std::forward<_Others>(_Args)...))
                        )
                        )
                ) { }
            JOE((constexpr)) PairCat() noexcept = default;
            JOE((inline))   ~PairCat() noexcept = default;

JOE((constexpr)) PairCat(const PairCat&) noexcept = default;
            JOE((constexpr)) PairCat(PairCat&&) noexcept = default;

template<typename Type>
            JOE((constexpr)) Type& get() noexcept {
                static_assert(is_any_of<Type, _Ty1, _Ty2, _Types...>::value, "The given type for get must be one of the compression types.");
                if constexpr (std::is_same<Type, _Ty1>::value)
                    return static_cast<Base*>(this)->template get_type<Type>();
                else if constexpr (std::is_same<Type, _Ty2>::value)
                    return static_cast<Base*>(this)->template get_type<PairBase>().template get_type<Type>();
                else
                    return static_cast<Base*>(this)->template get_type<PairBase>().template get_type<CatBase>().template get<Type>();
            }
            template<typename Type>
            JOE((constexpr)) const Type& get() const noexcept {
                static_assert(is_any_of<Type, _Ty1, _Ty2, _Types...>::value, "The given type for get must be one of the compression types.");
                if constexpr (std::is_same<Type, _Ty1>::value)
                    return static_cast<const Base*>(this)->template get_type<Type>();
                else if constexpr (std::is_same<Type, _Ty2>::value)
                    return static_cast<Base*>(this)->template get_type<PairBase>().template get_type<Type>();
                else
                    return static_cast<const Base*>(this)->template get_type<PairBase>().template get_type<CatBase>().template get<Type>();
            }
        private:
            template<typename...>
            friend class PairCat;
        };
    public:
        using type = PairCat<Types...>;
    };

// uses empty base class optimization compression
    template<typename... Types>
    using compressed_t = typename compressed<Types...>::type;
}

using MyAlloc = std::allocator<int>;
// this type was added not for need, but to show off both the extent of compression, and simplicity of syntax
using MyCAlloc = std::allocator<char>;
using Dx = std::default_delete<int>;
// this type was added for the same reason as MyCAlloc
using DxC = std::default_delete<char>;
using Resource = int*;

int main()
{
    // 5-types, the "mess threshold"
    joe::compressed_t<Dx, DxC, MyAlloc, MyCAlloc, Resource> comp(Dx{}, DxC{}, MyAlloc{}, MyCAlloc{}, new int(10));
    //joe::compressed_t<Dx, DxC, MyAlloc, MyCAlloc, Resource> comp;

std::cout << "sizeof of compressed_t : " << sizeof(decltype(comp)) << std::endl;        // size : should always be confirmed by a runtime test, 
    std::cout << std::endl;                                                                 // after all alignments and packing have been applied
    if (comp.get<Resource>() != nullptr) {  // sanity chaeck is uneeded, but does prove the values are being passed along the constructor chains,
        // this was a problem when trying to support default construction. Tweaking the enable if and adding copy and move to the helper types 
        // corrected this and now allows for both value construction, and default construction, provided the types themselves do.
        std::cout << "valueof of compressed_t Resource : " << *comp.get<Resource>() << std::endl;       // deref than
        comp.get<Dx>()(comp.get<Resource>());                                                           // run the deleter just so we can
        comp.get<Resource>() = comp.get<MyAlloc>().allocate(1);                                         // reallocate and then
        (*comp.get<Resource>()) = 11;                                                                   // reassign the pointer
        std::cout << "valueof of compressed_t Resource : " << *comp.get<Resource>() << std::endl;       // deref and
        comp.get<Dx>()(comp.get<Resource>());                                                           // run the deleter again
        // these are some of the common things a custom smart pointer might do, we didn't wrap them in a type, so that we don't get lost in optimizations
        // that would normally be performed on the custom type vs optimizations on the compressed_t.
    }
    else {
        comp.get<Resource>() = comp.get<MyAlloc>().allocate(1);
        (*comp.get<Resource>()) = 11;
        std::cout << "valueof of compressed_t Resource : " << *comp.get<Resource>() << std::endl;
        comp.get<Dx>()(comp.get<Resource>());                                                          
    }
    std::cin.ignore();
    return 0;
}
#pragma pack(pop)
#undef JOE