flatbuffers::vector_downward< SizeT > Class Template Reference

#include <vector_downward.h>

Public Member Functions
	vector_downward (size_t initial_size, Allocator *allocator, bool own_allocator, size_t buffer_minalign, const SizeT max_size=FLATBUFFERS_MAX_BUFFER_SIZE)
	vector_downward (vector_downward &&other) noexcept
vector_downward &	operator= (vector_downward &&other) noexcept
	~vector_downward ()
void	reset ()
void	clear ()
void	clear_scratch ()
void	clear_allocator ()
void	clear_buffer ()
uint8_t *	release_raw (size_t &allocated_bytes, size_t &offset)
DetachedBuffer	release ()
size_t	ensure_space (size_t len)
uint8_t *	make_space (size_t len)
Allocator *	get_custom_allocator ()
size_t	offset () const
SizeT	size () const
SizeT	unused_buffer_size () const
SizeT	scratch_size () const
size_t	capacity () const
uint8_t *	data () const
uint8_t *	scratch_data () const
uint8_t *	scratch_end () const
uint8_t *	data_at (size_t offset) const
void	push (const uint8_t *bytes, size_t num)
template<typename T >
void	push_small (const T &little_endian_t)
template<typename T >
void	scratch_push_small (const T &t)
void	fill (size_t zero_pad_bytes)
void	fill_big (size_t zero_pad_bytes)
void	pop (size_t bytes_to_remove)
void	scratch_pop (size_t bytes_to_remove)
void	swap (vector_downward &other)
void	swap_allocator (vector_downward &other)

Detailed Description

template<typename SizeT = uoffset_t>
class flatbuffers::vector_downward< SizeT >

Definition at line 35 of file vector_downward.h.

Constructor & Destructor Documentation

vector_downward() [1/2]

template<typename SizeT = uoffset_t>

flatbuffers::vector_downward< SizeT >::vector_downward ( size_t  initial_size, Allocator *  allocator, bool  own_allocator, size_t  buffer_minalign, const SizeT  max_size = FLATBUFFERS_MAX_BUFFER_SIZE  )

inlineexplicit

Definition at line 37 of file vector_downward.h.

      : allocator_(allocator),
        own_allocator_(own_allocator),
        initial_size_(initial_size),
        max_size_(max_size),
        buffer_minalign_(buffer_minalign),
        reserved_(0),
        size_(0),
        buf_(nullptr),
        cur_(nullptr),
        scratch_(nullptr) {}

vector_downward() [2/2]

template<typename SizeT = uoffset_t>

flatbuffers::vector_downward< SizeT >::vector_downward ( vector_downward< SizeT > &&  other )

inlinenoexcept

Definition at line 51 of file vector_downward.h.

      : allocator_(other.allocator_),
        own_allocator_(other.own_allocator_),
        initial_size_(other.initial_size_),
        max_size_(other.max_size_),
        buffer_minalign_(other.buffer_minalign_),
        reserved_(other.reserved_),
        size_(other.size_),
        buf_(other.buf_),
        cur_(other.cur_),
        scratch_(other.scratch_) {
    // No change in other.allocator_
    // No change in other.initial_size_
    // No change in other.buffer_minalign_
    other.own_allocator_ = false;
    other.reserved_ = 0;
    other.buf_ = nullptr;
    other.cur_ = nullptr;
    other.scratch_ = nullptr;
  }

~vector_downward()

template<typename SizeT = uoffset_t>

flatbuffers::vector_downward< SizeT >::~vector_downward ( )

inline

Definition at line 80 of file vector_downward.h.

                     {
    clear_buffer();
    clear_allocator();
  }

References flatbuffers::vector_downward< SizeT >::clear_allocator(), and flatbuffers::vector_downward< SizeT >::clear_buffer().

Member Function Documentation

capacity()

template<typename SizeT = uoffset_t>

size_t flatbuffers::vector_downward< SizeT >::capacity ( ) const

inline

Definition at line 176 of file vector_downward.h.

{ return reserved_; }

Referenced by flatbuffers::grpc::MessageBuilder::GetMessage(), and flatbuffers::grpc::MessageBuilder::MessageBuilder().

clear()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::clear ( )

inline

Definition at line 90 of file vector_downward.h.

               {
    if (buf_) {
      cur_ = buf_ + reserved_;
    } else {
      reserved_ = 0;
      cur_ = nullptr;
    }
    size_ = 0;
    clear_scratch();
  }

References flatbuffers::vector_downward< SizeT >::clear_scratch().

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::Clear(), flatbuffers::vector_downward< SizeT >::release(), flatbuffers::vector_downward< SizeT >::release_raw(), and flatbuffers::vector_downward< SizeT >::reset().

clear_allocator()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::clear_allocator ( )

inline

Definition at line 103 of file vector_downward.h.

                         {
    if (own_allocator_ && allocator_) { delete allocator_; }
    allocator_ = nullptr;
    own_allocator_ = false;
  }

Referenced by flatbuffers::vector_downward< SizeT >::~vector_downward().

clear_buffer()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::clear_buffer ( )

inline

Definition at line 109 of file vector_downward.h.

                      {
    if (buf_) Deallocate(allocator_, buf_, reserved_);
    buf_ = nullptr;
  }

References flatbuffers::Deallocate().

Referenced by flatbuffers::vector_downward< SizeT >::reset(), and flatbuffers::vector_downward< SizeT >::~vector_downward().

clear_scratch()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::clear_scratch ( )

inline

Definition at line 101 of file vector_downward.h.

{ scratch_ = buf_; }

Referenced by flatbuffers::vector_downward< SizeT >::clear(), and flatbuffers::FlatBufferBuilderImpl< Is64Aware >::Finish().

data()

template<typename SizeT = uoffset_t>

uint8_t * flatbuffers::vector_downward< SizeT >::data ( ) const

inline

Definition at line 178 of file vector_downward.h.

                        {
    FLATBUFFERS_ASSERT(cur_);
    return cur_;
  }

References FLATBUFFERS_ASSERT.

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::GetBufferPointer(), flatbuffers::FlatBufferBuilderImpl< Is64Aware >::GetBufferSpan(), flatbuffers::FlatBufferBuilderImpl< Is64Aware >::GetCurrentBufferPointer(), and flatbuffers::grpc::MessageBuilder::GetMessage().

data_at()

template<typename SizeT = uoffset_t>

uint8_t * flatbuffers::vector_downward< SizeT >::data_at ( size_t  offset ) const

inline

Definition at line 193 of file vector_downward.h.

{ return buf_ + reserved_ - offset; }

References flatbuffers::vector_downward< SizeT >::offset().

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::CreateUninitializedVector(), and flatbuffers::FlatBufferBuilderImpl< Is64Aware >::StringOffsetCompare::operator()().

ensure_space()

template<typename SizeT = uoffset_t>

size_t flatbuffers::vector_downward< SizeT >::ensure_space ( size_t  len )

inline

Definition at line 141 of file vector_downward.h.

                                  {
    FLATBUFFERS_ASSERT(cur_ >= scratch_ && scratch_ >= buf_);
    // If the length is larger than the unused part of the buffer, we need to
    // grow.
    if (len > unused_buffer_size()) { reallocate(len); }
    FLATBUFFERS_ASSERT(size() < max_size_);
    return len;
  }

References FLATBUFFERS_ASSERT, flatbuffers::vector_downward< SizeT >::size(), and flatbuffers::vector_downward< SizeT >::unused_buffer_size().

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::CreateVectorOfStrings(), flatbuffers::vector_downward< SizeT >::make_space(), and flatbuffers::vector_downward< SizeT >::scratch_push_small().

fill()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::fill ( size_t  zero_pad_bytes )

inline

Definition at line 213 of file vector_downward.h.

                                   {
    make_space(zero_pad_bytes);
    for (size_t i = 0; i < zero_pad_bytes; i++) cur_[i] = 0;
  }

References flatbuffers::vector_downward< SizeT >::make_space().

fill_big()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::fill_big ( size_t  zero_pad_bytes )

inline

Definition at line 220 of file vector_downward.h.

                                       {
    memset(make_space(zero_pad_bytes), 0, zero_pad_bytes);
  }

References flatbuffers::vector_downward< SizeT >::make_space().

get_custom_allocator()

template<typename SizeT = uoffset_t>

Allocator * flatbuffers::vector_downward< SizeT >::get_custom_allocator ( )

inline

Definition at line 160 of file vector_downward.h.

{ return allocator_; }

make_space()

template<typename SizeT = uoffset_t>

uint8_t * flatbuffers::vector_downward< SizeT >::make_space ( size_t  len )

inline

Definition at line 150 of file vector_downward.h.

                                         {
    if (len) {
      ensure_space(len);
      cur_ -= len;
      size_ += static_cast<SizeT>(len);
    }
    return cur_;
  }

References flatbuffers::vector_downward< SizeT >::ensure_space().

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::CreateUninitializedVector(), flatbuffers::vector_downward< SizeT >::fill(), flatbuffers::vector_downward< SizeT >::fill_big(), flatbuffers::vector_downward< SizeT >::push(), and flatbuffers::vector_downward< SizeT >::push_small().

offset()

template<typename SizeT = uoffset_t>

size_t flatbuffers::vector_downward< SizeT >::offset ( ) const

inline

Definition at line 163 of file vector_downward.h.

{ return cur_ - buf_; }

Referenced by flatbuffers::vector_downward< SizeT >::data_at(), and flatbuffers::vector_downward< SizeT >::release_raw().

operator=()

template<typename SizeT = uoffset_t>

vector_downward & flatbuffers::vector_downward< SizeT >::operator= ( vector_downward< SizeT > &&  other )

inlinenoexcept

Definition at line 73 of file vector_downward.h.

                                                               {
    // Move construct a temporary and swap idiom
    vector_downward temp(std::move(other));
    swap(temp);
    return *this;
  }

References flatbuffers::vector_downward< SizeT >::swap().

pop()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::pop ( size_t  bytes_to_remove )

inline

Definition at line 224 of file vector_downward.h.

                                   {
    cur_ += bytes_to_remove;
    size_ -= static_cast<SizeT>(bytes_to_remove);
  }

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::CreateSharedString().

push()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::push ( const uint8_t *  bytes, size_t  num  )

inline

Definition at line 195 of file vector_downward.h.

                                              {
    if (num > 0) { memcpy(make_space(num), bytes, num); }
  }

References flatbuffers::vector_downward< SizeT >::make_space().

push_small()

template<typename SizeT = uoffset_t>

template<typename T >

void flatbuffers::vector_downward< SizeT >::push_small ( const T &  little_endian_t )

inline

Definition at line 200 of file vector_downward.h.

                                                                 {
    make_space(sizeof(T));
    *reinterpret_cast<T *>(cur_) = little_endian_t;
  }

References flatbuffers::vector_downward< SizeT >::make_space().

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::CreateStruct().

release()

template<typename SizeT = uoffset_t>

DetachedBuffer flatbuffers::vector_downward< SizeT >::release ( )

inline

Definition at line 128 of file vector_downward.h.

                           {
    // allocator ownership (if any) is transferred to DetachedBuffer.
    DetachedBuffer fb(allocator_, own_allocator_, buf_, reserved_, cur_,
                      size());
    if (own_allocator_) {
      allocator_ = nullptr;
      own_allocator_ = false;
    }
    buf_ = nullptr;
    clear();
    return fb;
  }

References flatbuffers::vector_downward< SizeT >::clear(), and flatbuffers::vector_downward< SizeT >::size().

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::FLATBUFFERS_ATTRIBUTE(), and flatbuffers::FlatBufferBuilderImpl< Is64Aware >::Release().

release_raw()

template<typename SizeT = uoffset_t>

uint8_t * flatbuffers::vector_downward< SizeT >::release_raw ( size_t &  allocated_bytes, size_t &  offset  )

inline

Definition at line 115 of file vector_downward.h.

                                                                {
    auto *buf = buf_;
    allocated_bytes = reserved_;
    offset = vector_downward::offset();
 
    // release_raw only relinquishes the buffer ownership.
    // Does not deallocate or reset the allocator. Destructor will do that.
    buf_ = nullptr;
    clear();
    return buf;
  }

References flatbuffers::vector_downward< SizeT >::clear(), and flatbuffers::vector_downward< SizeT >::offset().

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::ReleaseRaw().

reset()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::reset ( )

inline

Definition at line 85 of file vector_downward.h.

               {
    clear_buffer();
    clear();
  }

References flatbuffers::vector_downward< SizeT >::clear(), and flatbuffers::vector_downward< SizeT >::clear_buffer().

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::Reset().

scratch_data()

template<typename SizeT = uoffset_t>

uint8_t * flatbuffers::vector_downward< SizeT >::scratch_data ( ) const

inline

Definition at line 183 of file vector_downward.h.

                                {
    FLATBUFFERS_ASSERT(buf_);
    return buf_;
  }

References FLATBUFFERS_ASSERT.

Referenced by flatbuffers::grpc::MessageBuilder::GetMessage(), and flatbuffers::grpc::MessageBuilder::MessageBuilder().

scratch_end()

template<typename SizeT = uoffset_t>

uint8_t * flatbuffers::vector_downward< SizeT >::scratch_end ( ) const

inline

Definition at line 188 of file vector_downward.h.

                               {
    FLATBUFFERS_ASSERT(scratch_);
    return scratch_;
  }

References FLATBUFFERS_ASSERT.

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::CreateVectorOfStrings().

scratch_pop()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::scratch_pop ( size_t  bytes_to_remove )

inline

Definition at line 229 of file vector_downward.h.

{ scratch_ -= bytes_to_remove; }

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::CreateVectorOfStrings().

scratch_push_small()

template<typename SizeT = uoffset_t>

template<typename T >

void flatbuffers::vector_downward< SizeT >::scratch_push_small ( const T &  t )

inline

Definition at line 205 of file vector_downward.h.

                                                           {
    ensure_space(sizeof(T));
    *reinterpret_cast<T *>(scratch_) = t;
    scratch_ += sizeof(T);
  }

References flatbuffers::vector_downward< SizeT >::ensure_space().

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::CreateVectorOfStrings().

scratch_size()

template<typename SizeT = uoffset_t>

SizeT flatbuffers::vector_downward< SizeT >::scratch_size ( ) const

inline

Definition at line 174 of file vector_downward.h.

{ return static_cast<SizeT>(scratch_ - buf_); }

size()

template<typename SizeT = uoffset_t>

SizeT flatbuffers::vector_downward< SizeT >::size ( ) const

inline

Definition at line 166 of file vector_downward.h.

{ return size_; }

Referenced by flatbuffers::FlatBufferBuilderImpl< Is64Aware >::CreateSharedString(), flatbuffers::vector_downward< SizeT >::ensure_space(), flatbuffers::FlatBufferBuilderImpl< Is64Aware >::GetBufferSpan(), flatbuffers::grpc::MessageBuilder::GetMessage(), flatbuffers::FlatBufferBuilderImpl< Is64Aware >::GetSize(), and flatbuffers::vector_downward< SizeT >::release().

swap()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::swap ( vector_downward< SizeT > &  other )

inline

Definition at line 231 of file vector_downward.h.

                                    {
    using std::swap;
    swap(allocator_, other.allocator_);
    swap(own_allocator_, other.own_allocator_);
    swap(initial_size_, other.initial_size_);
    swap(buffer_minalign_, other.buffer_minalign_);
    swap(reserved_, other.reserved_);
    swap(size_, other.size_);
    swap(max_size_, other.max_size_);
    swap(buf_, other.buf_);
    swap(cur_, other.cur_);
    swap(scratch_, other.scratch_);
  }

References flatbuffers::vector_downward< SizeT >::swap().

Referenced by flatbuffers::vector_downward< SizeT >::operator=(), flatbuffers::FlatBufferBuilderImpl< Is64Aware >::Swap(), flatbuffers::vector_downward< SizeT >::swap(), and flatbuffers::vector_downward< SizeT >::swap_allocator().

swap_allocator()

template<typename SizeT = uoffset_t>

void flatbuffers::vector_downward< SizeT >::swap_allocator ( vector_downward< SizeT > &  other )

inline

Definition at line 245 of file vector_downward.h.

                                              {
    using std::swap;
    swap(allocator_, other.allocator_);
    swap(own_allocator_, other.own_allocator_);
  }

References flatbuffers::vector_downward< SizeT >::swap().

Referenced by flatbuffers::grpc::MessageBuilder::Swap(), and flatbuffers::FlatBufferBuilderImpl< Is64Aware >::SwapBufAllocator().

unused_buffer_size()

template<typename SizeT = uoffset_t>

SizeT flatbuffers::vector_downward< SizeT >::unused_buffer_size ( ) const

inline

Definition at line 169 of file vector_downward.h.

                                   {
    return static_cast<SizeT>(cur_ - scratch_);
  }

Referenced by flatbuffers::vector_downward< SizeT >::ensure_space().

---

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

• onert-micro/externals/flatbuffers/vector_downward.h