typetraits.inl

Go to the documentation of this file.

/** ************************************************************************************************
 * \file
 * This header file is part of module \alib_boxing of the \aliblong.
 *
 * \emoji :copyright: 2013-2024 A-Worx GmbH, Germany.
 * Published under \ref mainpage_license "Boost Software License".
 **************************************************************************************************/
#ifndef HPP_ALIB_BOXING_TYPETRAITS
#define HPP_ALIB_BOXING_TYPETRAITS 1
 
#if !defined(HPP_ALIB_BOXING_BOXING)
#   error "ALib sources with ending '.inl' must not be included from outside."
#endif
 
namespace alib {  namespace boxing  {
 
namespace detail  {
/**
 * This type is used internally with struct \alib{boxing;TMappedTo}.
 *
 * \note
 *   The type is not used by user code. However, working with a debugger, when investigating
 *   to the \alib{boxing::detail;VTable} of a box value, this type will nicely denote that
 *   the mapped type is not an array.
 */
struct TPlain  {};
 
/**
 * This type is used internally with struct \alib{boxing;TMappedToArrayOf}.
 *
 * \note
 *   The type is not used by user code. However, working with a debugger, when investigating
 *   to the \alib{boxing::detail;VTable} of a box value, this type will nicely denote that
 *   the mapped type is an array.
 */
struct TArrayOf {};
 
/**
 * This is an empty type used to denote that default boxing is active. The type is
 * used with the default implementation of TMP struct \alib{boxing;T_Boxer}.
 * Providing this type in custom specializations (wrapped in \alib{boxing;TMappedTo}),
 * make such specialization in-effective.
 *
 * \see
 *   Templated struct \alib{boxing;T_Boxer} for more information.
 */
struct TDefaultBoxing  {};
 
 
/**
 * This is an empty type used to denote that a type must not be boxed.
 * To disable \alib_boxing_nl for a custom type, a specialization of type traits
 * struct \alib{boxing;T_Boxer} must use this type (wrapped in \alib{boxing;TMappedTo}), to
 * define type member \alib{boxing;T_Boxer::Mapping}.
 *
 * \see
 *   Templated struct \alib{boxing;T_Boxer} for more information.
 */
struct TNotBoxable     {};
 
}
 
/**
 * This type is used with to denote type mapping with standard, non-array types.
 *
 * Type mappings using either this or sibling struct \alib{boxing;TMappedToArrayOf}, have
 * to be provided with
 * - Specializations of \alib{boxing;T_Boxer}, and
 * - Namespace function \alib{boxing;BootstrapRegister} used to associated box-function implementations
 *   with mapped types.
 *
 * \see
 *   Templated struct \alib{boxing;T_Boxer} for more information.
 *
 * @tparam TMapped   The boxed type.
 */
template<typename TMapped>
struct TMappedTo
{
    /**
     * The given type \p{TMapped}.<br>
     */
    using Type         = TMapped;
 
    /**
     * Denotes that the type is not boxed to an array type.
     */
    using PlainOrArray = detail::TPlain;
 
};
 
 
/**
 * This type is used to define type mappings targeting array-types.
 * Array types consist of a an element type as well as a length.
 * Corresponding specializations of \alib{boxing;T_Boxer::Write} and \alib{boxing;T_Boxer::Read}
 * have to use write the pointer to the start of the array and the array's length into
 * the box's \alib{boxing;Placeholder}.
 *
 * \see
 *   Sibling struct \alib{boxing;TMappedTo} used to denote mapping to standard non-array types.
 *
 * @tparam TElement  The boxed array's element type.
 */
template<typename TElement>
struct TMappedToArrayOf
{
    /**
     * The element type given as \p{TElement}.<br>
     */
    using Type         = TElement;
 
    /**
     * Denotes that the type is boxed to an array type.
     */
    using PlainOrArray = detail::TArrayOf;
};
 
/** ************************************************************************************************
 * This template struct is used to define customized behavior for boxing C++ type
 * \p{TBoxable}.
 *
 * ### Default Boxing: ###
 * If this struct is \b not specialized for template type \p{TBoxable},
 * default boxing applies.
 * With that, values \b and pointers of a type are boxed in the same way:
 * - They are both boxed to a pointer of \p{TBoxable} if a value of the type does not "fit" into
 *   a box's \alib{boxing;Placeholder} or if the type is not copy-constructible or not
 *   trivially destructible.
 * - Otherwise, both are boxed as values, hence if a pointer is given to the constructor or
 *   assign \c operator= of class \alib{boxing;Box}, indirection \c operator* is applied.
 *
 * <br><p>
 * ###Custom Boxing With Specializations Of This Struct: ###
 * The default boxing briefly described above, can be manipulated by providing a specialization
 * of this struct.
 * All three entities of this default implementation have to be provided with such specializations:
 *
 * 1. <b>Type definition #Mapping:</b><br>
 *    The mapped type must be given using helper struct \alib{boxing;TMappedTo} or
 *    \alib{boxing;TMappedToArrayOf}. The mapped type needs to be given as an explicit template
 *    parameter of those.
 *    In the case of TMappedTo, the template parameter denotes the mapped type, while
 *    with TMappedToArrayOf, the template parameter denotes the type of the elements of the boxed
 *    C++ array.
 *
 *    If special type \alib{boxing;detail::TNotBoxable} is given (still wrapped in the helper, hence given
 *    as <c>TMappedTo<TNotBoxable></c>), then boxing is disallowed for type \p{TBoxed}.
 *    In this case, only declarations of functions #Write and #Read need to be provided, as they
 *    are never invoked.
 *
 *    The default implementation of this struct uses a second special type available,
 *    \alib{boxing;detail::TDefaultBoxing} which denotes default boxing.
 *
 * 2. <b>Static Method #Write:</b><br>
 *    This method is invoked for converting source values to mapped types.
 *    Often the default implementation given in the un-specialized version this struct is
 *    applicable. In this case it can simply be copied to the specialization.
 *
 *    Custom implementations may use TMP-enabled overloads of method \alib{boxing;Placeholder::Write}
 *    or alternatively write to the \c union members of the placeholder directly.
 *
 * 3. <b>Static Method #Read:</b><br>
 *    This method is invoked for converting the placeholder data back to the boxed source type.
 *    Often the default implementation given in the un-specialized version of this struct is
 *    well suited. In this case it can simply be copied to the specialization.<br>
 *    Custom implementations may use TMP-enabled overloads of method \alib{boxing;Placeholder::Read}
 *    or alternatively read the \c union members of the placeholder directly.
 *
 *    A type becomes \alib{boxing;TT_IsUnboxable;not unboxable} in the moment this function
 *    returns a different type than \p{TBoxable}.<br>
 *    This may well be intended and thus the specialized version of this struct
 *    may declare this method to return \c void.
 *    In this case a declaration of the method is sufficient, as it will never be invoked.<br>
 *    With TMP-enabled specializations of this struct (see  Programmer's Manual
 *    chapter \ref alib_boxing_customizing_conditional), the return type might be conditionally set.
 *    Such TMP-defined return type then decides about which of the TMP-enabled types are unboxable
 *    and which are not.
 *
 * \note
 *   If a specialization uses default type mapping by providing<br>
 *
 *       using   Mapping=      TMappedTo<TDefaultBoxing>;
 * \note
 *   in theory, a mixture of default and custom boxing is in place!
 *   Note, that the authors of this library and documentation have not seen a use case for this, yet.
 *
 * <br><p>
 * ### Helper Macros: ###
 *
 * A set of macros for defining specializations exist.
 * The use of the macro is recommended, as besides being less error prone, their use make the code
 * more readable. Finally, chances are good that code that uses the macros remains compatible
 * with future versions of module \alib_boxing_nl.
 *
 * All macros expect this struct's template type \p{TBoxable} as the first parameter, and most
 * expect the mapped type as the second parameter. The latter must not be wrapped in
 * templated helpers \b %TMappedTo respectively \b %TMappedToArrayOf, as the macros internally do that.<br>
 *
 * For more information, see the reference documentation of the macros, which are:
 *
 * - \ref ALIB_BOXING_CUSTOMIZE
 * - \ref ALIB_BOXING_CUSTOMIZE_TYPE_MAPPING
 * - \ref ALIB_BOXING_CUSTOMIZE_NOT_UNBOXABLE
 * - \ref ALIB_BOXING_CUSTOMIZE_ARRAY_TYPE
 * - \ref ALIB_BOXING_CUSTOMIZE_ARRAY_TYPE_NON_UNBOXABLE
 * - \ref ALIB_BOXING_CUSTOMIZE_DENY_BOXING
 *
 * <br><p>
 * ### Value Boxing and Nulled Pointers: ###
 * If a type is boxed as value (either with default boxing or custom boxing) and a \e nulled
 * pointer to that type is boxed, method \alib{boxing;Placeholder::Clear} is invoked
 * instead of this struct's method #Write.
 *
 * <br><p>
 * ### Avoiding Seldom Compilation Errors: ###
 * For technical reasons, namely to avoid TMP compilation problems, some conditional specialization
 * is internally made, that declare method #Read \c void. This is sometimes needed, if a type is
 * not returnable, even if that becomes never be boxed or unboxed.
 * Such situation might happen with TMP, for example if class \b Box is part of a \c union.<br>
 * The specialization is made for the following types of \p{TBoxable}:
 * - C++ array types<br>
 *   Those types are fetched by an overloaded constructor that does not (because it can not)
 *   leverage this struct. Likewise, they can not be unboxed in the usual fashion.
 * - Function types (selected by <c>std::is_function<TBoxable>::value</c>).
 *
 * If a dubious error message about method #Read not being able to return a certain type occurs, even
 * one that a user's code maybe even does "actively" try to box or unbox, then it might be helpful
 * to specialize this struct for such type, without providing implementations of \b Write and
 * \b Read and with the latter to return \c void.
 *
 * <br><p>
 * \see More explanation and sample code is given in chapter
 *      \ref alib_boxing_customizing "7. Customizing Boxing" of the
 *      \ref alib_mod_boxing "Programmer's Manual" of module \alib_boxing_nl.
 *
 * @tparam TBoxable    The source type to customize boxing for.
 * @tparam TEnableIf   Optional TMP parameter to allow conditional specializations.
 * ************************************************************************************************/
template<typename TBoxable, typename TEnableIf= void>
struct T_Boxer
{
    /**
     * Defines the mapped type. With specializations, that type has to be wrapped in either
     * \alib{boxing;TMappedTo;TMappedTo<T>} or \alib{boxing;TMappedTo;TMappedToArrayOf<T>}.
     * Special designator types \alib{boxing;detail::TDefaultBoxing} and \alib{boxing;detail::TNotBoxable}
     * may be wrapped, to denote corresponding behavior.
     *
     * The default implementation specifies designator type \b TDefaultBoxing, which
     * disables custom boxing.
     */
    using   Mapping=      TMappedTo<detail::TDefaultBoxing>;
 
 
    /**
     * Used for boxing a value, precisely writing the boxable portion of a type into
     * field \alib{boxing;Box::data}, which is given with parameter \p{target}.<br>
     * The default implementation of this struct implements this method as follows:
     * \snippet "alib/boxing/typetraits.inl"  DOX_ALIB_BOXING_T_BOXER_WRITE
     *
     * This implementation leverages the TMP-enabled overloads \alib{boxing;Placeholder::Write}
     * and is often all that is needed with custom specializations.
     *
     * \see
     *   A possible alternative declaration (signature) of this method is explained with manual
     *   chapter \ref alib_boxing_more_opt_constexpr.
     *
     * @param target The placeholder of the destination box.
     * @param value  The value to that is to be boxed.
     */
    DOX_MARKER([DOX_ALIB_BOXING_T_BOXER_WRITE])
    static void  Write( Placeholder& target,  const TBoxable& value )
    {
        target.Write( value );
    }
    DOX_MARKER([DOX_ALIB_BOXING_T_BOXER_WRITE])
 
    /**
     * Used for unboxing a value, precisely reading the contents of field \alib{boxing;Box::data},
     * which is given with parameter \p{src} and creating a value of type \p{TBoxable} from
     * that.<br>
     * The default implementation of this struct implements this method as follows:
     * \snippet "alib/boxing/typetraits.inl"  DOX_ALIB_BOXING_T_BOXER_READ
     *
     * This implementation leverages the TMP-enabled overloads \alib{boxing;Placeholder::Read}
     * and is often all that is needed with custom specializations.
     *
     * If a different type than \p{TBoxable} is returned, then that source type is not unboxable.
     * To intend such behavior, for example because \p{TBoxable} is mapped to a reduced type
     * and therefore unboxing is not possible, specializations may declare return type
     * \c void and omit a definition of this method.<br>
     * With TMP enabled customizations, also other return types may given, which likewise denote
     * an unboxable source type. A sample of that is given with Programmer's Manual chapter
     * \ref alib_boxing_customizing_conditional.
     *
     *
     * @param src   The Placeholder to unbox the data from
     * @return \c The unboxed object.
     */
    static
    ATMP_IF_T_F( !std::is_abstract<TBoxable>::value, TBoxable, TBoxable& )
    Read( const Placeholder& src)
    {
DOX_MARKER([DOX_ALIB_BOXING_T_BOXER_READ])
return src.Read<TBoxable>();
DOX_MARKER([DOX_ALIB_BOXING_T_BOXER_READ])
    }
 
}; // T_Boxer
 
// ########################      critical  T_Boxer  specializations     ###########################
#if !defined(ALIB_DOX)
 
// This is necessary for types that can't be used as return type in any way, for example
// types with extents, functions, etc.
template<typename TBoxable>  struct T_Boxer<TBoxable,
ATMP_VOID_IF( ATMP_IS_ARR( TBoxable ) || std::is_function<TBoxable>::value )    >
{
    using          Mapping=  TMappedTo<detail::TDefaultBoxing>;
    static void    Write( Placeholder& target,  TBoxable& value );
    static void    Read ( const Placeholder& src);
};
 
// void (needed to pass TMP stuff)
template<> struct T_Boxer<void>
{
    using          Mapping=  TMappedTo<detail::TDefaultBoxing>;
    static void    Write( Placeholder& target,  const void* value );
    static void*   Read ( const Placeholder& src);
};
 
#endif
 
/** ************************************************************************************************
 * This specializable TMP struct must be set for custom types, if the following applies:
 * - A custom boxing implements \alib{boxing;T_Boxer::Write} in a way that a different number
 *   of bytes are used in union \alib{boxing;Placeholder} than the \c sizeof() operator reports
 *   on the mapped type's size.
 * - if the standard copy constructor (used with default boxing) writes a different size.
 * - One of the above and no specialized version of both box-functions \alib{boxing;FHashcode}
 *   or \alib{boxing;FEquals} are set.
 *
 * <b>Background:</b><br>
 * The default implementations of \alib{boxing;FHashcode} and \alib{boxing;FEquals}
 * must use the first N "relevant" bytes of the placeholder only. The non-relevant bytes are
 * not written and therefore must not be taken into account.<br>
 * To receive the number of relevant bytes, they invoke \alib{boxing;Box::GetPlaceholderUsageLength}
 * (at run-time). This value is set at compile-time with the creation of a mapped type's \e vtable.
 * While for array types, the value is set to the overall size of union \alib{boxing;Placeholder},
 * for non-array types, the value of this TMP struct is used.
 *
 * It might be surprising, but a built-in specialization exists for even a C++ fundamental type
 * <c>long double</c>, which is dependent on the compiler/platform.
 * For example, on GNU/Linux 64-bit, GCC reports \c 16 with <c>sizeof(long double)</c>.
 * However, if a <c>long double</c> value is copied, e.g with:
 *
 *      *pointerToLongDouble= 3.14L;
 *
 * then only 10 bytes are written. The reason for this is that <c>sizeof</c> reports the size
 * needed for alignment when placed in an array of that type.
 * In the case of \alib_boxing_nl, 6 bytes of the placeholder remain random and therefore
 * must not be used for hashing or testing values on equality.
 *
 * @tparam TMappedPlain The mapped type to modify relevant placeholder length for \b FHashcode
 *                      and \b FEquals implementation.
 **************************************************************************************************/
template<typename TMappedPlain> struct T_SizeInPlaceholder
{
    /** The size used with the placeholder */
    static constexpr unsigned int value= sizeof(TMappedPlain);
};
 
#if !defined(ALIB_DOX)
    template<> struct T_SizeInPlaceholder<long double> { static constexpr unsigned int value= ALIB_SIZEOF_LONGDOUBLE_WRITTEN;  };
#endif
 
 
/** ************************************************************************************************
 * Helper struct that inherits \c std::true_type if boxing is customized for
 * type \p{T}, otherwise \c std::false_type.
 *
 * \see
 *   Helpers \alib{boxing;TT_IsUnboxable}, \alib{boxing;TT_IsLocked} and
 *   \alib{boxing;TT_IsNotBoxable}.
 *
 * @tparam T         The type to check.
 * @tparam TEnableIf Used for conditional specializations of this struct.
 * ************************************************************************************************/
template<typename T, typename TEnableIf= void> struct TT_IsCustomized          : std::true_type  {};
 
#if !defined(ALIB_DOX)
 
// besides checking T_Boxer<T>, in the case a pointer is given, we also have to check
// T_Boxer for the type that results when
// - the pointer is removed and then
// - a const is removed and finally
// - the pointer is added again. Otherwise "const T*" is not deferred to "T*"
 
template<typename T> struct TT_IsCustomized  <T, ATMP_VOID_IF(
  !ATMP_IS_PTR(T) && ATMP_EQ(detail::TDefaultBoxing, typename T_Boxer<          T  >::Mapping::Type)
                                                                   )>          : std::false_type {};
 
template<typename T> struct TT_IsCustomized  <T, ATMP_VOID_IF(
   ATMP_IS_PTR(T) && ATMP_EQ(detail::TDefaultBoxing, typename T_Boxer<ATMP_RCVP(T)*>::Mapping::Type)
                                                                   )>          : std::false_type {};
 
#endif
 
/** ************************************************************************************************
 * Helper struct that inherits \c std::true_type if customized boxing is in place
 * that disallows unboxing, otherwise \c std::false_type.
 *
 * This struct is strict in the following sense: It is of \c std::false type, if given \p{T} is a
 * non-customized value type \b TV, while the corresponding pointer type \b TV* type is locked - and
 * vice versa.
 * Note that in these two cases, the type is still not unboxable because it is locked through the
 * corresponding other customization.
 *
 * This behavior is intended and needed internally.
 *
 * \note
 *   Unboxing of a type is disabled, if method \alib{boxing;T_Boxer::Read} of a specialized
 *   boxer is declared to return \c void.
 *
 * \see
 *   \alib{boxing;TT_IsUnboxable} for an alternative that is of \c std::true_type exactly
 *   if a type can not be unboxed and methods \alib{boxing;Box::IsType} and \alib{boxing;Box::Unbox}
 *   fail to compile with that type.
 *
 * @tparam T         The type to check.
 * @tparam TEnableIf Used for conditional specializations of this struct.
 * ************************************************************************************************/
template<typename T, typename TEnableIf= void> struct TT_IsLocked              : std::false_type {};
 
#if !defined(ALIB_DOX)
 
template<typename T                          > struct TT_IsLocked<T,
ATMP_VOID_IF( !ATMP_EQ(T, ATMP_RR(decltype(T_Boxer<T>::Read(std::declval<Placeholder>())) ) ) )
                                                                    >          : std::true_type  {};
#endif
 
/** ************************************************************************************************
 * Helper struct that inherits \c std::true_type, if
 *
 * - boxing was customized for the given type and \alib{boxing;detail::TNotBoxable} was given as
 *   mapped type, or
 * - given type is a value type, no customization is given for it, while the corresponding
 *   pointer type has customized boxing with mapped type being \alib{boxing;detail::TNotBoxable}, or
 * - given type is a pointer  type, no customization is given for it, while the corresponding
 *   value type has customized boxing with mapped type being \alib{boxing;detail::TNotBoxable}.
 *
 * If a type is not boxable, it can be neither boxed nor unboxed.
 *
 * \see
 *   Helpers \alib{boxing;TT_IsCustomized}, \alib{boxing;TT_IsLocked} and
 *   \alib{boxing;TT_IsUnboxable}.
 *
 * @tparam T         The type to check.
 * @tparam TEnableIf Used for conditional specializations of this struct.
 * ************************************************************************************************/
template<typename T, typename TEnableIf= void> struct TT_IsNotBoxable          : std::false_type {};
 
#if !defined(ALIB_DOX)
 
template<typename T>
struct TT_IsNotBoxable<T, typename std::enable_if<
      ATMP_EQ(detail::TNotBoxable, typename T_Boxer<T>::Mapping::Type)
|| (    !TT_IsCustomized<T>::value
     && (     (     !ATMP_IS_PTR(T)
                &&   ATMP_EQ(detail::TNotBoxable   , typename T_Boxer<        T*>::Mapping::Type) )
          ||  (      ATMP_IS_PTR(T)
                &&   ATMP_EQ(detail::TNotBoxable   , typename T_Boxer<ATMP_RP(T)>::Mapping::Type) )
        )
   )
                                                   >::type>                    : std::true_type  {};
 
#endif
 
 
/** ************************************************************************************************
 * This type is of \c std::true_type exactly if a type can not be unboxed and methods
 * \alib{boxing;Box::IsType} and \alib{boxing;Box::Unbox} will fail to compile with that type.
 *
 * With default boxing, one of the types \b T and \b T* are unboxable (depending on value type
 * size and whether the type is copy constructible and trivially destructible).
 *
 * If custom boxing for either or both of types \b T and \b T* is in place, then the given type is
 * not unboxable if:
 * - customization is not in place for the version passed (value or pointer).
 * - customization is in place for the given type, but \alib{boxing;TT_IsLocked} is of
 *   \c std::true_type.
 * - The type is mapped to \alib{boxing;detail::TNotBoxable}.
 *
 * \see
 *   Helpers \alib{boxing;TT_IsCustomized}, \alib{boxing;TT_IsLocked} and
 *   \alib{boxing;TT_IsNotBoxable}.
 *
 * @tparam T         The type to check.
 * @tparam TEnableIf Helper type for implementing specializations of this struct.
 * ************************************************************************************************/
template<typename T, typename TEnableIf=void>
struct   TT_IsUnboxable                                                        : std::false_type {};
 
#if !defined(ALIB_DOX)
 
// default boxing
template<typename T>
struct   TT_IsUnboxable<T, typename std::enable_if<
 
   !TT_IsCustomized<ATMP_RP(T) >::value
&& !TT_IsCustomized<ATMP_RP(T)*>::value
&&    static_cast<bool>(  ATMP_IS_PTR(T) )
   == static_cast<bool>(     ( sizeof(Placeholder) <  sizeof(ATMP_RCVP(T))  )
                         ||  !std::is_copy_constructible    <ATMP_RCVP(T)>::value
                         ||  !std::is_trivially_destructible<ATMP_RCVP(T)>::value )
 
                                                  >::type>                     : std::true_type  {};
 
 
// custom boxing
template<typename T>
struct   TT_IsUnboxable<T, typename std::enable_if<
    TT_IsCustomized<T>::value
&& !TT_IsLocked    <T>::value
&& !TT_IsNotBoxable<T>::value
                                                  >::type>                     : std::true_type  {};
 
 
#endif
 
}} // namespace [alib::boxing]
 
//##################################################################################################
//#######################################     Macros     ###########################################
//##################################################################################################
 
#define ALIB_BOXING_CUSTOMIZE(TSource, TTarget, ...)                                               \
namespace alib::boxing {                                                                           \
template<>  struct T_Boxer<TSource>                                                                \
{                                                                                                  \
    using                       Mapping=    TMappedTo<TTarget>;                                    \
                                __VA_ARGS__                                                        \
}; }                                                                                             \
 
#define ALIB_BOXING_CUSTOMIZE_ARRAY_TYPE(TSource, TElement, ...)                                   \
namespace alib::boxing {                                                                           \
template<>  struct T_Boxer<TSource>                                                                \
{                                                                                                  \
    using                       Mapping=    TMappedToArrayOf<TElement>;                            \
                                __VA_ARGS__                                                        \
}; }
 
#define ALIB_BOXING_CUSTOMIZE_TYPE_MAPPING(TSource, TTarget)                                       \
namespace alib::boxing {                                                                           \
template<>  struct T_Boxer<TSource>                                                                \
{ using                         Mapping=    TMappedTo<TTarget>;                                    \
  static void                   Write( Placeholder& target,  TSource const & value )  { target.Write( static_cast<TTarget>( value ) );      } \
  static TSource                Read (const Placeholder& src)                         { return static_cast<TSource>(src.Read<TTarget>());   } \
}; }
 
#define ALIB_BOXING_CUSTOMIZE_TYPE_MAPPING_CONSTEXPR(TSource, TTarget)                             \
namespace alib::boxing {                                                                           \
template<>  struct T_Boxer<TSource>                                                                \
{ using                         Mapping=    TMappedTo<TTarget>;                                    \
  static constexpr Placeholder  Write(  TSource const & value )   { return Placeholder( static_cast<TTarget>( value ) );} \
  static TSource                Read (const Placeholder& src)     { return static_cast<TSource>(src.Read<TTarget>()   );} \
}; }
 
 
#define ALIB_BOXING_CUSTOMIZE_NOT_UNBOXABLE(TSource, TTarget)                                      \
namespace alib::boxing {                                                                           \
template<>  struct T_Boxer<TSource>                                                                \
{ using                         Mapping=    TMappedTo<TTarget>;                                    \
  static void                   Write( Placeholder& target,  TSource const & value )  { target.Write( static_cast<typename Mapping::Type>( value ) ); } \
  static void                   Read( const Placeholder& src);                                     \
}; }
 
#define ALIB_BOXING_CUSTOMIZE_NOT_UNBOXABLE_CONSTEXPR(TSource, TTarget)                            \
namespace alib::boxing {                                                                           \
template<>  struct T_Boxer<TSource>                                                                \
{ using                         Mapping=    TMappedTo<TTarget>;                                    \
  static constexpr Placeholder  Write(  TSource const & value )   { return Placeholder( static_cast<typename Mapping::Type>( value ) ); } \
  static void                   Read( const Placeholder& src);                                     \
}; }
 
 
#define ALIB_BOXING_CUSTOMIZE_ARRAY_TYPE_NON_UNBOXABLE(TSource, TElement, ...)                     \
namespace alib::boxing {                                                                           \
template<>  struct T_Boxer<TSource>                                                                \
{   using                       Mapping=    TMappedToArrayOf<TElement>;                            \
    __VA_ARGS__                                                                                    \
    static void                 Read( const Placeholder& src);                                     \
}; }
 
 
#define ALIB_BOXING_CUSTOMIZE_DENY_BOXING(TSource)                                                 \
namespace alib::boxing {                                                                           \
template<>  struct T_Boxer<TSource>                                                                \
{ using                         Mapping=    TMappedTo<detail::TNotBoxable>;                        \
  static void                   Write( Placeholder& target,  TSource const & value );              \
  static void                   Read ( const Placeholder& src);                                    \
}; }
 
#endif // HPP_ALIB_BOXING_TYPETRAITS