This class is useful to pass and accept enum values of arbitrary C++ scoped enum types. Based on class Box, all interfaces are inherited, including type guessing and unboxing.
In the constructor, enum elements of an arbitrary type are accepted. The element's underlying integral value is boxed, and thus run-time type-information is added. Having the "original" element stored in protected base class Box, has the following advantages:
- Note
- The implementation of this class, by deriving from class Box, introduces a small memory overhead (usually 8 bytes per instance on 64-bit system), in respect to a possible alternative "direct" implementation. This is due to the fact that boxing allows one-dimensional array types to be boxed as well as scalar types - which is never the case with this class.
But the advantages of doing so certainly surpasses this small drawback.
-
Class Box is inherited
protected instead of public, to hide bigger portions of the base class's interface. While some functions are explicitly made visible with keyword using, for others, instances of this class have to be cast first. Casting is done with overloaded methods CastToBox.
Functors In Namespace std
Functors std::hash, std::equal_to and std::less are specialized for this type with the inclusion of the header-file ALib.Boxing.StdFunctors.H as documented with namespace alib::boxingcompatibility::std.
Friends
class Box
- See also
- With the inclusion of the module ALib EnumRecords in the ALib Build, the namespace functions GetRecord and TryRecord become available, which receive an enum record for a value of this class.
Definition at line 46 of file enum.inl.
|
| using | TypeCode = uinteger |
| | The type of type codes received with ExportType.
|
| template<typename TBoxable> |
| static constexpr detail::VTable * | getVTable () |
| Placeholder | data |
| | The data that we encapsulate.
|
| detail::VTable * | vtable |
| template<typename T> |
| constexpr void | initPH (const T &src) noexcept |
| | Box () noexcept |
| template<typename TBoxable> |
| constexpr | Box (const TBoxable &src) noexcept |
| | Box (TypeCode typeCode, const Placeholder &placeholder) noexcept |
| size_t | ArrayElementSize () const |
| template<typename TFDecl, typename... TArgs> |
| decltype(std::declval< typename TFDecl::Signature >()(std::declval< Box & >(), std::declval< TArgs >()...)) | Call (TArgs &&... args) |
| template<typename TFDecl, typename... TArgs> |
| decltype(std::declval< typename TFDecl::Signature >()(std::declval< Box & >(), std::declval< TArgs >()...)) | Call (TArgs &&... args) const |
| template<typename TFDecl, typename... TArgs> |
| decltype(std::declval< typename TFDecl::Signature >()(std::declval< Box & >(), std::declval< TArgs >()...)) | CallDirect (typename TFDecl::Signature function, TArgs &&... args) |
| template<typename TFDecl, typename... TArgs> |
| decltype(std::declval< typename TFDecl::Signature >()(std::declval< Box & >(), std::declval< TArgs >()...)) | CallDirect (typename TFDecl::Signature function, TArgs &&... args) const |
| void | Clone (MonoAllocator &memory) |
| Placeholder & | Data () |
| const Placeholder & | Data () const |
| const detail::VTable * | DbgGetVTable () const |
| const std::type_info & | ElementTypeID () const |
| TypeCode | ExportType () const |
| Placeholder | ExportValue () const |
| template<typename TFDecl> |
| TFDecl::Signature | GetFunction (Reach searchScope, bool isInvocation=false) const |
| unsigned | GetPlaceholderUsageLength () const |
| size_t | Hashcode () const |
| void | Import (TypeCode typeCode) |
| void | Import (TypeCode typeCode, const Placeholder &placeholder) |
| bool | IsArray () const |
| template<typename TElementType> |
| bool | IsArrayOf () const |
| bool | IsCharacter () const |
| bool | IsEnum () const |
| bool | IsFloatingPoint () const |
| bool | IsNotNull () const |
| bool | IsNull () const |
| bool | IsPointer () const |
| bool | IsSameType (const Box &other) const |
| bool | IsSignedIntegral () const |
| template<typename TBoxable> |
| bool | IsType () const |
| bool | IsUnsignedIntegral () const |
| | operator bool () const |
| bool | operator!= (const Box &rhs) const |
| bool | operator< (Box const &rhs) const |
| bool | operator<= (Box const &rhs) const |
| bool | operator== (Box const &rhs) const |
| bool | operator> (Box const &rhs) const |
| bool | operator>= (Box const &rhs) const |
| const std::type_info & | TypeID () const |
| template<typename TValue> |
| TValue | Unbox () |
| template<typename TElementType> |
| TElementType * | UnboxArray () const |
| wchar | UnboxCharacter () const |
| template<typename TElementType> |
| TElementType & | UnboxElement (integer idx) const |
| double | UnboxFloatingPoint () const |
| integer | UnboxLength () const |
| template<typename TPointer> |
| TPointer | UnboxMutable () const |
| integer | UnboxSignedIntegral () const |
| uinteger | UnboxUnsignedIntegral () const |
| bool alib::boxing::Enum::operator< |
( |
Enum const & | rhs | ) |
const |
|
inline |
Comparison operator with another Enum object. The sort order is primarily determined by the enum types that were boxed. If those are the same, then the underlying integral value of the enum elements is compared.
This leads to a nested sort order, with the type information being the outer order and the integral value of the enum being the inner one.
- Note
- It is a matter of the compiler how the outer sort of types is performed and thus this cannot be determined by the user code.
- Parameters
-
| rhs | The right-hand side argument of the comparison. |
- Returns
- If the encapsulated type of this instance is the same as that of rhs, this methods returns
true if Integral of this object is smaller than the one of rhs and otherwise false. If the types are not the same, than the result is dependent on the tool chain (compiler) used for compiling ALib.
Definition at line 199 of file enum.inl.
