Inheritance diagram for gimbal::Vector< T >:

Public Types
using	VectorType = Vector< T >

using	VectorViewBaseType = VectorViewBase< Vector< T >, T >

using	ViewType = VectorViewBaseType

using	MoveValues = std::tuple< void *, Size, Size >

using	iterator = typename VectorViewBaseType::iterator

using	const_iterator = typename VectorViewBaseType::const_iterator

using	difference_type = typename VectorViewBaseType::difference_type

Public Types inherited from gimbal::VectorViewBase< Vector< T >, T >
using	VectorViewBaseType = VectorViewBase< Vector< T >, T >

using	DerivedType = Vector< T >

using	IterableType = RandomAccessIterable< Vector< T >, Size, T >

using	IndexableType = ReadWriteContiguousIndexable< Vector< T >, Size, T >

using	value_type = T

using	allocator_type = Context *

using	size_type = Size

using	difference_type = std::ptrdiff_t

using	reference = value_type &

using	const_reference = const value_type &

using	pointer = T *

using	const_pointer = const T *

using	iterator = typename IterableType::iterator

using	const_iterator = typename IterableType::const_iterator

using	reverse_iterator = typename IterableType::reverse_iterator

using	reverse_const_iterator = typename IterableType::reverse_const_iterator

Public Types inherited from gimbal::RandomAccessIterable< CRTP, Index, Value >
using	iterator = RandomAccessIterator< CRTP, Index, Value, false >

using	reverse_iterator = RandomAccessIterator< CRTP, Index, Value, true >

using	const_iterator = RandomAccessIterator< std::add_const_t< CRTP >, Index, Value, false >

using	reverse_const_iterator = RandomAccessIterator< std::add_const_t< CRTP >, Index, Value, true >

Public Member Functions
const GblArrayList *	getVector_ (void) const

GblArrayList *	getVector_ (void)

	Vector (std::nullptr_t, Size allocSize=sizeof(VectorType))

	Vector (Context *pCtx=nullptr, Size allocSize=sizeof(VectorType))

	Vector (const T pInitialData, Size elementCount, Context pCtx=nullptr, Size allocSize=sizeof(VectorType), Size elementSize=sizeof(T))

	Vector (Size count, const T &value=T(), Context *pCtx=nullptr, Size allocSize=sizeof(VectorType))

	Vector (std::initializer_list< T > c, Context *pCtx=nullptr, Size allocSize=sizeof(VectorType))

	Vector (type_compatible_container_readable< T > auto &&c, Context *pCtx=nullptr, Size allocSize=sizeof(VectorType))

	Vector (const type_compatible_iterator_readable< T > auto &first, const type_compatible_iterator_readable< T > auto &last, Context *pCtx=nullptr, Size allocSize=sizeof(VectorType))

	Vector (const VectorType &other, Context *pCtx=nullptr, Size allocSize=sizeof(VectorType))

	Vector (VectorView< T > other, Context *pCtx=nullptr, Size allocSize=sizeof(VectorType))

	Vector (VectorType &&rhs, Context *pCtx=nullptr, Size allocSize=sizeof(VectorType))

	Vector (GblArrayList &&rhs, Context *pCtx=nullptr, Size allocSize=sizeof(VectorType))

auto	take (void)

void	give (MoveValues moveValues)

void	reserve (Size count)

void	resize (Size newSize)

void	shrink_to_fit (void)

void	pushBack (T value)

void	push_back (T value)

template<typename... Args>
T &	emplace_back (Args &&... args)

void	pushFront (T value)

void	push_front (T value)

iterator	insert (const_iterator position, const T *pValue, Size count)

iterator	insert (const_iterator position, const T &val)

iterator	insert (const_iterator position, gimbal::Size size, const T &val)

iterator	insert (const_iterator position, const type_compatible_iterator_readable< T > auto &first, const type_compatible_iterator_readable< T > auto &last)

template<type_compatible_iterator_readable< T > It> requires contiguous_iterator<It>
iterator	insert (const_iterator position, const It &first, const It &last)

iterator	insert (const_iterator position, const type_compatible_container_readable< T > auto &c)

iterator	insert (const_iterator position, const type_compatible_contiguous_container_readable< T > auto &c)

template<typename... Args>
iterator	emplace (const_iterator position, Args &&... args)

void	popBack (void)

void	pop_back (void)

iterator	erase (const_iterator pos)

iterator	erase (const_iterator first, const_iterator last)

void	clear (void)

void	assign (const T *pData, Size elementCount)

void	assign (gimbal::Size size, const T &value)

void	assign (const type_compatible_contiguous_container_readable< T > auto &c)

void	assign (const type_compatible_container_readable< T > auto &c)

void	assign (const type_compatible_iterator_readable< T > auto &first, const type_compatible_iterator_readable< T > auto &last)

template<type_compatible_iterator_readable< T > It> requires contiguous_iterator<It>
void	assign (const It &first, const It &last)

const VectorType &	operator= (VectorView< T > rhs)

const VectorType &	operator= (const VectorType &rhs)

const VectorType &	operator= (VectorType &&rhs)

const VectorType &	operator= (GblArrayList &&rhs)

const VectorType &	operator= (const type_compatible_container< T > auto &&c)

const VectorType &	operator+= (const type_compatible_container_readable< T > auto &view)

const VectorType &	operator+= (const type_compatible_iterator_readable< T > auto &it)

const VectorType &	operator+= (const T &value)

const VectorType &	operator+= (VectorView< T > view)

Public Member Functions inherited from gimbal::VectorViewBase< Vector< T >, T >
	operator const GblArrayList * () const

const_reference	getElement_ (size_type index) const

reference	getElement_ (size_type index)

void	setElement_ (size_type index, value_type value)

size_t	getElementCount_ (void) const

bool	isEmpty (void) const

bool	isStack (void) const

bool	isHeap (void) const

std::vector< value_type >	toStdVector (void) const

Size	getStackBytes (void) const

Context *	getContext (void) const

allocator_type	get_allocator (void) const

Size	getSize (void) const

Size	getSizeBytes (void) const

Size	size_bytes (void) const

Size	getCapacity (void) const

Size	capacity (void) const

Size	getElementSize (void) const

size_type	element_size (void) const

size_type	max_size (void) const

const void *	getData (void) const

constexpr pointer	data (void)

constexpr const_pointer	data (void) const

T &	front (void) const

T &	back (void) const

Public Member Functions inherited from gimbal::ReadWriteContiguousIndexable< CRTP, Index, Value >
void	checkBounds (Index index) const

Index	size (void) const

Index	length (void) const

Index	empty (void) const

Value	at (Index index) const

IndexableProxy	at (Index index)

Value	front (Index index) const

IndexableProxy	front (void)

Value	back (void) const

IndexableProxy	back (void)

Public Member Functions inherited from gimbal::ReadWriteIndexable< CRTP, Index, Value, true >
Value	operator[] (Index key) const

Public Member Functions inherited from gimbal::RandomAccessIterable< CRTP, Index, Value >
iterator	begin (void)

auto	begin (void) const

auto	rbegin (void)

auto	rbegin (void) const

iterator	end (void)

auto	end (void) const

auto	rend (void)

auto	rend (void) const

const_iterator	cbegin (void) const

auto	crbegin (void) const

const_iterator	cend (void) const

auto	crend (void) const

Static Public Member Functions
static MoveValues	take (GblArrayList *pVec)

Protected Member Functions
void	destruct_ (Size startPos, Size count=1)

Protected Member Functions inherited from gimbal::VectorViewBase< Vector< T >, T >
decltype(auto)	vec_ (void) const

decltype(auto)	vec_ (void)

void *	at_ (Size index) const

Additional Inherited Members
Data Fields inherited from GblArrayList
struct {

GblContext * pCtx

uint8_t * pData

size_t size

size_t capacity

uint16_t elementSize

uint16_t zeroTerminated: 1

uint16_t stackCapacity: 15

}	private_

Detailed Description

template<typename T>
class gimbal::Vector< T >

Definition at line 274 of file gimbal_vector.hpp.

Member Typedef Documentation

◆ VectorType

template<typename T >

using gimbal::Vector< T >::VectorType = Vector<T>

Definition at line 289 of file gimbal_vector.hpp.

◆ VectorViewBaseType

template<typename T >

using gimbal::Vector< T >::VectorViewBaseType = VectorViewBase<Vector<T>, T>

Definition at line 290 of file gimbal_vector.hpp.

◆ ViewType

template<typename T >

using gimbal::Vector< T >::ViewType = VectorViewBaseType

Definition at line 291 of file gimbal_vector.hpp.

◆ MoveValues

template<typename T >

using gimbal::Vector< T >::MoveValues = std::tuple<void*, Size, Size>

Definition at line 292 of file gimbal_vector.hpp.

◆ iterator

template<typename T >

using gimbal::Vector< T >::iterator = typename VectorViewBaseType::iterator

Definition at line 293 of file gimbal_vector.hpp.

◆ const_iterator

template<typename T >

using gimbal::Vector< T >::const_iterator = typename VectorViewBaseType::const_iterator

Definition at line 294 of file gimbal_vector.hpp.

◆ difference_type

template<typename T >

using gimbal::Vector< T >::difference_type = typename VectorViewBaseType::difference_type

Definition at line 295 of file gimbal_vector.hpp.

Constructor & Destructor Documentation

◆ Vector() [1/11]

template<typename T >

gimbal::Vector< T >::Vector	(	std::nullptr_t	,
		Size	allocSize = `sizeof(VectorType)`
	)

inlineexplicit

Definition at line 308 of file gimbal_vector.hpp.

308 :

309 Vector(nullptr, 0, nullptr, allocSize) {}

◆ Vector() [2/11]

template<typename T >

gimbal::Vector< T >::Vector	(	Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`
	)

inlineexplicit

Definition at line 312 of file gimbal_vector.hpp.

312 :

313 Vector(nullptr, 0, pCtx, allocSize) {}

◆ Vector() [3/11]

template<typename T >

gimbal::Vector< T >::Vector	(	const T *	pInitialData,
		Size	elementCount,
		Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`,
		Size	elementSize = `sizeof(T)`
	)

inlineexplicit

Definition at line 316 of file gimbal_vector.hpp.

                                                                                                                                                    {
        Exception::checkThrow(GblArrayList_construct(this, elementSize, elementCount, pInitialData, allocSize, pCtx));
    }

◆ Vector() [4/11]

template<typename T >

gimbal::Vector< T >::Vector	(	Size	count,
		const T &	value = `T()`,
		Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`
	)

inlineexplicit

Definition at line 321 of file gimbal_vector.hpp.

                                                                                                              {
        T* pTempArray = static_cast<T*>(GBL_ALLOCA(count * sizeof(T)));
        std::fill(pTempArray, pTempArray+count, value);
        Exception::checkThrow(GblArrayList_construct(this, sizeof(T), count, pTempArray, allocSize, pCtx));
    }

◆ Vector() [5/11]

template<typename T >

gimbal::Vector< T >::Vector	(	std::initializer_list< T >	c,
		Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`
	)

inline

Definition at line 328 of file gimbal_vector.hpp.

                                                                                              :
        Vector(pCtx, allocSize)
    {
        insert(this->begin(), c.begin(), c.end());
    }

◆ Vector() [6/11]

template<typename T >

gimbal::Vector< T >::Vector	(	type_compatible_container_readable< T > auto &&	c,
		Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`
	)

inlineexplicit

Definition at line 336 of file gimbal_vector.hpp.

                                                                                                                             :
        Vector(pCtx, allocSize)
    {
        *this = std::forward<decltype(c)>(c);
    }

◆ Vector() [7/11]

template<typename T >

gimbal::Vector< T >::Vector	(	const type_compatible_iterator_readable< T > auto &	first,
		const type_compatible_iterator_readable< T > auto &	last,
		Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`
	)

inlineexplicit

Definition at line 343 of file gimbal_vector.hpp.

                                                                                                                                                                                            :
        Vector(pCtx, allocSize)
    {
        insert(this->end(), first, last);
    }

◆ Vector() [8/11]

template<typename T >

gimbal::Vector< T >::Vector	(	const VectorType &	other,
		Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`
	)

inline

Definition at line 352 of file gimbal_vector.hpp.

352 :

353 Vector(VectorView(other), pCtx, allocSize) {}

◆ Vector() [9/11]

template<typename T >

gimbal::Vector< T >::Vector	(	VectorView< T >	other,
		Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`
	)

inline

Definition at line 356 of file gimbal_vector.hpp.

356 :

357 Vector(other.data(), other.size(), pCtx, allocSize) {}

◆ Vector() [10/11]

template<typename T >

gimbal::Vector< T >::Vector	(	VectorType &&	rhs,
		Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`
	)

inline

Definition at line 363 of file gimbal_vector.hpp.

363 :

364 Vector(static_cast<GblArrayList&&>(rhs), pCtx, allocSize) {}

GblArrayList

Contiguous, array-based abstract list container with C++-style STL API.

Definition gimbal_array_list.h:29

◆ Vector() [11/11]

template<typename T >

gimbal::Vector< T >::Vector	(	GblArrayList &&	rhs,
		Context *	pCtx = `nullptr`,
		Size	allocSize = `sizeof(VectorType)`
	)

inline

Definition at line 367 of file gimbal_vector.hpp.

                                                                                        :
        Vector(pCtx, allocSize)
    {
        *this = std::move(rhs);
    }

◆ ~Vector()

template<typename T >

gimbal::Vector< T >::~Vector ( void )

inline

Definition at line 389 of file gimbal_vector.hpp.

                  {
        destruct_(0, size());
        Exception::checkThrow(GblArrayList_destruct(this));
    }

Member Function Documentation

◆ destruct_()

template<typename T >

void gimbal::Vector< T >::destruct_	(	Size	startPos,
		Size	count = `1`
	)

inlineprotected

Definition at line 280 of file gimbal_vector.hpp.

                                                {
        if constexpr(std::is_destructible_v<T>) {
            for(Size i = startPos; i < count; ++i) {
                this->data()[i].~T();
            }
        }
    }

◆ getVector_() [1/2]

template<typename T >

const GblArrayList * gimbal::Vector< T >::getVector_ ( void ) const

inline

Definition at line 297 of file gimbal_vector.hpp.

                                               {
        return static_cast<const GblArrayList*>(this);
    }

◆ getVector_() [2/2]

template<typename T >

GblArrayList * gimbal::Vector< T >::getVector_ ( void )

inline

Definition at line 301 of file gimbal_vector.hpp.

                                   {
        return static_cast<GblArrayList*>(this);
    }

◆ take() [1/2]

template<typename T >

static MoveValues gimbal::Vector< T >::take ( GblArrayList * pVec )

inlinestatic

Definition at line 373 of file gimbal_vector.hpp.

                                               {
        auto moveValues = MoveValues(nullptr, 0, 0);
        auto& [pData, size, capacity] = moveValues;
        Exception::checkThrow(GblArrayList_release(pVec, &pData, &size, &capacity));
        return moveValues;
    }

◆ take() [2/2]

template<typename T >

auto gimbal::Vector< T >::take ( void )

inline

Definition at line 380 of file gimbal_vector.hpp.

                    {
        return take(this);
    }

◆ give()

template<typename T >

void gimbal::Vector< T >::give ( MoveValues moveValues )

inline

Definition at line 384 of file gimbal_vector.hpp.

                                     {
        auto& [pData, size, capacity] = moveValues;
        Exception::checkThrow(GblArrayList_acquire(this, pData, size, capacity));
    }

◆ reserve()

template<typename T >

void gimbal::Vector< T >::reserve ( Size count )

inline

Definition at line 397 of file gimbal_vector.hpp.

                             {
        Exception::checkThrow(GblArrayList_reserve(this, count));
    }

◆ resize()

template<typename T >

void gimbal::Vector< T >::resize ( Size newSize )

inline

Definition at line 401 of file gimbal_vector.hpp.

                              {
        if(newSize < size()) {
            destruct_(newSize, size() - newSize);
        }
        Exception::checkThrow(GblArrayList_resize(this, newSize));
    }

◆ shrink_to_fit()

template<typename T >

void gimbal::Vector< T >::shrink_to_fit ( void )

inline

Definition at line 408 of file gimbal_vector.hpp.

                             {
        Exception::checkThrow(GblArrayList_shrinkToFit(this));
    }

◆ pushBack()

template<typename T >

void gimbal::Vector< T >::pushBack ( T value )

inline

Definition at line 412 of file gimbal_vector.hpp.

                           {
        Exception::checkThrow(GblArrayList_pushBack(this, &value));
    }

◆ push_back()

template<typename T >

void gimbal::Vector< T >::push_back ( T value )

inline

Definition at line 416 of file gimbal_vector.hpp.

                            {
        pushBack(std::move(value));
    }

◆ emplace_back()

template<typename T >

template<typename... Args>

T & gimbal::Vector< T >::emplace_back ( Args &&... args )

inline

Definition at line 421 of file gimbal_vector.hpp.

                                    {
        resize(size()+1);
        void* pData = this->at_(size()-1);
        T* pObj = new (pData) T(std::forward<Args>(args)...);
        return *pObj;
    }

◆ pushFront()

template<typename T >

void gimbal::Vector< T >::pushFront ( T value )

inline

Definition at line 428 of file gimbal_vector.hpp.

                            {
        Exception::checkThrow(GblArrayList_pushFront(this, &value));
    }

◆ push_front()

template<typename T >

void gimbal::Vector< T >::push_front ( T value )

inline

Definition at line 432 of file gimbal_vector.hpp.

                             {
        pushFront(std::move(value));
    }

◆ insert() [1/7]

template<typename T >

iterator gimbal::Vector< T >::insert	(	const_iterator	position,
		const T *	pValue,
		Size	count
	)

inline

Definition at line 436 of file gimbal_vector.hpp.

                                                                          {
        const auto index = std::distance(this->cbegin(), position);
        Exception::checkThrow([&]() {
            GblArrayList_insert(this, index, count, pValue);
        });
        return iterator(*this, index);
    }

◆ insert() [2/7]

template<typename T >

iterator gimbal::Vector< T >::insert	(	const_iterator	position,
		const T &	val
	)

inline

Definition at line 444 of file gimbal_vector.hpp.

                                                           {
        return insert(std::move(position), &val, 1);
    }

◆ insert() [3/7]

template<typename T >

iterator gimbal::Vector< T >::insert	(	const_iterator	position,
		gimbal::Size	size,
		const T &	val
	)

inline

Definition at line 448 of file gimbal_vector.hpp.

                                                                            {
        T* pTempArray = static_cast<T*>(GBL_ALLOCA(size * sizeof(T)));
        std::fill(pTempArray, pTempArray+size, val);
        return insert(std::move(position), pTempArray, size);
    }

◆ insert() [4/7]

template<typename T >

iterator gimbal::Vector< T >::insert	(	const_iterator	position,
		const type_compatible_iterator_readable< T > auto &	first,
		const type_compatible_iterator_readable< T > auto &	last
	)

inline

Definition at line 454 of file gimbal_vector.hpp.

                                                                                                                                                            {
        const auto size = std::distance(first, last);
        T* pTempArray = static_cast<T*>(GBL_ALLOCA(size * sizeof(T)));
        std::copy(first, last, pTempArray);
        return insert(std::move(position), pTempArray, size);
    }

◆ insert() [5/7]

template<typename T >

template<type_compatible_iterator_readable< T > It>
requires contiguous_iterator<It>

iterator gimbal::Vector< T >::insert	(	const_iterator	position,
		const It &	first,
		const It &	last
	)

inline

Definition at line 463 of file gimbal_vector.hpp.

                                                                              {
        return insert(std::move(position), &first[0], std::distance(first, last));
    }

◆ insert() [6/7]

template<typename T >

iterator gimbal::Vector< T >::insert	(	const_iterator	position,
		const type_compatible_container_readable< T > auto &	c
	)

inline

Definition at line 467 of file gimbal_vector.hpp.

                                                                                                  {
        return insert(std::move(position), std::cbegin(c), std::cend(c));
    }

◆ insert() [7/7]

template<typename T >

iterator gimbal::Vector< T >::insert	(	const_iterator	position,
		const type_compatible_contiguous_container_readable< T > auto &	c
	)

inline

Definition at line 471 of file gimbal_vector.hpp.

                                                                                                             {
        return insert(std::move(position), c.data(), std::size(c));
    }

◆ emplace()

template<typename T >

template<typename... Args>

iterator gimbal::Vector< T >::emplace	(	const_iterator	position,
		Args &&...	args
	)

inline

Definition at line 476 of file gimbal_vector.hpp.

                                                              {
        const auto index = std::distance(this->cbegin(), position);
        void* pData = nullptr;
        Exception::checkThrow([&]() {
            pData = GblArrayList_insert(this, index, 1, nullptr);
        });
         T* pObj = new (pData) T(std::forward<Args>(args)...);
         return iterator(*this, index);
    }

◆ popBack()

template<typename T >

void gimbal::Vector< T >::popBack ( void )

inline

Definition at line 486 of file gimbal_vector.hpp.

                       {// throw if bullshit
        destruct_(this->getSize()-1, 1);
        erase(this->end()-1);
    }

◆ pop_back()

template<typename T >

void gimbal::Vector< T >::pop_back ( void )

inline

Definition at line 491 of file gimbal_vector.hpp.

                        {
        popBack();
    }

◆ erase() [1/2]

template<typename T >

iterator gimbal::Vector< T >::erase ( const_iterator pos )

inline

Definition at line 495 of file gimbal_vector.hpp.

                                       {
        return erase(pos, pos+1);
    }

◆ erase() [2/2]

template<typename T >

iterator gimbal::Vector< T >::erase	(	const_iterator	first,
		const_iterator	last
	)

inline

Definition at line 499 of file gimbal_vector.hpp.

                                                              {
        const auto index = std::distance<const_iterator>(this->begin(), first);
        const auto count = std::distance(first, last);
        destruct_(index, count);
        Exception::checkThrow(GblArrayList_erase(this, index, count));
        return iterator(*this, index+count);
    }

◆ clear()

template<typename T >

void gimbal::Vector< T >::clear ( void )

inline

Definition at line 507 of file gimbal_vector.hpp.

                     {
        destruct_(0, this->getSize());
        Exception::checkThrow(GblArrayList_clear(this));
    }

◆ assign() [1/6]

template<typename T >

void gimbal::Vector< T >::assign	(	const T *	pData,
		Size	elementCount
	)

inline

Definition at line 512 of file gimbal_vector.hpp.

                                                   {
        Exception::checkThrow(GblArrayList_assign(this, pData, elementCount));
    }

◆ assign() [2/6]

template<typename T >

void gimbal::Vector< T >::assign	(	gimbal::Size	size,
		const T &	value
	)

inline

Definition at line 516 of file gimbal_vector.hpp.

                                                 {
        T* pTempArray = static_cast<T*>(GBL_ALLOCA(size * sizeof(T)));
        std::fill(pTempArray, pTempArray+size, value);
        assign(pTempArray, size);
    }

◆ assign() [3/6]

template<typename T >

void gimbal::Vector< T >::assign ( const type_compatible_contiguous_container_readable< T > auto & c )

inline

Definition at line 522 of file gimbal_vector.hpp.

                                                                                {
        assign(c.data(), std::size(c));
    }

◆ assign() [4/6]

template<typename T >

void gimbal::Vector< T >::assign ( const type_compatible_container_readable< T > auto & c )

inline

Definition at line 526 of file gimbal_vector.hpp.

                                                                     {
        T* pTempArray = static_cast<T*>(GBL_ALLOCA(std::size(c) * sizeof(T)));
        std::copy(begin(c), end(c), pTempArray);
        Exception::checkThrow(GblArrayList_assign(this, pTempArray, std::size(c)));
    }

◆ assign() [5/6]

template<typename T >

void gimbal::Vector< T >::assign	(	const type_compatible_iterator_readable< T > auto &	first,
		const type_compatible_iterator_readable< T > auto &	last
	)

inline

Definition at line 532 of file gimbal_vector.hpp.

                                                                                                                               {
        const auto size = std::distance(first, last);
        T* pTempArray = static_cast<T*>(GBL_ALLOCA(size * sizeof(T)));
        std::copy(first, last, pTempArray);
        assign(pTempArray, size);
    }

◆ assign() [6/6]

template<typename T >

template<type_compatible_iterator_readable< T > It>
requires contiguous_iterator<It>

void gimbal::Vector< T >::assign	(	const It &	first,
		const It &	last
	)

inline

Definition at line 541 of file gimbal_vector.hpp.

                                                 {
 
            const T* pData = &first[0];
            const auto dist = std::distance(first, last);
 
        assign(pData, dist);
    }

◆ operator=() [1/5]

template<typename T >

const VectorType & gimbal::Vector< T >::operator= ( VectorView< T > rhs )

inline

Definition at line 549 of file gimbal_vector.hpp.

                                                   {
        Exception::checkThrow(GblArrayList_assign(this, rhs.data(), rhs.size()));
        return *this;
    }

◆ operator=() [2/5]

template<typename T >

const VectorType & gimbal::Vector< T >::operator= ( const VectorType & rhs )

inline

Definition at line 554 of file gimbal_vector.hpp.

                                                       {
        return *this = VectorView<T>(rhs);
    }

◆ operator=() [3/5]

template<typename T >

const VectorType & gimbal::Vector< T >::operator= ( VectorType && rhs )

inline

Definition at line 558 of file gimbal_vector.hpp.

                                                  {
        return *this = static_cast<GblArrayList&&>(rhs);
    }

◆ operator=() [4/5]

template<typename T >

const VectorType & gimbal::Vector< T >::operator= ( GblArrayList && rhs )

inline

Definition at line 562 of file gimbal_vector.hpp.

                                                    {
        VectorView<T> rhsView(rhs); //C++ wrapper "viewing" C object
 
        if(this->getContext() == rhsView.getContext() && rhsView.isHeap()) {
            give(take(&rhs));
        } else {
            *this = rhsView; //do regular-ass copy assignment for generic view
        }
        return *this;
    }

◆ operator=() [5/5]

template<typename T >

const VectorType & gimbal::Vector< T >::operator= ( const type_compatible_container< T > auto && c )

inline

Definition at line 573 of file gimbal_vector.hpp.

                                                                             {
        // check for supported move semantics!
#ifdef GBL_PMR_VECTOR
        if constexpr(std::same_as<decltype(c), gimbal::pmr::vector<T>&&>) {
            if(this->get_allocator() == c.get_allocator()) {
                assign(c);
            }
        } else {
#endif
            assign(c);
#ifdef GBL_PMR_VECTOR
        }
#endif
        return *this;
    }

◆ operator+=() [1/4]

template<typename T >

const VectorType & gimbal::Vector< T >::operator+= ( const type_compatible_container_readable< T > auto & view )

inline

Definition at line 589 of file gimbal_vector.hpp.

                                                                                         {
        insert(this->end(), view);
        return *this;
    }

◆ operator+=() [2/4]

template<typename T >

const VectorType & gimbal::Vector< T >::operator+= ( const type_compatible_iterator_readable< T > auto & it )

inline

Definition at line 594 of file gimbal_vector.hpp.

                                                                                      {
        insert(this->end(), it);
        return *this;
    }

◆ operator+=() [3/4]

template<typename T >

const VectorType & gimbal::Vector< T >::operator+= ( const T & value )

inline

Definition at line 599 of file gimbal_vector.hpp.

                                                 {
        insert(this->end(), 1, value);
        return *this;
    }

◆ operator+=() [4/4]

template<typename T >

const VectorType & gimbal::Vector< T >::operator+= ( VectorView< T > view )

inline

Definition at line 604 of file gimbal_vector.hpp.

                                                     {
        insert(this->end(), view.data(), view.size());
        return *this;
    }

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

gimbal_vector.hpp

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ VectorType

◆ VectorViewBaseType

◆ ViewType

◆ MoveValues

◆ iterator

◆ const_iterator

◆ difference_type

Constructor & Destructor Documentation

◆ Vector() [1/11]

◆ Vector() [2/11]

◆ Vector() [3/11]

◆ Vector() [4/11]

◆ Vector() [5/11]

◆ Vector() [6/11]

◆ Vector() [7/11]

◆ Vector() [8/11]

◆ Vector() [9/11]

◆ Vector() [10/11]

◆ Vector() [11/11]

◆ ~Vector()

Member Function Documentation

◆ destruct_()

◆ getVector_() [1/2]

◆ getVector_() [2/2]

◆ take() [1/2]

◆ take() [2/2]

◆ give()

◆ reserve()

◆ resize()

◆ shrink_to_fit()

◆ pushBack()

◆ push_back()

◆ emplace_back()

◆ pushFront()

◆ push_front()

◆ insert() [1/7]

◆ insert() [2/7]

◆ insert() [3/7]

◆ insert() [4/7]

◆ insert() [5/7]

◆ insert() [6/7]

◆ insert() [7/7]

◆ emplace()

◆ popBack()

◆ pop_back()

◆ erase() [1/2]

◆ erase() [2/2]

◆ clear()

◆ assign() [1/6]

◆ assign() [2/6]

◆ assign() [3/6]

◆ assign() [4/6]

◆ assign() [5/6]

◆ assign() [6/6]

◆ operator=() [1/5]

◆ operator=() [2/5]

◆ operator=() [3/5]

◆ operator=() [4/5]

◆ operator=() [5/5]

◆ operator+=() [1/4]

◆ operator+=() [2/4]

◆ operator+=() [3/4]

◆ operator+=() [4/4]