llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T > Struct Template Reference

Public Types
using	value_type = T
	Value type.
using	pointer = value_type *
	Pointer type.
using	const_pointer = typename std::pointer_traits< pointer >::template rebind< const value_type >
	Const pointer type.
using	difference_type = typename std::pointer_traits< pointer >::difference_type
	Difference type.
using	size_type = typename std::make_unsigned< difference_type >::type
	Size type.
using	reference = value_type &
	Reference type.
using	const_reference = const value_type &
	Const reference type.
using	iterator = pointer
	Iterator type.
using	const_iterator = const_pointer
	Const iterator type.
using	reverse_iterator = std::reverse_iterator< iterator >
	Reverse iterator type.
using	const_reverse_iterator = std::reverse_iterator< const_iterator >
	Const reverse iterator type.

Public Member Functions
constexpr	trivial_vector_impl ()
	Default constructor.
	trivial_vector_impl (size_type count, const value_type &v)
	Filling constructor of value_type
template<class InputIt >
	trivial_vector_impl (InputIt first, InputIt last)
	Range constructor.
	trivial_vector_impl (const trivial_vector_impl &)=delete
	Copy constructor disabled, use range constructor if you really want this.
trivial_vector_impl &	operator= (const trivial_vector_impl &)=delete
	Copy assigned disabled, use range constructor if you really want this.
	trivial_vector_impl (trivial_vector_impl &&o) noexcept
	Move constructor.
trivial_vector_impl &	operator= (trivial_vector_impl &&o) noexcept
	Move assignment.
	trivial_vector_impl (std::initializer_list< value_type > il)
	Initialiser list constructor.
void	assign (size_type count, const value_type &v)
	Assigns.
template<class InputIt >
void	assign (InputIt first, InputIt last)
	Assigns.
void	assign (std::initializer_list< value_type > il)
	Assigns.
reference	at (size_type i)
	Item index, bounds checked.
const_reference	at (size_type i) const
	Item index, bounds checked.
reference	operator[] (size_type i)
	Item index, unchecked.
const_reference	operator[] (size_type i) const
	Item index, unchecked.
reference	front ()
	First element.
const_reference	front () const
	First element.
reference	back ()
	Last element.
const_reference	back () const
	Last element.
pointer	data () noexcept
	Underlying array.
const_pointer	data () const noexcept
	Underlying array.
iterator	begin () noexcept
	Iterator to first item.
const_iterator	begin () const noexcept
	Iterator to first item.
const_iterator	cbegin () const noexcept
	Iterator to first item.
iterator	end () noexcept
	Iterator to after last item.
const_iterator	end () const noexcept
	Iterator to after last item.
const_iterator	cend () const noexcept
	Iterator to after last item.
reverse_iterator	rbegin () noexcept
	Iterator to last item.
const_reverse_iterator	rbegin () const noexcept
	Iterator to last item.
const_reverse_iterator	crbegin () const noexcept
	Iterator to last item.
reverse_iterator	rend () noexcept
	Iterator to before first item.
const_reverse_iterator	rend () const noexcept
	Iterator to before first item.
const_reverse_iterator	crend () const noexcept
	Iterator to before first item.
bool	empty () const noexcept
	If empty.
size_type	size () const noexcept
	Items in container.
size_type	max_size () const noexcept
	Maximum items in container.
void	reserve (size_type n)
	Increase capacity.
size_type	capacity () const noexcept
	Items can be stored until storage expanded.
void	shrink_to_fit ()
	Removes unused capacity.
void	clear () noexcept
	Clears container.
iterator	insert (const_iterator pos, const value_type &v)
	Inserts item.
iterator	insert (const_iterator pos, value_type &&v)
	Inserts item.
iterator	insert (const_iterator pos, size_type count, const value_type &v)
	Inserts items.
template<class InputIt >
iterator	insert (const_iterator pos, InputIt first, InputIt last)
	Inserts items.
iterator	insert (const_iterator pos, std::initializer_list< value_type > il)
	Inserts items.
template<class... Args>
iterator	emplace (const_iterator pos, Args &&... args)
	Emplace item.
iterator	erase (const_iterator pos)
	Erases item.
iterator	erase (const_iterator first, const_iterator last)
	Erases items.
void	push_back (const value_type &v)
	Appends item.
void	push_back (value_type &&v)
	Appends item.
template<class... Args>
reference	emplace_back (Args &&... args)
	Appends item.
void	pop_back ()
	Removes last element.
void	resize (size_type count, const value_type &v)
	Resizes container.
void	swap (trivial_vector_impl &o) noexcept
	Swaps.

Constructor & Destructor Documentation

trivial_vector_impl() [1/4]

template<bool has_default_construction, class T >

constexpr llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::trivial_vector_impl ( )

inlineconstexpr

Default constructor.

{}  // NOLINT

trivial_vector_impl() [2/4]

template<bool has_default_construction, class T >

llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::trivial_vector_impl ( size_type  count, const value_type &  v  )

inline

Filling constructor of value_type

{ insert(begin(), count, v); }

trivial_vector_impl() [3/4]

template<bool has_default_construction, class T >

template<class InputIt >

llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::trivial_vector_impl ( InputIt  first, InputIt  last  )

inline

Range constructor.

{ insert(begin(), first, last); }

trivial_vector_impl() [4/4]

template<bool has_default_construction, class T >

llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::trivial_vector_impl ( trivial_vector_impl< has_default_construction, T > &&  o )

inlinenoexcept

Move constructor.

                                                            : _sh(std::move(o._sh)), _mh(std::move(o._mh)), _begin(o._begin), _end(o._end), _capacity(o._capacity)
      {
        _mh.set_section(&_sh);
        o._begin = o._end = o._capacity = nullptr;
      }

~trivial_vector_impl()

template<bool has_default_construction, class T >

llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::~trivial_vector_impl ( )

inline

{ clear(); }

Member Function Documentation

assign() [1/3]

template<bool has_default_construction, class T >

template<class InputIt >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::assign ( InputIt  first, InputIt  last  )

inline

Assigns.

      {
        clear();
        insert(begin(), first, last);
      }

assign() [2/3]

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::assign ( size_type  count, const value_type &  v  )

inline

Assigns.

      {
        clear();
        insert(begin(), count, v);
      }

assign() [3/3]

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::assign ( std::initializer_list< value_type >  il )

inline

Assigns.

{ assign(il.begin(), il.end()); }

at() [1/2]

template<bool has_default_construction, class T >

reference llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::at ( size_type  i )

inline

Item index, bounds checked.

      {
        if(i >= size())
        {
          LLFIO_EXCEPTION_THROW(std::out_of_range("bounds exceeded"));  // NOLINT
        }
        return _begin[i];
      }

at() [2/2]

template<bool has_default_construction, class T >

const_reference llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::at ( size_type  i ) const

inline

Item index, bounds checked.

      {
        if(i >= size())
        {
          LLFIO_EXCEPTION_THROW(std::out_of_range("bounds exceeded"));  // NOLINT
        }
        return _begin[i];
      }

back() [1/2]

template<bool has_default_construction, class T >

reference llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::back ( )

inline

Last element.

{ return _end[-1]; }

back() [2/2]

template<bool has_default_construction, class T >

const_reference llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::back ( ) const

inline

Last element.

{ return _end[-1]; }

begin() [1/2]

template<bool has_default_construction, class T >

const_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::begin ( ) const

inlinenoexcept

Iterator to first item.

{ return const_iterator(_begin); }

begin() [2/2]

template<bool has_default_construction, class T >

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::begin ( )

inlinenoexcept

Iterator to first item.

{ return iterator(_begin); }

capacity()

template<bool has_default_construction, class T >

size_type llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::capacity ( ) const

inlinenoexcept

Items can be stored until storage expanded.

{ return _capacity - _begin; }

cbegin()

template<bool has_default_construction, class T >

const_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::cbegin ( ) const

inlinenoexcept

Iterator to first item.

{ return const_iterator(_begin); }

cend()

template<bool has_default_construction, class T >

const_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::cend ( ) const

inlinenoexcept

Iterator to after last item.

{ return const_iterator(_end); }

clear()

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::clear ( )

inlinenoexcept

Clears container.

      {
        // Trivially copyable means trivial destructor
        _end = _begin;
      }

crbegin()

template<bool has_default_construction, class T >

const_reverse_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::crbegin ( ) const

inlinenoexcept

Iterator to last item.

{ return const_reverse_iterator(end()); }

crend()

template<bool has_default_construction, class T >

const_reverse_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::crend ( ) const

inlinenoexcept

Iterator to before first item.

{ return const_reverse_iterator(begin()); }

data() [1/2]

template<bool has_default_construction, class T >

const_pointer llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::data ( ) const

inlinenoexcept

Underlying array.

{ return _begin; }

data() [2/2]

template<bool has_default_construction, class T >

pointer llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::data ( )

inlinenoexcept

Underlying array.

{ return _begin; }

emplace()

template<bool has_default_construction, class T >

template<class... Args>

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::emplace ( const_iterator  pos, Args &&...  args  )

inline

Emplace item.

      {
        if(capacity() == size())
        {
          reserve(_scale_capacity(capacity()));
        }
        // Trivially copyable, so memmove
        memmove(pos._v + 1, pos._v, (_end - pos._v) * sizeof(value_type));
        // BUT complex constructors may throw!
        LLFIO_EXCEPTION_TRY
        {
          new(pos._v) value_type(std::forward<Args>(args)...);
        }
        LLFIO_EXCEPTION_CATCH_ALL
        {
          memmove(pos._v, pos._v + 1, (_end - pos._v) * sizeof(value_type));
          LLFIO_EXCEPTION_RETHROW;
        }
        ++_end;
        return iterator(pos._v);
      }

emplace_back()

template<bool has_default_construction, class T >

template<class... Args>

reference llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::emplace_back ( Args &&...  args )

inline

Appends item.

      {
        if(_end == _capacity)
        {
          reserve(_scale_capacity(capacity()));
        }
        new(_end) value_type(std::forward<Args>(args)...);
        ++_end;
        return *(_end - 1);
      }

empty()

template<bool has_default_construction, class T >

bool llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::empty ( ) const

inlinenoexcept

If empty.

{ return _end == _begin; }

end() [1/2]

template<bool has_default_construction, class T >

const_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::end ( ) const

inlinenoexcept

Iterator to after last item.

{ return const_iterator(_end); }

end() [2/2]

template<bool has_default_construction, class T >

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::end ( )

inlinenoexcept

Iterator to after last item.

{ return iterator(_end); }

erase() [1/2]

template<bool has_default_construction, class T >

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::erase ( const_iterator  first, const_iterator  last  )

inline

Erases items.

      {
        // Trivially copyable
        memmove(first._v, last._v, (_end - last._v) * sizeof(value_type));
        _end -= last._v - first._v;
        return iterator(first._v);
      }

erase() [2/2]

template<bool has_default_construction, class T >

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::erase ( const_iterator  pos )

inline

Erases item.

      {
        // Trivially copyable
        memmove(pos._v, pos._v + 1, ((_end - 1) - pos._v) * sizeof(value_type));
        --_end;
        return iterator(pos._v);
      }

front() [1/2]

template<bool has_default_construction, class T >

reference llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::front ( )

inline

First element.

{ return _begin[0]; }

front() [2/2]

template<bool has_default_construction, class T >

const_reference llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::front ( ) const

inline

First element.

{ return _begin[0]; }

insert() [1/5]

template<bool has_default_construction, class T >

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::insert ( const_iterator  pos, const value_type &  v  )

inline

Inserts item.

{ return emplace(pos, v); }

insert() [2/5]

template<bool has_default_construction, class T >

template<class InputIt >

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::insert ( const_iterator  pos, InputIt  first, InputIt  last  )

inline

Inserts items.

      {
        size_type count = std::distance(first, last);
        {
          size_type cap = capacity();
          while(size() + count < cap)
          {
            cap = _scale_capacity(cap);
          }
          reserve(cap);
        }
        // Trivially copyable, so memmove and we know copy construction can't fail
        memmove(pos._v + count, pos._v, (_end - pos._v) * sizeof(value_type));
        for(size_type n = 0; n < count; n++)
        {
          new(pos._v + n) value_type(*first++);
        }
        _end += count;
        return iterator(pos._v);
      }

insert() [3/5]

template<bool has_default_construction, class T >

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::insert ( const_iterator  pos, size_type  count, const value_type &  v  )

inline

Inserts items.

      {
        {
          size_type cap = capacity();
          while(size() + count < cap)
          {
            cap = _scale_capacity(cap);
          }
          reserve(cap);
        }
        // Trivially copyable, so memmove and we know copy construction can't fail
        memmove(pos._v + count, pos._v, (_end - pos._v) * sizeof(value_type));
        for(size_type n = 0; n < count; n++)
        {
          new(pos._v + n) value_type(v);
        }
        _end += count;
        return iterator(pos._v);
      }

insert() [4/5]

template<bool has_default_construction, class T >

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::insert ( const_iterator  pos, std::initializer_list< value_type >  il  )

inline

Inserts items.

{ return insert(pos, il.begin(), il.end()); }

insert() [5/5]

template<bool has_default_construction, class T >

iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::insert ( const_iterator  pos, value_type &&  v  )

inline

Inserts item.

{ return emplace(pos, std::move(v)); }

max_size()

template<bool has_default_construction, class T >

size_type llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::max_size ( ) const

inlinenoexcept

Maximum items in container.

{ return static_cast<map_handle::size_type>(-1) / sizeof(T); }

operator=()

template<bool has_default_construction, class T >

trivial_vector_impl & llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::operator= ( trivial_vector_impl< has_default_construction, T > &&  o )

inlinenoexcept

Move assignment.

      {
        if(this == &o)
        {
          return *this;
        }
        this->~trivial_vector_impl();
        new(this) trivial_vector_impl(std::move(o));
        return *this;
      }

operator[]() [1/2]

template<bool has_default_construction, class T >

reference llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::operator[] ( size_type  i )

inline

Item index, unchecked.

{ return _begin[i]; }

operator[]() [2/2]

template<bool has_default_construction, class T >

const_reference llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::operator[] ( size_type  i ) const

inline

Item index, unchecked.

{ return _begin[i]; }

pop_back()

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::pop_back ( )

inline

Removes last element.

      {
        if(!empty())
        {
          --_end;
        }
      }

push_back() [1/2]

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::push_back ( const value_type &  v )

inline

Appends item.

      {
        if(_end == _capacity)
        {
          reserve(_scale_capacity(capacity()));
        }
        new(_end++) value_type(v);
      }

push_back() [2/2]

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::push_back ( value_type &&  v )

inline

Appends item.

{ push_back(v); }

rbegin() [1/2]

template<bool has_default_construction, class T >

const_reverse_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::rbegin ( ) const

inlinenoexcept

Iterator to last item.

{ return const_reverse_iterator(end()); }

rbegin() [2/2]

template<bool has_default_construction, class T >

reverse_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::rbegin ( )

inlinenoexcept

Iterator to last item.

{ return reverse_iterator(end()); }

rend() [1/2]

template<bool has_default_construction, class T >

const_reverse_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::rend ( ) const

inlinenoexcept

Iterator to before first item.

{ return const_reverse_iterator(begin()); }

rend() [2/2]

template<bool has_default_construction, class T >

reverse_iterator llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::rend ( )

inlinenoexcept

Iterator to before first item.

{ return reverse_iterator(begin()); }

reserve()

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::reserve ( size_type  n )

inline

Increase capacity.

      {
        if(n > max_size())
        {
          LLFIO_EXCEPTION_THROW(std::length_error("Max size exceeded"));  // NOLINT
        }
        size_type current_size = size();
        size_type bytes = n * sizeof(value_type);
        bytes = utils::round_up_to_page_size(bytes, utils::page_size());
        if(!_sh.is_valid())
        {
          _sh = section_handle::section(bytes).value();
          _mh = map_handle::map(_sh, bytes).value();
        }
        else if(n > capacity())
        {
          // We can always grow a section even with maps open on it
          _sh.truncate(bytes).value();
          // Attempt to resize the map in place
          if(!_mh.truncate(bytes, true))
          {
            // std::cerr << "truncate fail" << std::endl;
            // If can't resize, close the map and reopen it into a new address
            _mh.close().value();
            _mh = map_handle::map(_sh, bytes).value();
          }
        }
        else
        {
          return;
        }
        _begin = reinterpret_cast<pointer>(_mh.address());
        _capacity = reinterpret_cast<pointer>(_mh.address() + bytes);
        _end = _begin + current_size;
      }

resize()

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::resize ( size_type  count, const value_type &  v  )

inline

Resizes container.

      {
        if(count < size())
        {
          // Trivially copyable means trivial destructor
          _end = _begin + count;
          return;
        }
        if(count > capacity())
        {
          reserve(count);
        }
        // TODO(ned): Kinda assuming the compiler will do the right thing below, should really check that
        while(count - size() >= 16)
        {
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
          new(_end++) value_type(v);
        }
        while(count > size())
        {
          new(_end++) value_type(v);
        }
      }

shrink_to_fit()

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::shrink_to_fit ( )

inline

Removes unused capacity.

      {
        size_type current_size = size();
        size_type bytes = current_size * sizeof(value_type);
        bytes = utils::round_up_to_page_size(bytes, _mh.page_size());
        if(bytes / sizeof(value_type) == capacity())
        {
          return;
        }
        if(bytes == 0)
        {
          _mh.close().value();
          _sh.close().value();
          _begin = _end = _capacity = nullptr;
          return;
        }
        _mh.close().value();
        _sh.truncate(bytes).value();
        _mh = map_handle::map(_sh, bytes).value();
        _begin = reinterpret_cast<pointer>(_mh.address());
        _capacity = reinterpret_cast<pointer>(_mh.address() + bytes);
        _end = _begin + current_size;
      }

size()

template<bool has_default_construction, class T >

size_type llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::size ( ) const

inlinenoexcept

Items in container.

{ return _end - _begin; }

swap()

template<bool has_default_construction, class T >

void llfio_v2_xxx::algorithm::impl::trivial_vector_impl< has_default_construction, T >::swap ( trivial_vector_impl< has_default_construction, T > &  o )

inlinenoexcept

Swaps.

      {
        using namespace std;
        swap(_sh, o._sh);
        swap(_mh, o._mh);
        swap(_begin, o._begin);
        swap(_end, o._end);
        swap(_capacity, o._capacity);
      }

---

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

• include/llfio/v2.0/algorithm/trivial_vector.hpp