#include <fixed_array.h>

Classes
struct	EmptyInlinedStorage

struct	NonEmptyInlinedStorage

class	Storage

struct	StorageElementWrapper

Public Types
using	allocator_type = typename AllocatorTraits::allocator_type

using	const_iterator = const_pointer

using	const_pointer = typename allocator_type::const_pointer

using	const_reference = typename allocator_type::const_reference

using	const_reverse_iterator = std::reverse_iterator< const_iterator >

using	difference_type = typename allocator_type::difference_type

using	iterator = pointer

using	pointer = typename allocator_type::pointer

using	reference = typename allocator_type::reference

using	reverse_iterator = std::reverse_iterator< iterator >

using	size_type = typename allocator_type::size_type

using	value_type = typename allocator_type::value_type

Public Member Functions
reference	at (size_type i)

const_reference	at (size_type i) const

reference	back ()

const_reference	back () const

iterator	begin ()

const_iterator	begin () const

const_iterator	cbegin () const

const_iterator	cend () const

const_reverse_iterator	crbegin () const

const_reverse_iterator	crend () const

const_pointer	data () const

pointer	data ()

bool	empty () const

iterator	end ()

const_iterator	end () const

void	fill (const value_type &val)

	FixedArray (const FixedArray &other, const allocator_type &a=allocator_type()) noexcept(NoexceptCopyable())

	FixedArray (FixedArray &&other, const allocator_type &a=allocator_type()) noexcept(NoexceptMovable())

	FixedArray (size_type n, const allocator_type &a=allocator_type())

	FixedArray (size_type n, const value_type &val, const allocator_type &a=allocator_type())

	FixedArray (std::initializer_list< value_type > init_list, const allocator_type &a=allocator_type())

template<typename Iterator , EnableIfForwardIterator< Iterator > * = nullptr>
	FixedArray (Iterator first, Iterator last, const allocator_type &a=allocator_type())

reference	front ()

const_reference	front () const

constexpr size_type	max_size () const

size_t	memsize () const

void	operator= (FixedArray &&)=delete

void	operator= (const FixedArray &)=delete

reference	operator[] (size_type i)

const_reference	operator[] (size_type i) const

reverse_iterator	rbegin ()

const_reverse_iterator	rbegin () const

reverse_iterator	rend ()

const_reverse_iterator	rend () const

size_type	size () const

	~FixedArray () noexcept

Static Public Attributes
static constexpr size_type	inline_elements

Private Types
using	AllocatorTraits = std::allocator_traits< A >

template<typename Iterator >
using	EnableIfForwardIterator = absl::enable_if_t< std::is_convertible< typename std::iterator_traits< Iterator >::iterator_category, std::forward_iterator_tag >::value >

using	InlinedStorage = absl::conditional_t< inline_elements==0, EmptyInlinedStorage, NonEmptyInlinedStorage >

using	StorageElement = absl::conditional_t< std::is_array< value_type >::value, StorageElementWrapper< value_type >, value_type >

using	StorageElementBuffer = absl::aligned_storage_t< sizeof(StorageElement), alignof(StorageElement)>

Static Private Member Functions
static pointer	AsValueType (pointer ptr)

static pointer	AsValueType (StorageElementWrapper< value_type > *ptr)

static constexpr bool	DefaultConstructorIsNonTrivial ()

static constexpr bool	NoexceptCopyable ()

static constexpr bool	NoexceptMovable ()

Private Attributes
Storage	storage_

Static Private Attributes
static constexpr size_t	kInlineBytesDefault = 256

Friends
template<typename H >
H	AbslHashValue (H h, const FixedArray &v)

bool	operator!= (const FixedArray &lhs, const FixedArray &rhs)

bool	operator< (const FixedArray &lhs, const FixedArray &rhs)

bool	operator<= (const FixedArray &lhs, const FixedArray &rhs)

bool	operator== (const FixedArray &lhs, const FixedArray &rhs)

bool	operator> (const FixedArray &lhs, const FixedArray &rhs)

bool	operator>= (const FixedArray &lhs, const FixedArray &rhs)

Detailed Description

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>
class absl::FixedArray< T, N, A >

Definition at line 82 of file fixed_array.h.

Member Typedef Documentation

◆ allocator_type

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::allocator_type = typename AllocatorTraits::allocator_type

Definition at line 108 of file fixed_array.h.

◆ AllocatorTraits

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::AllocatorTraits = std::allocator_traits<A>

private

Definition at line 88 of file fixed_array.h.

◆ const_iterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::const_iterator = const_pointer

Definition at line 117 of file fixed_array.h.

◆ const_pointer

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::const_pointer = typename allocator_type::const_pointer

Definition at line 111 of file fixed_array.h.

◆ const_reference

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::const_reference = typename allocator_type::const_reference

Definition at line 113 of file fixed_array.h.

◆ const_reverse_iterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::const_reverse_iterator = std::reverse_iterator<const_iterator>

Definition at line 119 of file fixed_array.h.

◆ difference_type

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::difference_type = typename allocator_type::difference_type

Definition at line 115 of file fixed_array.h.

◆ EnableIfForwardIterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

template<typename Iterator >

using absl::FixedArray< T, N, A >::EnableIfForwardIterator = absl::enable_if_t<std::is_convertible< typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value>

private

Definition at line 94 of file fixed_array.h.

◆ InlinedStorage

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::InlinedStorage = absl::conditional_t<inline_elements == 0, EmptyInlinedStorage, NonEmptyInlinedStorage>

private

Definition at line 436 of file fixed_array.h.

◆ iterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::iterator = pointer

Definition at line 116 of file fixed_array.h.

◆ pointer

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::pointer = typename allocator_type::pointer

Definition at line 110 of file fixed_array.h.

◆ reference

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::reference = typename allocator_type::reference

Definition at line 112 of file fixed_array.h.

◆ reverse_iterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::reverse_iterator = std::reverse_iterator<iterator>

Definition at line 118 of file fixed_array.h.

◆ size_type

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::size_type = typename allocator_type::size_type

Definition at line 114 of file fixed_array.h.

◆ StorageElement

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::StorageElement = absl::conditional_t<std::is_array<value_type>::value, StorageElementWrapper<value_type>, value_type>

private

Definition at line 398 of file fixed_array.h.

◆ StorageElementBuffer

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::StorageElementBuffer = absl::aligned_storage_t<sizeof(StorageElement), alignof(StorageElement)>

private

Definition at line 400 of file fixed_array.h.

◆ value_type

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

using absl::FixedArray< T, N, A >::value_type = typename allocator_type::value_type

Definition at line 109 of file fixed_array.h.

Constructor & Destructor Documentation

◆ FixedArray() [1/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

absl::FixedArray< T, N, A >::FixedArray	(	const FixedArray< T, N, A > &	other,
		const allocator_type &	a = `allocator_type()`
	)

inlinenoexcept

Definition at line 125 of file fixed_array.h.

◆ FixedArray() [2/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

absl::FixedArray< T, N, A >::FixedArray	(	FixedArray< T, N, A > &&	other,
		const allocator_type &	a = `allocator_type()`
	)

inlinenoexcept

Definition at line 130 of file fixed_array.h.

◆ FixedArray() [3/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

absl::FixedArray< T, N, A >::FixedArray	(	size_type	n,
		const allocator_type &	a = `allocator_type()`
	)

inlineexplicit

Definition at line 138 of file fixed_array.h.

◆ FixedArray() [4/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

absl::FixedArray< T, N, A >::FixedArray	(	size_type	n,
		const value_type &	val,
		const allocator_type &	a = `allocator_type()`
	)

inline

Definition at line 147 of file fixed_array.h.

◆ FixedArray() [5/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

absl::FixedArray< T, N, A >::FixedArray	(	std::initializer_list< value_type >	init_list,
		const allocator_type &	a = `allocator_type()`
	)

inline

Definition at line 155 of file fixed_array.h.

◆ FixedArray() [6/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

template<typename Iterator , EnableIfForwardIterator< Iterator > * = nullptr>

absl::FixedArray< T, N, A >::FixedArray	(	Iterator	first,
		Iterator	last,
		const allocator_type &	a = `allocator_type()`
	)

inline

Definition at line 163 of file fixed_array.h.

◆ ~FixedArray()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

absl::FixedArray< T, N, A >::~FixedArray ( )

inlinenoexcept

Definition at line 169 of file fixed_array.h.

Member Function Documentation

◆ AsValueType() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

static pointer absl::FixedArray< T, N, A >::AsValueType ( pointer ptr )

inlinestaticprivate

Definition at line 402 of file fixed_array.h.

◆ AsValueType() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

static pointer absl::FixedArray< T, N, A >::AsValueType ( StorageElementWrapper< value_type > * ptr )

inlinestaticprivate

Definition at line 403 of file fixed_array.h.

◆ at() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

reference absl::FixedArray< T, N, A >::at ( size_type i )

inline

Definition at line 236 of file fixed_array.h.

◆ at() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_reference absl::FixedArray< T, N, A >::at ( size_type i ) const

inline

Definition at line 245 of file fixed_array.h.

◆ back() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

reference absl::FixedArray< T, N, A >::back ( )

inline

Definition at line 264 of file fixed_array.h.

◆ back() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_reference absl::FixedArray< T, N, A >::back ( ) const

inline

Definition at line 268 of file fixed_array.h.

◆ begin() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

iterator absl::FixedArray< T, N, A >::begin ( )

inline

Definition at line 273 of file fixed_array.h.

◆ begin() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_iterator absl::FixedArray< T, N, A >::begin ( ) const

inline

Definition at line 277 of file fixed_array.h.

◆ cbegin()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_iterator absl::FixedArray< T, N, A >::cbegin ( ) const

inline

Definition at line 282 of file fixed_array.h.

◆ cend()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_iterator absl::FixedArray< T, N, A >::cend ( ) const

inline

Definition at line 296 of file fixed_array.h.

◆ crbegin()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_reverse_iterator absl::FixedArray< T, N, A >::crbegin ( ) const

inline

Definition at line 312 of file fixed_array.h.

◆ crend()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_reverse_iterator absl::FixedArray< T, N, A >::crend ( ) const

inline

Definition at line 328 of file fixed_array.h.

◆ data() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_pointer absl::FixedArray< T, N, A >::data ( ) const

inline

Definition at line 208 of file fixed_array.h.

◆ data() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

pointer absl::FixedArray< T, N, A >::data ( )

inline

Definition at line 213 of file fixed_array.h.

◆ DefaultConstructorIsNonTrivial()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

static constexpr bool absl::FixedArray< T, N, A >::DefaultConstructorIsNonTrivial ( )

inlinestaticprivate

Definition at line 103 of file fixed_array.h.

◆ empty()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

bool absl::FixedArray< T, N, A >::empty ( ) const

inline

Definition at line 197 of file fixed_array.h.

◆ end() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

iterator absl::FixedArray< T, N, A >::end ( )

inline

Definition at line 287 of file fixed_array.h.

◆ end() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_iterator absl::FixedArray< T, N, A >::end ( ) const

inline

Definition at line 291 of file fixed_array.h.

◆ fill()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

void absl::FixedArray< T, N, A >::fill ( const value_type & val )

inline

Definition at line 333 of file fixed_array.h.

◆ front() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

reference absl::FixedArray< T, N, A >::front ( )

inline

Definition at line 255 of file fixed_array.h.

◆ front() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_reference absl::FixedArray< T, N, A >::front ( ) const

inline

Definition at line 259 of file fixed_array.h.

◆ max_size()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

constexpr size_type absl::FixedArray< T, N, A >::max_size ( ) const

inline

Definition at line 190 of file fixed_array.h.

◆ memsize()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

size_t absl::FixedArray< T, N, A >::memsize ( ) const

inline

Definition at line 202 of file fixed_array.h.

◆ NoexceptCopyable()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

static constexpr bool absl::FixedArray< T, N, A >::NoexceptCopyable ( )

inlinestaticprivate

Definition at line 95 of file fixed_array.h.

◆ NoexceptMovable()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

static constexpr bool absl::FixedArray< T, N, A >::NoexceptMovable ( )

inlinestaticprivate

Definition at line 99 of file fixed_array.h.

◆ operator=() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

void absl::FixedArray< T, N, A >::operator= ( FixedArray< T, N, A > && )

delete

◆ operator=() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

void absl::FixedArray< T, N, A >::operator= ( const FixedArray< T, N, A > & )

delete

◆ operator[]() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

reference absl::FixedArray< T, N, A >::operator[] ( size_type i )

inline

Definition at line 219 of file fixed_array.h.

◆ operator[]() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_reference absl::FixedArray< T, N, A >::operator[] ( size_type i ) const

inline

Definition at line 227 of file fixed_array.h.

◆ rbegin() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

reverse_iterator absl::FixedArray< T, N, A >::rbegin ( )

inline

Definition at line 301 of file fixed_array.h.

◆ rbegin() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_reverse_iterator absl::FixedArray< T, N, A >::rbegin ( ) const

inline

Definition at line 305 of file fixed_array.h.

◆ rend() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

reverse_iterator absl::FixedArray< T, N, A >::rend ( )

inline

Definition at line 317 of file fixed_array.h.

◆ rend() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

const_reverse_iterator absl::FixedArray< T, N, A >::rend ( ) const

inline

Definition at line 321 of file fixed_array.h.

◆ size()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

size_type absl::FixedArray< T, N, A >::size ( ) const

inline

Definition at line 183 of file fixed_array.h.

Friends And Related Function Documentation

◆ AbslHashValue

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

template<typename H >

H AbslHashValue	(	H	h,
		const FixedArray< T, N, A > &	v
	)

friend

Definition at line 363 of file fixed_array.h.

◆ operator!=

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

bool operator!=	(	const FixedArray< T, N, A > &	lhs,
		const FixedArray< T, N, A > &	rhs
	)

friend

Definition at line 341 of file fixed_array.h.

◆ operator<

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

bool operator<	(	const FixedArray< T, N, A > &	lhs,
		const FixedArray< T, N, A > &	rhs
	)

friend

Definition at line 345 of file fixed_array.h.

◆ operator<=

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

bool operator<=	(	const FixedArray< T, N, A > &	lhs,
		const FixedArray< T, N, A > &	rhs
	)

friend

Definition at line 354 of file fixed_array.h.

◆ operator==

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

bool operator==	(	const FixedArray< T, N, A > &	lhs,
		const FixedArray< T, N, A > &	rhs
	)

friend

Definition at line 337 of file fixed_array.h.

◆ operator>

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

bool operator>	(	const FixedArray< T, N, A > &	lhs,
		const FixedArray< T, N, A > &	rhs
	)

friend

Definition at line 350 of file fixed_array.h.

◆ operator>=

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

bool operator>=	(	const FixedArray< T, N, A > &	lhs,
		const FixedArray< T, N, A > &	rhs
	)

friend

Definition at line 358 of file fixed_array.h.

Member Data Documentation

◆ inline_elements

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

constexpr FixedArray< T, N, A >::size_type absl::FixedArray< T, N, A >::inline_elements

static

Initial value:

=
      (N == kFixedArrayUseDefault ? kInlineBytesDefault / sizeof(value_type)
                                  : static_cast<size_type>(N))

Definition at line 121 of file fixed_array.h.

◆ kInlineBytesDefault

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

constexpr size_t absl::FixedArray< T, N, A >::kInlineBytesDefault = 256

staticprivate

Definition at line 86 of file fixed_array.h.

◆ storage_

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>

Storage absl::FixedArray< T, N, A >::storage_

private

Definition at line 486 of file fixed_array.h.

The documentation for this class was generated from the following file:

fixed_array.h

Classes

Public Types

Public Member Functions

Static Public Attributes

Private Types

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>> class absl::FixedArray< T, N, A >

Member Typedef Documentation

◆ allocator_type

◆ AllocatorTraits

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ const_reverse_iterator

◆ difference_type

◆ EnableIfForwardIterator

◆ InlinedStorage

◆ iterator

◆ pointer

◆ reference

◆ reverse_iterator

◆ size_type

◆ StorageElement

◆ StorageElementBuffer

◆ value_type

Constructor & Destructor Documentation

◆ FixedArray() [1/6]

◆ FixedArray() [2/6]

◆ FixedArray() [3/6]

◆ FixedArray() [4/6]

◆ FixedArray() [5/6]

◆ FixedArray() [6/6]

◆ ~FixedArray()

Member Function Documentation

◆ AsValueType() [1/2]

◆ AsValueType() [2/2]

◆ at() [1/2]

◆ at() [2/2]

◆ back() [1/2]

◆ back() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ cend()

◆ crbegin()

◆ crend()

◆ data() [1/2]

◆ data() [2/2]

◆ DefaultConstructorIsNonTrivial()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ fill()

◆ front() [1/2]

◆ front() [2/2]

◆ max_size()

◆ memsize()

◆ NoexceptCopyable()

◆ NoexceptMovable()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ rbegin() [1/2]

◆ rbegin() [2/2]

◆ rend() [1/2]

◆ rend() [2/2]

◆ size()

Friends And Related Function Documentation

◆ AbslHashValue

◆ operator!=

◆ operator<

◆ operator<=

◆ operator==

◆ operator>

◆ operator>=

template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>
class absl::FixedArray< T, N, A >