Classes
struct	IndexTypeFromArgs

struct	IndexTypeFromArgs< Default, FirstInt, Ints... >

struct	Dyn

struct	IsProxyReferenceImpl

struct	IsProxyReferenceImpl< R, std::void_t< typename R::value_type, decltype(static_cast< typename R::value_type >(std::declval< R & >())), decltype(std::declval< R & >()=std::declval< typename R::value_type >())> >

struct	GetTagsImpl

struct	GetTagsImpl< Record< Fields... >, RecordCoord< FirstCoord, Coords... > >

struct	GetTagsImpl< ChildType[Count], RecordCoord< FirstCoord, Coords... > >

struct	GetTagsImpl< T, RecordCoord<> >

struct	GetTagImpl

struct	GetTagImpl< RecordDim, RecordCoord<> >

struct	FindFieldByTag

struct	GetCoordFromTagsImpl

struct	GetCoordFromTagsImpl< Record< Fields... >, RecordCoord< ResultCoords... >, FirstTag, Tags... >

struct	GetCoordFromTagsImpl< ChildType[Count], RecordCoord< ResultCoords... >, FirstTag, Tags... >

struct	GetCoordFromTagsImpl< RecordDim, RecordCoord >

struct	GetCoordFromTagsImpl< Record< Fields... >, RecordCoord<>, mp_list< Tags... > >

struct	GetCoordFromTagsImpl< ChildType[Count], RecordCoord<>, mp_list< Tags... > >

struct	GetCoordFromTagsImpl< Record< Fields... >, RecordCoord<>, RecordCoord< RCs... > >

struct	GetTypeImpl

struct	GetTypeImpl< Record< Children... >, RecordCoord< HeadCoord, TailCoords... > >

struct	GetTypeImpl< ChildType[N], RecordCoord< HeadCoord, TailCoords... > >

struct	GetTypeImpl< T, RecordCoord<> >

struct	LeafRecordCoordsImpl

struct	LeafRecordCoordsImpl< T, RecordCoord< RCs... > >

struct	LeafRecordCoordsImpl< Record< Fields... >, RecordCoord< RCs... > >

struct	LeafRecordCoordsImpl< Child[N], RecordCoord< RCs... > >

struct	FlattenRecordDimImpl

struct	FlattenRecordDimImpl< Record< Fields... > >

struct	FlattenRecordDimImpl< Child[N]>

struct	IndirectValue

struct	IsBoundedArray

struct	IsBoundedArray< T[N]>

struct	TransformLeavesWithCoordImpl

struct	TransformLeavesWithCoordImpl< RecordCoord< Is... >, Record< Fields... >, TypeFunctor >

struct	TransformLeavesWithCoordImpl< RecordCoord< Is... >, Child[N], TypeFunctor >

struct	MakePassSecond

struct	IsConstant

struct	IsConstant< std::integral_constant< T, V > >

struct	BoxedValue

struct	BoxedValue< Constant< V >, I >

struct	mp_unwrap_values_into_impl

struct	mp_unwrap_values_into_impl< FromList< Values... >, ToList >

struct	ReplacePlaceholdersImpl

struct	ReplacePlaceholdersImpl< mp_arg< I >, Args... >

struct	ReplacePlaceholdersImpl< E< Ts... >, Args... >

struct	Assign

struct	PlusAssign

struct	MinusAssign

struct	MultiplyAssign

struct	DivideAssign

struct	ModuloAssign

struct	ValueOf

struct	ValueOf< T, std::enable_if_t< isRecordRef< T > > >

struct	ValueOf< T, std::enable_if_t< isProxyReference< T > > >

struct	ValueOf< T & >

struct	ReferenceTo

struct	ReferenceTo< T, std::enable_if_t< isRecordRef< T > &&!isOne< T > > >

struct	ReferenceTo< T, std::enable_if_t< isProxyReference< T > > >

struct	BindMakeSizedSimd

struct	SimdizeNImpl

struct	SimdizeNImpl< RecordDim, 1, MakeSizedSimd >

struct	SizeEqualTo

struct	TupleLeaf

struct	TupleLeaf< I, T, true >

struct	IsComputed

struct	IsComputed< Mapping, RecordCoord, std::void_t< decltype(Mapping::isComputed(RecordCoord{}))> >

Typedefs
template<typename FromList , template< auto... > class ToList>
using	mp_unwrap_values_into = typename mp_unwrap_values_into_impl< FromList, ToList >::type

template<typename Allocator , typename RecordDim >
using	AllocatorBlobType = decltype(std::declval< Allocator >()(std::integral_constant< std::size_t, alignOf< RecordDim > >{}, 0))

Functions
template<typename SizeType , SizeType Extent, std::size_t... Is>
constexpr auto	makeArrayExtents (std::index_sequence< Is... >)

template<typename RecordDim >
void	assertTrivialCopyable ()

template<typename MemcpyFunc = decltype(memcpy)>
void	parallelMemcpy (std::byte dst, const std::byte src, std::size_t size, std::size_t threadId=0, std::size_t threadCount=1, MemcpyFunc singleThreadMemcpy=memcpy)

template<typename TypeList >
constexpr auto	flatAlignOfImpl ()

template<typename TypeList , bool Align, bool IncludeTailPadding>
constexpr auto	sizeOfImpl () -> std::size_t

template<typename TypeList , std::size_t I, bool Align>
constexpr auto	offsetOfImplWorkaround () -> std::size_t

template<typename A , typename B >
auto	mergeRecordDimsImpl (mp_identity< A > a, mp_identity< B >)

template<typename A , std::size_t NA, typename B , std::size_t NB>
auto	mergeRecordDimsImpl ([[maybe_unused]] mp_identity< A[NA]> a, [[maybe_unused]] mp_identity< B[NB]> b)

template<typename... FieldsA>
auto	mergeRecordDimsImpl (mp_identity< Record< FieldsA... >> a, mp_identity< Record<>>)

template<typename... FieldsA, typename FieldB , typename... FieldsB, auto Pos = FindFieldByTag<Record<FieldsA...>, GetFieldTag<FieldB>>::value>
auto	mergeRecordDimsImpl (mp_identity< Record< FieldsA... >>, mp_identity< Record< FieldB, FieldsB... >>)

template<template< typename... > typename L, typename... T, typename F >
constexpr void	mp_for_each_inline_impl (L< T... >, F &&f)

template<std::size_t... Coords1, std::size_t... Coords2>
constexpr auto	recordCoordCommonPrefixIsBiggerImpl (RecordCoord< Coords1... >, RecordCoord< Coords2... >) -> bool

template<std::size_t... Coords1, std::size_t... Coords2>
constexpr auto	recordCoordCommonPrefixIsSameImpl (RecordCoord< Coords1... >, RecordCoord< Coords2... >) -> bool

template<typename Functor , typename LeftRecord , typename RightView , typename RightBoundRecordDim , bool RightOwnView>
auto	recordRefArithOperator (LeftRecord &left, const RecordRef< RightView, RightBoundRecordDim, RightOwnView > &right) -> LeftRecord &

template<typename Functor , typename LeftRecord , typename T >
auto	recordRefArithOperator (LeftRecord &left, const T &right) -> LeftRecord &

template<typename Functor , typename LeftRecord , typename RightView , typename RightBoundRecordDim , bool RightOwnView>
auto	recordRefRelOperator (const LeftRecord &left, const RecordRef< RightView, RightBoundRecordDim, RightOwnView > &right) -> bool

template<typename Functor , typename LeftRecord , typename T >
auto	recordRefRelOperator (const LeftRecord &left, const T &right) -> bool

template<typename ProxyReference , typename T , std::enable_if_t<!isRecordRef< std::decay_t< ProxyReference >>, int > = 0>
auto	asTupleImpl (ProxyReference &&leaf, T) -> ProxyReference

template<typename TWithOptionalConst , typename T , std::enable_if_t<!isRecordRef< std::decay_t< TWithOptionalConst >>, int > = 0>
auto	asTupleImpl (TWithOptionalConst &leaf, T) -> std::reference_wrapper< TWithOptionalConst >

template<typename RecordRef , typename T , std::size_t N, std::size_t... Is>
auto	asTupleImplForArray (RecordRef &&vd, T(&&)[N], std::index_sequence< Is... >)

template<typename RecordRef , typename T , std::size_t N>
auto	asTupleImpl (RecordRef &&vd, T(&&a)[N])

template<typename RecordRef , typename... Fields>
auto	asTupleImpl (RecordRef &&vd, Record< Fields... >)

template<typename ProxyReference , typename T , std::enable_if_t<!isRecordRef< std::decay_t< ProxyReference >>, int > = 0>
auto	asFlatTupleImpl (ProxyReference &&leaf, T) -> std::tuple< ProxyReference >

template<typename TWithOptionalConst , typename T , std::enable_if_t<!isRecordRef< std::decay_t< TWithOptionalConst >>, int > = 0>
auto	asFlatTupleImpl (TWithOptionalConst &leaf, T) -> std::tuple< TWithOptionalConst & >

template<typename RecordRef , typename T , std::size_t N, std::size_t... Is>
auto	asFlatTupleImplForArray (RecordRef &&vd, T(&&)[N], std::index_sequence< Is... >)

template<typename RecordRef , typename T , std::size_t N>
auto	asFlatTupleImpl (RecordRef &&vd, T(&&a)[N])

template<typename RecordRef , typename... Fields>
auto	asFlatTupleImpl (RecordRef &&vd, Record< Fields... >)

template<typename Tuple1 , typename Tuple2 , std::size_t... Is>
void	assignTuples (Tuple1 &&dst, Tuple2 &&src, std::index_sequence< Is... >)

template<typename T1 , typename T2 >
void	assignTupleElement (T1 &&dst, T2 &&src)

template<typename T , typename Tuple , std::size_t... Is>
auto	makeFromTuple (Tuple &&src, std::index_sequence< Is... >)

template<typename T , typename Simd , typename SrcRC , typename DstRC >
void	loadSimdFromField (const T &srcRef, Simd &dstSimd, SrcRC srcRC, DstRC dstRC)

template<typename Simd , typename TFwd , typename SrcRC , typename DstRC >
void	storeSimdToField (const Simd &srcSimd, TFwd &&dstRef, SrcRC srcRC, DstRC dstRC)

template<typename In , typename Out >
constexpr auto	constexprCopy (In f, In l, Out d) -> Out

template<class ForwardIt1 , class ForwardIt2 >
constexpr auto	constexprSearch (ForwardIt1 first, ForwardIt1 last, ForwardIt2 sFirst, ForwardIt2 sLast) -> ForwardIt1

template<class InputIt , class OutputIt , class T >
constexpr auto	constexprRemoveCopy (InputIt first, InputIt last, OutputIt d_first, const T &value) -> OutputIt

template<class InputIt , class T >
auto	constexprCount (InputIt first, InputIt last, const T &value) -> typename std::iterator_traits< InputIt >::difference_type

template<std::size_t NewSize, typename T , std::size_t N>
constexpr auto	resizeArray (Array< T, N > a)

template<typename T >
constexpr auto	typeNameAsArray ()

constexpr auto	isIdentChar (char c) -> bool

constexpr auto	intToStrSize (std::size_t s)

template<typename... Elements, std::size_t... Is>
constexpr auto	areEqual (const Tuple< Elements... > &a, const Tuple< Elements... > &b, std::index_sequence< Is... >) -> bool

template<typename Tuple1 , typename Tuple2 , size_t... Is1, size_t... Is2>
constexpr auto	tupleCatImpl (const Tuple1 &t1, const Tuple2 &t2, std::index_sequence< Is1... >, std::index_sequence< Is2... >)

template<std::size_t Pos, typename Tuple , typename Replacement , std::size_t... IsBefore, std::size_t... IsAfter>
constexpr auto	tupleReplaceImpl (Tuple &&tuple, Replacement &&replacement, std::index_sequence< IsBefore... >, std::index_sequence< IsAfter... >)

template<size_t... Is, typename... Elements, typename Functor >
constexpr auto	tupleTransformHelper (std::index_sequence< Is... >, const Tuple< Elements... > &tuple, const Functor &functor)

template<typename Allocator , typename Mapping , std::size_t... Is>
auto	makeBlobArray (const Allocator &alloc, const Mapping &mapping, std::integer_sequence< std::size_t, Is... >) -> Array< AllocatorBlobType< Allocator, typename Mapping::RecordDim >, Mapping::blobCount >

template<class T , class U >
constexpr auto &&	forward_like (U &&x) noexcept

template<typename Blobs , typename TransformBlobFunc , std::size_t... Is>
auto	makeTransformedBlobArray (Blobs &&blobs, const TransformBlobFunc &transformBlob, std::integer_sequence< std::size_t, Is... >)

Variables
constexpr auto	memcpy = [](void* dst, const void* src, std::size_t size) { std::memcpy(dst, src, size); }

constexpr auto	copyBlobWithMemcpy

template<typename Mapping >
constexpr std::size_t	aosoaLanes = 1

template<std::size_t I, typename RecordDim >
constexpr std::size_t	flatFieldCountBefore = 0

template<typename... Children>
constexpr std::size_t	flatFieldCountBefore< 0, Record< Children... > > = 0

template<std::size_t I, typename... Children>
constexpr std::size_t	flatFieldCountBefore< I, Record< Children... > >

template<typename T , typename = void>
constexpr auto	isTupleLike = false

template<typename... Ts>
constexpr auto	dependentFalse = false

template<typename T , typename SFINAE , typename... Args>
constexpr auto	isDirectListInitializableImpl = false

template<typename T , typename... Args>
constexpr auto	isDirectListInitializable = isDirectListInitializableImpl<T, void, Args...>

template<typename T , typename Tuple >
constexpr auto	isDirectListInitializableFromTuple = false

template<typename T , template< typename... > typename Tuple, typename... Args>
constexpr auto	isDirectListInitializableFromTuple< T, Tuple< Args... > > = isDirectListInitializable<T, Args...>

template<typename AoSMapping , typename ElementType , std::size_t Lanes>
constexpr auto	aosStridedIndices

template<typename T >
constexpr auto	typeNameStorage = typeNameAsArray<T>()

template<typename T >
constexpr auto	structNameStorage

template<typename RecordDim , std::size_t... Coords>
constexpr auto	recordCoordTagsStorage

Typedef Documentation

◆ AllocatorBlobType

template<typename Allocator , typename RecordDim >

using llama::internal::AllocatorBlobType = typedef decltype(std::declval<Allocator>()(std::integral_constant<std::size_t, alignOf<RecordDim> >{}, 0))

Definition at line 30 of file View.hpp.

◆ mp_unwrap_values_into

template<typename FromList , template< auto... > class ToList>

using llama::internal::mp_unwrap_values_into = typedef typename mp_unwrap_values_into_impl<FromList, ToList>::type

Definition at line 36 of file Meta.hpp.

Function Documentation

◆ areEqual()

template<typename... Elements, std::size_t... Is>

constexpr auto llama::internal::areEqual	(	const Tuple< Elements... > &	a,
		const Tuple< Elements... > &	b,
		std::index_sequence< Is... >
	)		-> bool

inlineconstexpr

Definition at line 157 of file Tuple.hpp.

◆ asFlatTupleImpl() [1/4]

template<typename ProxyReference , typename T , std::enable_if_t<!isRecordRef< std::decay_t< ProxyReference >>, int > = 0>

auto llama::internal::asFlatTupleImpl	(	ProxyReference &&	leaf,
		T
	)		-> std::tuple<ProxyReference>

inline

Definition at line 234 of file RecordRef.hpp.

◆ asFlatTupleImpl() [2/4]

template<typename RecordRef , typename... Fields>

auto llama::internal::asFlatTupleImpl	(	RecordRef &&	vd,
		Record< Fields... >
	)

inline

Definition at line 262 of file RecordRef.hpp.

◆ asFlatTupleImpl() [3/4]

template<typename RecordRef , typename T , std::size_t N>

auto llama::internal::asFlatTupleImpl	(	RecordRef &&	vd,
		T(&&)	a[N]
	)

inline

Definition at line 256 of file RecordRef.hpp.

◆ asFlatTupleImpl() [4/4]

template<typename TWithOptionalConst , typename T , std::enable_if_t<!isRecordRef< std::decay_t< TWithOptionalConst >>, int > = 0>

auto llama::internal::asFlatTupleImpl	(	TWithOptionalConst &	leaf,
		T
	)		-> std::tuple<TWithOptionalConst&>

inline

Definition at line 244 of file RecordRef.hpp.

◆ asFlatTupleImplForArray()

template<typename RecordRef , typename T , std::size_t N, std::size_t... Is>

auto llama::internal::asFlatTupleImplForArray	(	RecordRef &&	vd,
		T(&&)	[N],
		std::index_sequence< Is... >
	)

inline

Definition at line 250 of file RecordRef.hpp.

◆ assertTrivialCopyable()

template<typename RecordDim >

void llama::internal::assertTrivialCopyable ( )

Definition at line 18 of file Copy.hpp.

◆ assignTupleElement()

template<typename T1 , typename T2 >

void llama::internal::assignTupleElement	(	T1 &&	dst,
		T2 &&	src
	)

inline

Definition at line 283 of file RecordRef.hpp.

◆ assignTuples()

template<typename Tuple1 , typename Tuple2 , std::size_t... Is>

void llama::internal::assignTuples	(	Tuple1 &&	dst,
		Tuple2 &&	src,
		std::index_sequence< Is... >
	)

inline

Definition at line 299 of file RecordRef.hpp.

◆ asTupleImpl() [1/4]

template<typename ProxyReference , typename T , std::enable_if_t<!isRecordRef< std::decay_t< ProxyReference >>, int > = 0>

auto llama::internal::asTupleImpl	(	ProxyReference &&	leaf,
		T
	)		-> ProxyReference

inline

Definition at line 197 of file RecordRef.hpp.

◆ asTupleImpl() [2/4]

template<typename RecordRef , typename... Fields>

auto llama::internal::asTupleImpl	(	RecordRef &&	vd,
		Record< Fields... >
	)

inline

Definition at line 225 of file RecordRef.hpp.

◆ asTupleImpl() [3/4]

template<typename RecordRef , typename T , std::size_t N>

auto llama::internal::asTupleImpl	(	RecordRef &&	vd,
		T(&&)	a[N]
	)

inline

Definition at line 219 of file RecordRef.hpp.

◆ asTupleImpl() [4/4]

template<typename TWithOptionalConst , typename T , std::enable_if_t<!isRecordRef< std::decay_t< TWithOptionalConst >>, int > = 0>

auto llama::internal::asTupleImpl	(	TWithOptionalConst &	leaf,
		T
	)		-> std::reference_wrapper<TWithOptionalConst>

inline

Definition at line 206 of file RecordRef.hpp.

◆ asTupleImplForArray()

template<typename RecordRef , typename T , std::size_t N, std::size_t... Is>

auto llama::internal::asTupleImplForArray	(	RecordRef &&	vd,
		T(&&)	[N],
		std::index_sequence< Is... >
	)

inline

Definition at line 213 of file RecordRef.hpp.

◆ constexprCopy()

template<typename In , typename Out >

constexpr auto llama::internal::constexprCopy	(	In	f,
		In	l,
		Out	d
	)		-> Out

constexpr

Definition at line 17 of file StructName.hpp.

◆ constexprCount()

template<class InputIt , class T >

auto llama::internal::constexprCount	(	InputIt	first,
		InputIt	last,
		const T &	value
	)		-> typename std::iterator_traits<InputIt>::difference_type

Definition at line 64 of file StructName.hpp.

◆ constexprRemoveCopy()

template<class InputIt , class OutputIt , class T >

constexpr auto llama::internal::constexprRemoveCopy	(	InputIt	first,
		InputIt	last,
		OutputIt	d_first,
		const T &	value
	)		-> OutputIt

constexpr

Definition at line 49 of file StructName.hpp.

◆ constexprSearch()

template<class ForwardIt1 , class ForwardIt2 >

constexpr auto llama::internal::constexprSearch	(	ForwardIt1	first,
		ForwardIt1	last,
		ForwardIt2	sFirst,
		ForwardIt2	sLast
	)		-> ForwardIt1

constexpr

Definition at line 27 of file StructName.hpp.

◆ flatAlignOfImpl()

template<typename TypeList >

constexpr auto llama::internal::flatAlignOfImpl ( )

constexpr

Definition at line 537 of file Core.hpp.

◆ forward_like()

template<class T , class U >

constexpr auto&& llama::internal::forward_like ( U && x )

inlineconstexprnoexcept

Definition at line 613 of file View.hpp.

◆ intToStrSize()

constexpr auto llama::internal::intToStrSize ( std::size_t s )

constexpr

Definition at line 285 of file StructName.hpp.

◆ isIdentChar()

constexpr auto llama::internal::isIdentChar ( char c ) -> bool

constexpr

Definition at line 206 of file StructName.hpp.

◆ loadSimdFromField()

template<typename T , typename Simd , typename SrcRC , typename DstRC >

void llama::internal::loadSimdFromField	(	const T &	srcRef,
		Simd &	dstSimd,
		SrcRC	srcRC,
		DstRC	dstRC
	)

inline

Definition at line 209 of file Simd.hpp.

◆ makeArrayExtents()

template<typename SizeType , SizeType Extent, std::size_t... Is>

constexpr auto llama::internal::makeArrayExtents ( std::index_sequence< Is... > )

constexpr

Definition at line 232 of file ArrayExtents.hpp.

◆ makeBlobArray()

template<typename Allocator , typename Mapping , std::size_t... Is>

auto llama::internal::makeBlobArray	(	const Allocator &	alloc,
		const Mapping &	mapping,
		std::integer_sequence< std::size_t, Is... >
	)		-> Array<AllocatorBlobType<Allocator, typename Mapping::RecordDim>, Mapping::blobCount>

inline

Definition at line 34 of file View.hpp.

◆ makeFromTuple()

template<typename T , typename Tuple , std::size_t... Is>

auto llama::internal::makeFromTuple	(	Tuple &&	src,
		std::index_sequence< Is... >
	)

inline

Definition at line 307 of file RecordRef.hpp.

◆ makeTransformedBlobArray()

template<typename Blobs , typename TransformBlobFunc , std::size_t... Is>

auto llama::internal::makeTransformedBlobArray	(	Blobs &&	blobs,
		const TransformBlobFunc &	transformBlob,
		std::integer_sequence< std::size_t, Is... >
	)

inline

Definition at line 634 of file View.hpp.

◆ mergeRecordDimsImpl() [1/4]

template<typename A , std::size_t NA, typename B , std::size_t NB>

auto llama::internal::mergeRecordDimsImpl	(	[[maybe_unused] ] mp_identity< A[NA]>	a,
		[[maybe_unused] ] mp_identity< B[NB]>	b
	)

Definition at line 773 of file Core.hpp.

◆ mergeRecordDimsImpl() [2/4]

template<typename A , typename B >

auto llama::internal::mergeRecordDimsImpl	(	mp_identity< A >	a,
		mp_identity< B >
	)

Definition at line 766 of file Core.hpp.

◆ mergeRecordDimsImpl() [3/4]

template<typename... FieldsA>

auto llama::internal::mergeRecordDimsImpl	(	mp_identity< Record< FieldsA... >>	a,
		mp_identity< Record<>>
	)

Definition at line 783 of file Core.hpp.

◆ mergeRecordDimsImpl() [4/4]

template<typename... FieldsA, typename FieldB , typename... FieldsB, auto Pos = FindFieldByTag<Record<FieldsA...>, GetFieldTag<FieldB>>::value>

auto llama::internal::mergeRecordDimsImpl	(	mp_identity< Record< FieldsA... >>	,
		mp_identity< Record< FieldB, FieldsB... >>
	)

Definition at line 793 of file Core.hpp.

◆ mp_for_each_inline_impl()

template<template< typename... > typename L, typename... T, typename F >

constexpr void llama::internal::mp_for_each_inline_impl	(	L< T... >	,
		F &&	f
	)

inlineconstexpr

Definition at line 20 of file Meta.hpp.

◆ offsetOfImplWorkaround()

template<typename TypeList , std::size_t I, bool Align>

constexpr auto llama::internal::offsetOfImplWorkaround ( ) -> std::size_t

constexpr

Definition at line 641 of file Core.hpp.

◆ parallelMemcpy()

template<typename MemcpyFunc = decltype(memcpy)>

void llama::internal::parallelMemcpy	(	std::byte *	dst,
		const std::byte *	src,
		std::size_t	size,
		std::size_t	threadId = `0`,
		std::size_t	threadCount = `1`,
		MemcpyFunc	singleThreadMemcpy = `memcpy`
	)

Definition at line 35 of file Copy.hpp.

◆ recordCoordCommonPrefixIsBiggerImpl()

template<std::size_t... Coords1, std::size_t... Coords2>

constexpr auto llama::internal::recordCoordCommonPrefixIsBiggerImpl	(	RecordCoord< Coords1... >	,
		RecordCoord< Coords2... >
	)		-> bool

constexpr

Definition at line 134 of file RecordCoord.hpp.

◆ recordCoordCommonPrefixIsSameImpl()

template<std::size_t... Coords1, std::size_t... Coords2>

constexpr auto llama::internal::recordCoordCommonPrefixIsSameImpl	(	RecordCoord< Coords1... >	,
		RecordCoord< Coords2... >
	)		-> bool

constexpr

Definition at line 159 of file RecordCoord.hpp.

◆ recordRefArithOperator() [1/2]

template<typename Functor , typename LeftRecord , typename RightView , typename RightBoundRecordDim , bool RightOwnView>

auto llama::internal::recordRefArithOperator	(	LeftRecord &	left,
		const RecordRef< RightView, RightBoundRecordDim, RightOwnView > &	right
	)		-> LeftRecord&

inline

Definition at line 49 of file RecordRef.hpp.

◆ recordRefArithOperator() [2/2]

template<typename Functor , typename LeftRecord , typename T >

auto llama::internal::recordRefArithOperator	(	LeftRecord &	left,
		const T &	right
	)		-> LeftRecord&

inline

Definition at line 83 of file RecordRef.hpp.

◆ recordRefRelOperator() [1/2]

template<typename Functor , typename LeftRecord , typename RightView , typename RightBoundRecordDim , bool RightOwnView>

auto llama::internal::recordRefRelOperator	(	const LeftRecord &	left,
		const RecordRef< RightView, RightBoundRecordDim, RightOwnView > &	right
	)		-> bool

inline

Definition at line 96 of file RecordRef.hpp.

◆ recordRefRelOperator() [2/2]

template<typename Functor , typename LeftRecord , typename T >

auto llama::internal::recordRefRelOperator	(	const LeftRecord &	left,
		const T &	right
	)		-> bool

inline

Definition at line 131 of file RecordRef.hpp.

◆ resizeArray()

template<std::size_t NewSize, typename T , std::size_t N>

constexpr auto llama::internal::resizeArray ( Array< T, N > a )

constexpr

Definition at line 79 of file StructName.hpp.

◆ sizeOfImpl()

template<typename TypeList , bool Align, bool IncludeTailPadding>

constexpr auto llama::internal::sizeOfImpl ( ) -> std::size_t

constexpr

Definition at line 586 of file Core.hpp.

◆ storeSimdToField()

template<typename Simd , typename TFwd , typename SrcRC , typename DstRC >

void llama::internal::storeSimdToField	(	const Simd &	srcSimd,
		TFwd &&	dstRef,
		SrcRC	srcRC,
		DstRC	dstRC
	)

inline

Definition at line 255 of file Simd.hpp.

◆ tupleCatImpl()

template<typename Tuple1 , typename Tuple2 , size_t... Is1, size_t... Is2>

constexpr auto llama::internal::tupleCatImpl	(	const Tuple1 &	t1,
		const Tuple2 &	t2,
		std::index_sequence< Is1... >	,
		std::index_sequence< Is2... >
	)

inlineconstexpr

Definition at line 189 of file Tuple.hpp.

◆ tupleReplaceImpl()

template<std::size_t Pos, typename Tuple , typename Replacement , std::size_t... IsBefore, std::size_t... IsAfter>

constexpr auto llama::internal::tupleReplaceImpl	(	Tuple &&	tuple,
		Replacement &&	replacement,
		std::index_sequence< IsBefore... >	,
		std::index_sequence< IsAfter... >
	)

inlineconstexpr

Definition at line 218 of file Tuple.hpp.

◆ tupleTransformHelper()

template<size_t... Is, typename... Elements, typename Functor >

constexpr auto llama::internal::tupleTransformHelper	(	std::index_sequence< Is... >	,
		const Tuple< Elements... > &	tuple,
		const Functor &	functor
	)

inlineconstexpr

Definition at line 246 of file Tuple.hpp.

◆ typeNameAsArray()

template<typename T >

constexpr auto llama::internal::typeNameAsArray ( )

constexpr

Definition at line 87 of file StructName.hpp.

Variable Documentation

◆ aosoaLanes

template<typename Mapping >

constexpr std::size_t llama::internal::aosoaLanes = 1

inlineconstexpr

Definition at line 156 of file Copy.hpp.

◆ aosStridedIndices

template<typename AoSMapping , typename ElementType , std::size_t Lanes>

constexpr auto llama::internal::aosStridedIndices

inlineconstexpr

Initial value:

= []()
        {
            auto stride = flatSizeOf<
                              typename AoSMapping::Permuter::FlatRecordDim,
                              AoSMapping::fieldAlignment == llama::mapping::FieldAlignment::Align>
                / sizeof(ElementType);
            std::array<int, Lanes> indices{};
            for(int i = 0; i < static_cast<int>(Lanes); i++)
                indices[i] = i * stride;
            return indices;
        }()

Definition at line 196 of file Simd.hpp.

◆ copyBlobWithMemcpy

constexpr auto llama::internal::copyBlobWithMemcpy

inlineconstexpr

Initial value:

= [](const auto& src, auto& dst, std::size_t size)
        {
            static_assert(std::is_trivially_copyable_v<std::remove_reference_t<decltype(*&src[0])>>);
            static_assert(std::is_trivially_copyable_v<std::remove_reference_t<decltype(*&dst[0])>>);
            std::memcpy(&dst[0], &src[0], size);
        }

Definition at line 83 of file Copy.hpp.

◆ dependentFalse

template<typename... Ts>

constexpr auto llama::internal::dependentFalse = false

inlineconstexpr

Definition at line 277 of file RecordRef.hpp.

◆ flatFieldCountBefore

template<std::size_t I, typename RecordDim >

constexpr std::size_t llama::internal::flatFieldCountBefore = 0

inlineconstexpr

Definition at line 500 of file Core.hpp.

◆ flatFieldCountBefore< 0, Record< Children... > >

template<typename... Children>

constexpr std::size_t llama::internal::flatFieldCountBefore< 0, Record< Children... > > = 0

inlineconstexpr

Definition at line 503 of file Core.hpp.

◆ flatFieldCountBefore< I, Record< Children... > >

template<std::size_t I, typename... Children>

constexpr std::size_t llama::internal::flatFieldCountBefore< I, Record< Children... > >

inlineconstexpr

Initial value:

= flatFieldCountBefore<I - 1, Record<Children...>>

+ flatFieldCount<GetFieldType<mp_at_c<Record<Children...>, I - 1>>>

llama::internal::flatFieldCountBefore

constexpr std::size_t flatFieldCountBefore

Definition: Core.hpp:500

llama::GetFieldType

mp_second< Field > GetFieldType

Get the type from a Field.

Definition: Core.hpp:191

llama::flatFieldCount

constexpr std::size_t flatFieldCount

The total number of fields in the recursively expanded record dimension.

Definition: Core.hpp:486

Definition at line 508 of file Core.hpp.

◆ isDirectListInitializable

template<typename T , typename... Args>

constexpr auto llama::internal::isDirectListInitializable = isDirectListInitializableImpl<T, void, Args...>

inlineconstexpr

Definition at line 322 of file RecordRef.hpp.

◆ isDirectListInitializableFromTuple

template<typename T , typename Tuple >

constexpr auto llama::internal::isDirectListInitializableFromTuple = false

inlineconstexpr

Definition at line 325 of file RecordRef.hpp.

◆ isDirectListInitializableFromTuple< T, Tuple< Args... > >

template<typename T , template< typename... > typename Tuple, typename... Args>

constexpr auto llama::internal::isDirectListInitializableFromTuple< T, Tuple< Args... > > = isDirectListInitializable<T, Args...>

inlineconstexpr

Definition at line 328 of file RecordRef.hpp.

◆ isDirectListInitializableImpl

template<typename T , typename SFINAE , typename... Args>

constexpr auto llama::internal::isDirectListInitializableImpl = false

inlineconstexpr

Definition at line 314 of file RecordRef.hpp.

◆ isTupleLike

template<typename T , typename = void>

constexpr auto llama::internal::isTupleLike = false

inlineconstexpr

Definition at line 268 of file RecordRef.hpp.

◆ memcpy

constexpr auto llama::internal::memcpy = [](void* dst, const void* src, std::size_t size) { std::memcpy(dst, src, size); }

inlineconstexpr

Definition at line 31 of file Copy.hpp.

◆ recordCoordTagsStorage

template<typename RecordDim , std::size_t... Coords>

constexpr auto llama::internal::recordCoordTagsStorage

inlineconstexpr

Definition at line 297 of file StructName.hpp.

◆ structNameStorage

template<typename T >

constexpr auto llama::internal::structNameStorage

inlineconstexpr

Definition at line 220 of file StructName.hpp.

◆ typeNameStorage

template<typename T >

constexpr auto llama::internal::typeNameStorage = typeNameAsArray<T>()

inlineconstexpr

Definition at line 193 of file StructName.hpp.

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ AllocatorBlobType

◆ mp_unwrap_values_into

Function Documentation

◆ areEqual()

◆ asFlatTupleImpl() [1/4]

◆ asFlatTupleImpl() [2/4]

◆ asFlatTupleImpl() [3/4]

◆ asFlatTupleImpl() [4/4]

◆ asFlatTupleImplForArray()

◆ assertTrivialCopyable()

◆ assignTupleElement()

◆ assignTuples()

◆ asTupleImpl() [1/4]

◆ asTupleImpl() [2/4]

◆ asTupleImpl() [3/4]

◆ asTupleImpl() [4/4]

◆ asTupleImplForArray()

◆ constexprCopy()

◆ constexprCount()

◆ constexprRemoveCopy()

◆ constexprSearch()

◆ flatAlignOfImpl()

◆ forward_like()

◆ intToStrSize()

◆ isIdentChar()

◆ loadSimdFromField()

◆ makeArrayExtents()

◆ makeBlobArray()

◆ makeFromTuple()

◆ makeTransformedBlobArray()

◆ mergeRecordDimsImpl() [1/4]

◆ mergeRecordDimsImpl() [2/4]

◆ mergeRecordDimsImpl() [3/4]

◆ mergeRecordDimsImpl() [4/4]

◆ mp_for_each_inline_impl()

◆ offsetOfImplWorkaround()

◆ parallelMemcpy()

◆ recordCoordCommonPrefixIsBiggerImpl()

◆ recordCoordCommonPrefixIsSameImpl()

◆ recordRefArithOperator() [1/2]

◆ recordRefArithOperator() [2/2]

◆ recordRefRelOperator() [1/2]

◆ recordRefRelOperator() [2/2]

◆ resizeArray()

◆ sizeOfImpl()

◆ storeSimdToField()

◆ tupleCatImpl()

◆ tupleReplaceImpl()

◆ tupleTransformHelper()

◆ typeNameAsArray()

Variable Documentation

◆ aosoaLanes

◆ aosStridedIndices

◆ copyBlobWithMemcpy

◆ dependentFalse

◆ flatFieldCountBefore

◆ flatFieldCountBefore< 0, Record< Children... > >

◆ flatFieldCountBefore< I, Record< Children... > >

◆ isDirectListInitializable

◆ isDirectListInitializableFromTuple

◆ isDirectListInitializableFromTuple< T, Tuple< Args... > >

◆ isDirectListInitializableImpl

◆ isTupleLike

◆ memcpy

◆ recordCoordTagsStorage

◆ structNameStorage

◆ typeNameStorage