g2o::ceres::internal::FixedArray< T, N, A > Class Template Reference

#include <fixed_array.h>

Collaboration diagram for g2o::ceres::internal::FixedArray< T, N, A >:

Classes
struct	StorageElementWrapper
class	NonEmptyInlinedStorage
class	EmptyInlinedStorage
class	Storage

Public Types
using	allocator_type = typename AllocatorTraits::allocator_type
using	value_type = typename AllocatorTraits::value_type
using	pointer = typename AllocatorTraits::pointer
using	const_pointer = typename AllocatorTraits::const_pointer
using	reference = value_type&
using	const_reference = const value_type&
using	size_type = typename AllocatorTraits::size_type
using	difference_type = typename AllocatorTraits::difference_type
using	iterator = pointer
using	const_iterator = const_pointer
using	reverse_iterator = std::reverse_iterator<iterator>
using	const_reverse_iterator = std::reverse_iterator<const_iterator>

Public Member Functions
	FixedArray (const FixedArray &other, const allocator_type &a=allocator_type())
	FixedArray (FixedArray &&other, const allocator_type &a=allocator_type()) noexcept
	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())
	~FixedArray () noexcept
void	operator= (FixedArray &&)=delete
void	operator= (const FixedArray &)=delete
size_type	size () const
constexpr size_type	max_size () const
bool	empty () const
size_t	memsize () const
const_pointer	data () const
pointer	data ()
reference	operator[] (size_type i)
const_reference	operator[] (size_type i) const
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
iterator	begin ()
const_iterator	begin () const
const_iterator	cbegin () const
iterator	end ()
const_iterator	end () const
const_iterator	cend () const
reverse_iterator	rbegin ()
const_reverse_iterator	rbegin () const
const_reverse_iterator	crbegin () const
reverse_iterator	rend ()
const_reverse_iterator	rend () const
const_reverse_iterator	crend () const
void	fill (const value_type &val)

Static Public Attributes
static constexpr size_type	inline_elements

Private Types
using	AllocatorTraits = std::allocator_traits<A>
template<typename Iterator>
using	EnableIfForwardIterator
using	StorageElement
using	InlinedStorage

Static Private Member Functions
static constexpr bool	DefaultConstructorIsNonTrivial ()
static pointer	AsValueType (pointer ptr)
static pointer	AsValueType (StorageElementWrapper< value_type > *ptr)

Private Attributes
Storage	storage_

Static Private Attributes
static constexpr size_t	kInlineBytesDefault = 256

Friends
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 = FixedArrayDefaultAllocator<T>>
class g2o::ceres::internal::FixedArray< T, N, A >

Definition at line 85 of file fixed_array.h.

Member Typedef Documentation

allocator_type

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::allocator_type = typename AllocatorTraits::allocator_type

Definition at line 103 of file fixed_array.h.

AllocatorTraits

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::AllocatorTraits = std::allocator_traits<A>

private

Definition at line 91 of file fixed_array.h.

const_iterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::const_iterator = const_pointer

Definition at line 112 of file fixed_array.h.

const_pointer

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::const_pointer = typename AllocatorTraits::const_pointer

Definition at line 106 of file fixed_array.h.

const_reference

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::const_reference = const value_type&

Definition at line 108 of file fixed_array.h.

const_reverse_iterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::const_reverse_iterator = std::reverse_iterator<const_iterator>

Definition at line 114 of file fixed_array.h.

difference_type

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::difference_type = typename AllocatorTraits::difference_type

Definition at line 110 of file fixed_array.h.

EnableIfForwardIterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

template<typename Iterator>

using g2o::ceres::internal::FixedArray< T, N, A >::EnableIfForwardIterator

private

Initial value:

 typename std::enable_if<std::is_convertible<
      typename std::iterator_traits<Iterator>::iterator_category,
      std::forward_iterator_tag>::value>::type

Definition at line 95 of file fixed_array.h.

InlinedStorage

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::InlinedStorage

private

Initial value:

 
      typename std::conditional<inline_elements == 0, EmptyInlinedStorage,
                                NonEmptyInlinedStorage>::type

Definition at line 392 of file fixed_array.h.

iterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::iterator = pointer

Definition at line 111 of file fixed_array.h.

pointer

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::pointer = typename AllocatorTraits::pointer

Definition at line 105 of file fixed_array.h.

reference

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::reference = value_type&

Definition at line 107 of file fixed_array.h.

reverse_iterator

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::reverse_iterator = std::reverse_iterator<iterator>

Definition at line 113 of file fixed_array.h.

size_type

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::size_type = typename AllocatorTraits::size_type

Definition at line 109 of file fixed_array.h.

StorageElement

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::StorageElement

private

Initial value:

 
      typename std::conditional<std::is_array<value_type>::value,
                                StorageElementWrapper<value_type>,
                                value_type>::type

Definition at line 355 of file fixed_array.h.

value_type

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

using g2o::ceres::internal::FixedArray< T, N, A >::value_type = typename AllocatorTraits::value_type

Definition at line 104 of file fixed_array.h.

Constructor & Destructor Documentation

FixedArray() [1/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

g2o::ceres::internal::FixedArray< T, N, A >::FixedArray ( const FixedArray< T, N, A > & other, const allocator_type & a = allocator_type() )

inline

Definition at line 120 of file fixed_array.h.

      : FixedArray(other.begin(), other.end(), a) {}

References begin(), end(), and FixedArray().

Referenced by FixedArray(), FixedArray(), FixedArray(), operator!=, operator<, operator<=, operator=(), operator=(), operator==, operator>, and operator>=.

FixedArray() [2/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

g2o::ceres::internal::FixedArray< T, N, A >::FixedArray ( FixedArray< T, N, A > && other, const allocator_type & a = allocator_type() )

inlinenoexcept

Definition at line 124 of file fixed_array.h.

      : FixedArray(std::make_move_iterator(other.begin()),
                   std::make_move_iterator(other.end()), a) {}

References begin(), end(), and FixedArray().

FixedArray() [3/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

g2o::ceres::internal::FixedArray< T, N, A >::FixedArray ( size_type n, const allocator_type & a = allocator_type() )

inlineexplicit

Definition at line 131 of file fixed_array.h.

      : storage_(n, a) {
    if (DefaultConstructorIsNonTrivial()) {
      ConstructRange(storage_.alloc(), storage_.begin(), storage_.end());
    }
  }

References g2o::ceres::internal::ConstructRange(), DefaultConstructorIsNonTrivial(), and storage_.

FixedArray() [4/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

g2o::ceres::internal::FixedArray< T, N, A >::FixedArray ( size_type n, const value_type & val, const allocator_type & a = allocator_type() )

inline

Definition at line 139 of file fixed_array.h.

      : storage_(n, a) {
    ConstructRange(storage_.alloc(), storage_.begin(), storage_.end(), val);
  }

References g2o::ceres::internal::ConstructRange(), and storage_.

FixedArray() [5/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

g2o::ceres::internal::FixedArray< T, N, A >::FixedArray ( std::initializer_list< value_type > init_list, const allocator_type & a = allocator_type() )

inline

Definition at line 146 of file fixed_array.h.

      : FixedArray(init_list.begin(), init_list.end(), a) {}

References begin(), end(), and FixedArray().

FixedArray() [6/6]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

g2o::ceres::internal::FixedArray< T, N, A >::FixedArray ( Iterator first, Iterator last, const allocator_type & a = allocator_type() )

inline

Definition at line 154 of file fixed_array.h.

      : storage_(std::distance(first, last), a) {
    CopyRange(storage_.alloc(), storage_.begin(), first, last);
  }

References g2o::ceres::internal::CopyRange(), and storage_.

~FixedArray()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

g2o::ceres::internal::FixedArray< T, N, A >::~FixedArray ( )

inlinenoexcept

Definition at line 160 of file fixed_array.h.

                         {
    for (auto* cur = storage_.begin(); cur != storage_.end(); ++cur) {
      AllocatorTraits::destroy(storage_.alloc(), cur);
    }
  }

References storage_.

Member Function Documentation

AsValueType() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

pointer g2o::ceres::internal::FixedArray< T, N, A >::AsValueType ( pointer ptr )

inlinestaticprivate

Definition at line 360 of file fixed_array.h.

{ return ptr; }

Referenced by data(), data(), and g2o::ceres::internal::FixedArray< T, N, A >::Storage::~Storage().

AsValueType() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

pointer g2o::ceres::internal::FixedArray< T, N, A >::AsValueType ( StorageElementWrapper< value_type > * ptr )

inlinestaticprivate

Definition at line 361 of file fixed_array.h.

                                                                     {
    return std::addressof(ptr->array);
  }

References g2o::ceres::internal::FixedArray< T, N, A >::StorageElementWrapper< OuterT, InnerT, InnerN >::array.

back() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

reference g2o::ceres::internal::FixedArray< T, N, A >::back ( )

inline

Definition at line 229 of file fixed_array.h.

{ return *(end() - 1); }

References end().

back() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_reference g2o::ceres::internal::FixedArray< T, N, A >::back ( ) const

inline

Definition at line 233 of file fixed_array.h.

{ return *(end() - 1); }

References end().

begin() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

iterator g2o::ceres::internal::FixedArray< T, N, A >::begin ( )

inline

Definition at line 238 of file fixed_array.h.

{ return data(); }

References data().

Referenced by cbegin(), fill(), FixedArray(), FixedArray(), FixedArray(), front(), front(), operator<, operator==, rend(), and rend().

begin() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_iterator g2o::ceres::internal::FixedArray< T, N, A >::begin ( ) const

inline

Definition at line 242 of file fixed_array.h.

{ return data(); }

References data().

cbegin()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_iterator g2o::ceres::internal::FixedArray< T, N, A >::cbegin ( ) const

inline

Definition at line 247 of file fixed_array.h.

{ return begin(); }

References begin().

cend()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_iterator g2o::ceres::internal::FixedArray< T, N, A >::cend ( ) const

inline

Definition at line 261 of file fixed_array.h.

{ return end(); }

References end().

crbegin()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_reverse_iterator g2o::ceres::internal::FixedArray< T, N, A >::crbegin ( ) const

inline

Definition at line 277 of file fixed_array.h.

{ return rbegin(); }

References rbegin().

crend()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_reverse_iterator g2o::ceres::internal::FixedArray< T, N, A >::crend ( ) const

inline

Definition at line 293 of file fixed_array.h.

{ return rend(); }

References rend().

data() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

pointer g2o::ceres::internal::FixedArray< T, N, A >::data ( )

inline

Definition at line 204 of file fixed_array.h.

{ return AsValueType(storage_.begin()); }

References AsValueType(), and storage_.

data() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_pointer g2o::ceres::internal::FixedArray< T, N, A >::data ( ) const

inline

Definition at line 199 of file fixed_array.h.

{ return AsValueType(storage_.begin()); }

References AsValueType(), and storage_.

Referenced by begin(), begin(), end(), end(), g2o::BaseFixedSizedEdge< D, OdomAndLaserMotion, VertexSE2, VertexBaseline >::linearizeOplusN(), operator[](), and operator[]().

DefaultConstructorIsNonTrivial()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

constexpr bool g2o::ceres::internal::FixedArray< T, N, A >::DefaultConstructorIsNonTrivial ( )

inlinestaticconstexprprivate

Definition at line 98 of file fixed_array.h.

                                                         {
    return !std::is_trivially_default_constructible<StorageElement>::value;
  }

Referenced by FixedArray().

empty()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

bool g2o::ceres::internal::FixedArray< T, N, A >::empty ( ) const

inline

Definition at line 188 of file fixed_array.h.

{ return size() == 0; }

References size().

end() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

iterator g2o::ceres::internal::FixedArray< T, N, A >::end ( )

inline

Definition at line 252 of file fixed_array.h.

{ return data() + size(); }

References data(), and size().

Referenced by back(), back(), cend(), fill(), FixedArray(), FixedArray(), FixedArray(), operator<, operator==, rbegin(), and rbegin().

end() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_iterator g2o::ceres::internal::FixedArray< T, N, A >::end ( ) const

inline

Definition at line 256 of file fixed_array.h.

{ return data() + size(); }

References data(), and size().

fill()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

inline

Definition at line 298 of file fixed_array.h.

{ std::fill(begin(), end(), val); }

References begin(), and end().

Referenced by g2o::BaseFixedSizedEdge< D, OdomAndLaserMotion, VertexSE2, VertexBaseline >::linearizeOplusN().

front() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

reference g2o::ceres::internal::FixedArray< T, N, A >::front ( )

inline

Definition at line 220 of file fixed_array.h.

{ return *begin(); }

References begin().

front() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_reference g2o::ceres::internal::FixedArray< T, N, A >::front ( ) const

inline

Definition at line 224 of file fixed_array.h.

{ return *begin(); }

References begin().

max_size()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

size_type g2o::ceres::internal::FixedArray< T, N, A >::max_size ( ) const

inlineconstexpr

Definition at line 181 of file fixed_array.h.

                                       {
    return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
  }

memsize()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

size_t g2o::ceres::internal::FixedArray< T, N, A >::memsize ( ) const

inline

Definition at line 193 of file fixed_array.h.

{ return size() * sizeof(value_type); }

References size().

operator=() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

void g2o::ceres::internal::FixedArray< T, N, A >::operator= ( const FixedArray< T, N, A > & )

delete

References FixedArray().

operator=() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

void g2o::ceres::internal::FixedArray< T, N, A >::operator= ( FixedArray< T, N, A > && )

delete

References FixedArray().

operator[]() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

inline

Definition at line 210 of file fixed_array.h.

{ return data()[i]; }

References data().

operator[]() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

inline

Definition at line 215 of file fixed_array.h.

{ return data()[i]; }

References data().

rbegin() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

reverse_iterator g2o::ceres::internal::FixedArray< T, N, A >::rbegin ( )

inline

Definition at line 266 of file fixed_array.h.

{ return reverse_iterator(end()); }

References end().

Referenced by crbegin().

rbegin() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_reverse_iterator g2o::ceres::internal::FixedArray< T, N, A >::rbegin ( ) const

inline

Definition at line 270 of file fixed_array.h.

                                        {
    return const_reverse_iterator(end());
  }

References end().

rend() [1/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

reverse_iterator g2o::ceres::internal::FixedArray< T, N, A >::rend ( )

inline

Definition at line 282 of file fixed_array.h.

{ return reverse_iterator(begin()); }

References begin().

Referenced by crend().

rend() [2/2]

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

const_reverse_iterator g2o::ceres::internal::FixedArray< T, N, A >::rend ( ) const

inline

Definition at line 286 of file fixed_array.h.

                                      {
    return const_reverse_iterator(begin());
  }

References begin().

size()

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

size_type g2o::ceres::internal::FixedArray< T, N, A >::size ( ) const

inline

Definition at line 174 of file fixed_array.h.

{ return storage_.size(); }

References storage_.

Referenced by empty(), end(), end(), and memsize().

Friends And Related Symbol Documentation

operator!=

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

friend

Definition at line 306 of file fixed_array.h.

                                                                       {
    return !(lhs == rhs);
  }

References FixedArray().

operator<

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

friend

Definition at line 310 of file fixed_array.h.

                                                                      {
    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(),
                                        rhs.end());
  }

References begin(), end(), and FixedArray().

operator<=

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

friend

Definition at line 319 of file fixed_array.h.

                                                                       {
    return !(rhs < lhs);
  }

References FixedArray().

operator==

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

friend

Definition at line 302 of file fixed_array.h.

                                                                       {
    return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
  }

References begin(), end(), and FixedArray().

operator>

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

friend

Definition at line 315 of file fixed_array.h.

                                                                      {
    return rhs < lhs;
  }

References FixedArray().

operator>=

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

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

friend

Definition at line 323 of file fixed_array.h.

                                                                       {
    return !(lhs < rhs);
  }

References FixedArray().

Member Data Documentation

inline_elements

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

size_type g2o::ceres::internal::FixedArray< T, N, A >::inline_elements

staticconstexpr

Initial value:

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

Definition at line 116 of file fixed_array.h.

Referenced by g2o::ceres::internal::FixedArray< T, N, A >::Storage::UsingInlinedStorage().

kInlineBytesDefault

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

size_t g2o::ceres::internal::FixedArray< T, N, A >::kInlineBytesDefault = 256

staticconstexprprivate

Definition at line 89 of file fixed_array.h.

storage_

template<typename T, size_t N = kFixedArrayUseDefault, typename A = FixedArrayDefaultAllocator<T>>

Storage g2o::ceres::internal::FixedArray< T, N, A >::storage_

private

Definition at line 442 of file fixed_array.h.

Referenced by data(), data(), FixedArray(), FixedArray(), FixedArray(), size(), and ~FixedArray().

---

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

• /build/reproducible-path/g2o-0~20230806/g2o/autodiff/fixed_array.h