terse::DynArray< T, TAllocator > Class Template Reference

Resizable array-like abstraction for trivial-types only. More...

#include <DynArray.h>

Inheritance diagram for terse::DynArray< T, TAllocator >:

Collaboration diagram for terse::DynArray< T, TAllocator >:

Public Types
using	value_type = T
using	allocator_type = TAllocator

Public Member Functions
	DynArray (const allocator_type &allocator)
	DynArray ()
	DynArray (std::size_t size, const allocator_type &allocator=allocator_type{})
	DynArray (std::size_t size, const value_type &value, const allocator_type &allocator=allocator_type{})
	DynArray (const value_type *source, std::size_t size, const allocator_type &allocator=allocator_type{})
template<typename TIterator >
	DynArray (TIterator start, TIterator end, const allocator_type &allocator=allocator_type{})
	~DynArray ()=default
	DynArray (const DynArray &rhs)
DynArray &	operator= (const DynArray &rhs)
	DynArray (DynArray &&rhs) noexcept
DynArray &	operator= (DynArray &&rhs) noexcept
allocator_type	get_allocator () const noexcept
void	clear ()
value_type *	data ()
const value_type *	data () const
std::size_t	size () const
bool	empty () const
value_type &	operator[] (std::size_t index)
const value_type &	operator[] (std::size_t index) const
value_type *	begin ()
value_type *	end ()
const value_type *	cbegin () const
const value_type *	cend () const
const value_type *	begin () const
const value_type *	end () const
void	resize (std::size_t size, const value_type &value)
void	resize (std::size_t size)
void	resize_uninitialized (std::size_t size)
template<typename TIterator >
void	assign (TIterator start, TIterator end)

Private Types
using	pointer_type = std::unique_ptr< value_type, std::function< void(value_type *)> >

Static Private Member Functions
static pointer_type	create (std::size_t size, allocator_type alloc)

Private Attributes
allocator_type	alloc
std::size_t	sz
pointer_type	ptr

Detailed Description

template<typename T, class TAllocator>
class terse::DynArray< T, TAllocator >

Resizable array-like abstraction for trivial-types only.

Member Typedef Documentation

allocator_type

template<typename T , class TAllocator >

using terse::DynArray< T, TAllocator >::allocator_type = TAllocator

pointer_type

template<typename T , class TAllocator >

using terse::DynArray< T, TAllocator >::pointer_type = std::unique_ptr<value_type, std::function<void (value_type*)> >

private

value_type

template<typename T , class TAllocator >

using terse::DynArray< T, TAllocator >::value_type = T

Constructor & Destructor Documentation

DynArray() [1/8]

template<typename T , class TAllocator >

terse::DynArray< T, TAllocator >::DynArray ( const allocator_type &  allocator )

inlineexplicit

                                                           :
            alloc{allocator},
            sz{},
            ptr{nullptr} {
        }

DynArray() [2/8]

template<typename T , class TAllocator >

terse::DynArray< T, TAllocator >::DynArray ( )

inline

                   : DynArray{allocator_type{}} {
        }

DynArray() [3/8]

template<typename T , class TAllocator >

terse::DynArray< T, TAllocator >::DynArray ( std::size_t  size, const allocator_type &  allocator = allocator_type{}  )

inline

                                                                                 {}) :
            alloc{allocator},
            sz{size},
            ptr{create(sz, alloc)} {
        }

DynArray() [4/8]

template<typename T , class TAllocator >

terse::DynArray< T, TAllocator >::DynArray ( std::size_t  size, const value_type &  value, const allocator_type &  allocator = allocator_type{}  )

inline

                                                                                                          {}) :
            DynArray{size, allocator} {
 
            std::fill_n(data(), size, value);
        }

DynArray() [5/8]

template<typename T , class TAllocator >

terse::DynArray< T, TAllocator >::DynArray ( const value_type *  source, std::size_t  size, const allocator_type &  allocator = allocator_type{}  )

inline

                                                                                                           {}) :
            DynArray{size, allocator} {
 
            if ((data() != nullptr) && (source != nullptr)) {
                std::memcpy(data(), source, size * sizeof(value_type));
            }
        }

DynArray() [6/8]

template<typename T , class TAllocator >

template<typename TIterator >

terse::DynArray< T, TAllocator >::DynArray ( TIterator  start, TIterator  end, const allocator_type &  allocator = allocator_type{}  )

inline

                                                                                                 {}) :
            DynArray{static_cast<std::size_t>(std::distance(start, end)), allocator} {
 
            #if defined(_MSC_VER) && !defined(__clang__)
                if (size() != 0ul) {
                    std::copy(start, end, stdext::checked_array_iterator<value_type*>(data(), size()));
                }
            #else
                std::copy(start, end, data());
            #endif
        }

~DynArray()

template<typename T , class TAllocator >

terse::DynArray< T, TAllocator >::~DynArray ( )

default

DynArray() [7/8]

template<typename T , class TAllocator >

terse::DynArray< T, TAllocator >::DynArray ( const DynArray< T, TAllocator > &  rhs )

inline

                                      : DynArray{rhs.size(), rhs.get_allocator()} {
            if ((data() != nullptr) && (rhs.data() != nullptr)) {
                std::memcpy(data(), rhs.data(), rhs.size() * sizeof(value_type));
            }
        }

References terse::DynArray< T, TAllocator >::data(), and terse::DynArray< T, TAllocator >::size().

DynArray() [8/8]

template<typename T , class TAllocator >

terse::DynArray< T, TAllocator >::DynArray ( DynArray< T, TAllocator > &&  rhs )

inlinenoexcept

                                          :
            alloc{},
            sz{},
            ptr{} {
 
            std::swap(alloc, rhs.alloc);
            std::swap(ptr, rhs.ptr);
            std::swap(sz, rhs.sz);
        }

Member Function Documentation

assign()

template<typename T , class TAllocator >

template<typename TIterator >

void terse::DynArray< T, TAllocator >::assign ( TIterator  start, TIterator  end  )

inline

                                                    {
            resize_uninitialized(static_cast<std::size_t>(std::distance(start, end)));
            #if defined(_MSC_VER) && !defined(__clang__)
                if (size() != 0ul) {
                    std::copy(start, end, stdext::checked_array_iterator<value_type*>(data(), size()));
                }
            #else
                std::copy(start, end, data());
            #endif
        }

References extd::copy(), terse::DynArray< T, TAllocator >::data(), terse::DynArray< T, TAllocator >::end(), terse::DynArray< T, TAllocator >::resize_uninitialized(), and terse::DynArray< T, TAllocator >::size().

begin() [1/2]

template<typename T , class TAllocator >

value_type * terse::DynArray< T, TAllocator >::begin ( )

inline

                            {
            return data();
        }

References terse::DynArray< T, TAllocator >::data().

Referenced by dna::JointFilter::apply(), dnac::JointFilter::apply(), terse::DynArray< T, TAllocator >::resize(), and dnac::ScaleCommand::Impl::scaleJointBehavior().

begin() [2/2]

template<typename T , class TAllocator >

const value_type * terse::DynArray< T, TAllocator >::begin ( ) const

inline

                                        {
            return cbegin();
        }

References terse::DynArray< T, TAllocator >::cbegin().

cbegin()

template<typename T , class TAllocator >

const value_type * terse::DynArray< T, TAllocator >::cbegin ( ) const

inline

                                         {
            return data();
        }

References terse::DynArray< T, TAllocator >::data().

Referenced by terse::DynArray< T, TAllocator >::begin().

cend()

template<typename T , class TAllocator >

const value_type * terse::DynArray< T, TAllocator >::cend ( ) const

inline

                                       {
            return data() + sz;
        }

References terse::DynArray< T, TAllocator >::data(), and terse::DynArray< T, TAllocator >::sz.

Referenced by terse::DynArray< T, TAllocator >::end().

clear()

template<typename T , class TAllocator >

void terse::DynArray< T, TAllocator >::clear ( )

inline

                     {
            ptr.reset();
            sz = 0ul;
        }

References terse::DynArray< T, TAllocator >::ptr, and terse::DynArray< T, TAllocator >::sz.

Referenced by dna::RawTextureCoordinateVector::clear(), dna::RawVertexLayoutVector::clear(), dnac::RawTextureCoordinateVector::clear(), and dnac::RawVertexLayoutVector::clear().

create()

template<typename T , class TAllocator >

static pointer_type terse::DynArray< T, TAllocator >::create ( std::size_t  size, allocator_type  alloc  )

inlinestaticprivate

                                                                         {
            return pointer_type{alloc.allocate(size), [alloc, size](value_type* p) mutable {
                                    alloc.deallocate(p, size);
                                }};
        }

References terse::DynArray< T, TAllocator >::alloc, and terse::DynArray< T, TAllocator >::size().

Referenced by terse::DynArray< T, TAllocator >::resize(), and terse::DynArray< T, TAllocator >::resize_uninitialized().

data() [1/2]

template<typename T , class TAllocator >

value_type * terse::DynArray< T, TAllocator >::data ( )

inline

                           {
            return ptr.get();
        }

References terse::DynArray< T, TAllocator >::ptr.

Referenced by terse::DynArray< T, TAllocator >::assign(), terse::DynArray< T, TAllocator >::begin(), terse::DynArray< T, TAllocator >::cbegin(), terse::DynArray< T, TAllocator >::cend(), terse::Blob< T, TAllocator >::data(), terse::DynArray< T, TAllocator >::DynArray(), terse::DynArray< T, TAllocator >::end(), and terse::DynArray< T, TAllocator >::operator[]().

data() [2/2]

template<typename T , class TAllocator >

const value_type * terse::DynArray< T, TAllocator >::data ( ) const

inline

                                       {
            return ptr.get();
        }

References terse::DynArray< T, TAllocator >::ptr.

empty()

template<typename T , class TAllocator >

bool terse::DynArray< T, TAllocator >::empty ( ) const

inline

                           {
            return (sz == 0ul);
        }

References terse::DynArray< T, TAllocator >::sz.

Referenced by dna::JointFilter::apply(), dnac::JointFilter::apply(), and dna::FilteredInputArchive::process().

end() [1/2]

template<typename T , class TAllocator >

value_type * terse::DynArray< T, TAllocator >::end ( )

inline

                          {
            return data() + sz;
        }

References terse::DynArray< T, TAllocator >::data(), and terse::DynArray< T, TAllocator >::sz.

Referenced by dna::JointFilter::apply(), dnac::JointFilter::apply(), and terse::DynArray< T, TAllocator >::assign().

end() [2/2]

template<typename T , class TAllocator >

const value_type * terse::DynArray< T, TAllocator >::end ( ) const

inline

                                      {
            return cend();
        }

References terse::DynArray< T, TAllocator >::cend().

get_allocator()

template<typename T , class TAllocator >

allocator_type terse::DynArray< T, TAllocator >::get_allocator ( ) const

inlinenoexcept

                                                      {
            return alloc;
        }

References terse::DynArray< T, TAllocator >::alloc.

Referenced by terse::Blob< T, TAllocator >::get_allocator().

operator=() [1/2]

template<typename T , class TAllocator >

DynArray & terse::DynArray< T, TAllocator >::operator= ( const DynArray< T, TAllocator > &  rhs )

inline

                                                 {
            DynArray tmp{rhs};
            std::swap(alloc, tmp.alloc);
            std::swap(ptr, tmp.ptr);
            std::swap(sz, tmp.sz);
            return *this;
        }

References terse::DynArray< T, TAllocator >::alloc, terse::DynArray< T, TAllocator >::ptr, and terse::DynArray< T, TAllocator >::sz.

operator=() [2/2]

template<typename T , class TAllocator >

DynArray & terse::DynArray< T, TAllocator >::operator= ( DynArray< T, TAllocator > &&  rhs )

inlinenoexcept

                                                     {
            std::swap(alloc, rhs.alloc);
            std::swap(ptr, rhs.ptr);
            std::swap(sz, rhs.sz);
            return *this;
        }

References terse::DynArray< T, TAllocator >::alloc, terse::DynArray< T, TAllocator >::ptr, and terse::DynArray< T, TAllocator >::sz.

operator[]() [1/2]

template<typename T , class TAllocator >

value_type & terse::DynArray< T, TAllocator >::operator[] ( std::size_t  index )

inline

                                                {
            assert(index < size());
            return data()[index];
        }

References terse::DynArray< T, TAllocator >::data(), and terse::DynArray< T, TAllocator >::size().

operator[]() [2/2]

template<typename T , class TAllocator >

const value_type & terse::DynArray< T, TAllocator >::operator[] ( std::size_t  index ) const

inline

                                                            {
            assert(index < size());
            return data()[index];
        }

References terse::DynArray< T, TAllocator >::data(), and terse::DynArray< T, TAllocator >::size().

resize() [1/2]

template<typename T , class TAllocator >

void terse::DynArray< T, TAllocator >::resize ( std::size_t  size )

inline

                                    {
            resize(size, value_type{});
        }

References terse::DynArray< T, TAllocator >::resize(), and terse::DynArray< T, TAllocator >::size().

resize() [2/2]

template<typename T , class TAllocator >

void terse::DynArray< T, TAllocator >::resize ( std::size_t  size, const value_type &  value  )

inline

                                                             {
            if (size > sz) {
                pointer_type old{ptr.release(), [this](value_type* p) {
                                     alloc.deallocate(p, sz);
                                 }};
                ptr = create(size, alloc);
                assert(ptr != nullptr);
                if (old != nullptr) {
                    std::memcpy(ptr.get(), old.get(), sz * sizeof(value_type));
                }
                std::fill_n(begin() + sz, size - sz, value);
            }
            sz = size;
        }

References terse::DynArray< T, TAllocator >::alloc, terse::DynArray< T, TAllocator >::begin(), terse::DynArray< T, TAllocator >::create(), terse::DynArray< T, TAllocator >::ptr, terse::DynArray< T, TAllocator >::size(), and terse::DynArray< T, TAllocator >::sz.

Referenced by dna::JointFilter::apply(), dnac::JointFilter::apply(), terse::ExtendableJSONInputArchive< TExtender, TStream, TSize, TOffset >::process(), and terse::DynArray< T, TAllocator >::resize().

resize_uninitialized()

template<typename T , class TAllocator >

void terse::DynArray< T, TAllocator >::resize_uninitialized ( std::size_t  size )

inline

                                                  {
            if (size > sz) {
                pointer_type old{ptr.release(), [this](value_type* p) {
                                     alloc.deallocate(p, sz);
                                 }};
                ptr = create(size, alloc);
                assert(ptr != nullptr);
                if (old != nullptr) {
                    std::memcpy(ptr.get(), old.get(), sz * sizeof(value_type));
                }
            }
            sz = size;
        }

References terse::DynArray< T, TAllocator >::alloc, terse::DynArray< T, TAllocator >::create(), terse::DynArray< T, TAllocator >::ptr, terse::DynArray< T, TAllocator >::size(), and terse::DynArray< T, TAllocator >::sz.

Referenced by dna::JointFilter::apply(), dnac::JointFilter::apply(), terse::DynArray< T, TAllocator >::assign(), terse::ExtendableJSONInputArchive< TExtender, TStream, TSize, TOffset >::process(), terse::ExtendableBinaryInputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::resize(), and terse::Blob< T, TAllocator >::setSize().

size()

template<typename T , class TAllocator >

std::size_t terse::DynArray< T, TAllocator >::size ( ) const

inline

                               {
            return sz;
        }

References terse::DynArray< T, TAllocator >::sz.

Referenced by dna::JointFilter::apply(), dnac::JointFilter::apply(), terse::DynArray< T, TAllocator >::assign(), terse::DynArray< T, TAllocator >::create(), terse::DynArray< T, TAllocator >::DynArray(), terse::DynArray< T, TAllocator >::operator[](), terse::ExtendableBinaryOutputArchive< TExtender, TStream, TSize, TOffset, EByteOrder >::process(), terse::ExtendableJSONInputArchive< TExtender, TStream, TSize, TOffset >::process(), dna::FilteredInputArchive::process(), terse::DynArray< T, TAllocator >::resize(), terse::DynArray< T, TAllocator >::resize_uninitialized(), dna::RawTextureCoordinateVector::size(), dna::RawVertexLayoutVector::size(), dnac::RawTextureCoordinateVector::size(), dnac::RawVertexLayoutVector::size(), and terse::Blob< T, TAllocator >::size().

Member Data Documentation

alloc

template<typename T , class TAllocator >

allocator_type terse::DynArray< T, TAllocator >::alloc

private

Referenced by terse::DynArray< T, TAllocator >::create(), terse::DynArray< T, TAllocator >::get_allocator(), terse::DynArray< T, TAllocator >::operator=(), terse::DynArray< T, TAllocator >::resize(), and terse::DynArray< T, TAllocator >::resize_uninitialized().

ptr

template<typename T , class TAllocator >

pointer_type terse::DynArray< T, TAllocator >::ptr

private

Referenced by terse::DynArray< T, TAllocator >::clear(), terse::DynArray< T, TAllocator >::data(), terse::DynArray< T, TAllocator >::operator=(), terse::DynArray< T, TAllocator >::resize(), and terse::DynArray< T, TAllocator >::resize_uninitialized().

sz

template<typename T , class TAllocator >

std::size_t terse::DynArray< T, TAllocator >::sz

private

Referenced by terse::DynArray< T, TAllocator >::cend(), terse::DynArray< T, TAllocator >::clear(), terse::DynArray< T, TAllocator >::empty(), terse::DynArray< T, TAllocator >::end(), terse::DynArray< T, TAllocator >::operator=(), terse::DynArray< T, TAllocator >::resize(), terse::DynArray< T, TAllocator >::resize_uninitialized(), and terse::DynArray< T, TAllocator >::size().

---

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

• DynArray.h