FL_ALIGNAS() [5/5]

template<typename T, fl::size N>

struct fl::FL_ALIGNAS	(	alignof(T)	,
		alignof(fl::uptr) ? alignof(T) :alignof(fl::uptr)	)

Definition at line 1 of file vector.h.

                                                            : alignof(fl::uptr)) InlinedMemoryBlock {
    // using MemoryType = uinptr_t;
    typedef fl::uptr MemoryType;
    enum {
        kTotalBytes = N * sizeof(T),
        kExtraSize =
            (kTotalBytes % alignof(fl::max_align_t)) ? (alignof(fl::max_align_t) - (kTotalBytes % alignof(fl::max_align_t))) : 0,
        // Fix: calculate total bytes first, then convert to MemoryType units
        kTotalBytesAligned = kTotalBytes + kExtraSize,
        kBlockSize = (kTotalBytesAligned + sizeof(MemoryType) - 1) / sizeof(MemoryType),
    };
 
    InlinedMemoryBlock() FL_NOEXCEPT {
        fl::memset(mMemoryBlock, 0, sizeof(mMemoryBlock));
#ifdef FASTLED_TESTING
        __data = memory();
#endif
    }
 
    InlinedMemoryBlock(const InlinedMemoryBlock &other) FL_NOEXCEPT = default;
    InlinedMemoryBlock(InlinedMemoryBlock &&other) FL_NOEXCEPT = default;
 
    // u32 mRaw[N * sizeof(T)/sizeof(MemoryType) + kExtraSize];
    // align this to the size of MemoryType.
    // u32 mMemoryBlock[kTotalSize] = {0};
    MemoryType mMemoryBlock[kBlockSize];
 
    T *memory() FL_NOEXCEPT {
        MemoryType *begin = &mMemoryBlock[0];
        fl::uptr shift_up =
            fl::ptr_to_int(begin) & (sizeof(MemoryType) - 1);
        MemoryType *raw = begin + shift_up;
        return fl::bit_cast<T *>(raw);
    }
 
    const T *memory() const FL_NOEXCEPT {
        const MemoryType *begin = &mMemoryBlock[0];
        const fl::uptr shift_up =
            fl::ptr_to_int(begin) & (sizeof(MemoryType) - 1);
        const MemoryType *raw = begin + shift_up;
        return fl::bit_cast<const T *>(raw);
    }
 
#ifdef FASTLED_TESTING
    T *__data = nullptr;
#endif
};

References begin(), bit_cast(), FL_ALIGNAS(), FL_NOEXCEPT, memset(), and ptr_to_int().

Here is the call graph for this function: