flatbuffers::grpc::MessageBuilder Class Reference

#include <grpc.h>

Collaboration diagram for flatbuffers::grpc::MessageBuilder:

Public Member Functions
	MessageBuilder (uoffset_t initial_size=1024)
	MessageBuilder (const MessageBuilder &other)=delete
MessageBuilder &	operator= (const MessageBuilder &other)=delete
	MessageBuilder (MessageBuilder &&other)
	MessageBuilder (FlatBufferBuilder &&src, void(*dealloc)(void *, size_t)=&DefaultAllocator::dealloc)
	Create a MessageBuilder from a FlatBufferBuilder.
MessageBuilder &	operator= (FlatBufferBuilder &&src)
MessageBuilder &	operator= (MessageBuilder &&other)
void	Swap (MessageBuilder &other)
uint8_t *	ReleaseRaw (size_t &size, size_t &offset, ::grpc::Slice &slice)
	~MessageBuilder ()
template<class T >
Message< T >	GetMessage ()
template<class T >
Message< T >	ReleaseMessage ()
Public Member Functions inherited from flatbuffers::FlatBufferBuilderImpl< false >
	FlatBufferBuilderImpl (size_t initial_size=1024, Allocator *allocator=nullptr, bool own_allocator=false, size_t buffer_minalign=AlignOf< largest_scalar_t >())
	Default constructor for FlatBufferBuilder.
	FlatBufferBuilderImpl (FlatBufferBuilderImpl &&other) noexcept
	Move constructor for FlatBufferBuilder.
FlatBufferBuilderImpl &	operator= (FlatBufferBuilderImpl &&other) noexcept
	Move assignment operator for FlatBufferBuilder.
void	Swap (FlatBufferBuilderImpl &other)
	~FlatBufferBuilderImpl ()
void	Reset ()
void	Clear ()
	Reset all the state in this FlatBufferBuilder so it can be reused to construct another buffer.
SizeT	GetSize () const
	The current size of the serialized buffer, counting from the end.
std::enable_if< is_64, uoffset_t >::type	GetSizeRelative32BitRegion () const
	The current size of the serialized buffer relative to the end of the 32-bit region.
std::enable_if<!is_64, uoffset_t >::type	GetSizeRelative32BitRegion () const
uint8_t *	GetBufferPointer () const
	Get the serialized buffer (after you call Finish()).
flatbuffers::span< uint8_t >	GetBufferSpan () const
	Get the serialized buffer (after you call Finish()) as a span.
uint8_t *	GetCurrentBufferPointer () const
	Get a pointer to an unfinished buffer.
	FLATBUFFERS_ATTRIBUTE () DetachedBuffer ReleaseBufferPointer()
	Get the released pointer to the serialized buffer.
DetachedBuffer	Release ()
	Get the released DetachedBuffer.
uint8_t *	ReleaseRaw (size_t &size, size_t &offset)
	Get the released pointer to the serialized buffer.
size_t	GetBufferMinAlignment () const
	get the minimum alignment this buffer needs to be accessed properly. This is only known once all elements have been written (after you call Finish()). You can use this information if you need to embed a FlatBuffer in some other buffer, such that you can later read it without first having to copy it into its own buffer.
void	ForceDefaults (bool fd)
	In order to save space, fields that are set to their default value don't get serialized into the buffer.
void	DedupVtables (bool dedup)
	By default vtables are deduped in order to save space.
OffsetT< String >	CreateString (const char *str, size_t len)
	Store a string in the buffer, which can contain any binary data.
OffsetT< String >	CreateString (const char *str)
	Store a string in the buffer, which is null-terminated.
OffsetT< String >	CreateString (char *str)
	Store a string in the buffer, which is null-terminated.
OffsetT< String >	CreateString (const std::string &str)
	Store a string in the buffer, which can contain any binary data.
OffsetT< String >	CreateString (const String *str)
	Store a string in the buffer, which can contain any binary data.
OffsetT< String >	CreateString (const T &str)
	Store a string in the buffer, which can contain any binary data.
Offset< String >	CreateSharedString (const char *str, size_t len)
	Store a string in the buffer, which can contain any binary data. If a string with this exact contents has already been serialized before, instead simply returns the offset of the existing string. This uses a map stored on the heap, but only stores the numerical offsets.
Offset< String >	CreateSharedString (const char *str)
	Store a string in the buffer, which null-terminated. If a string with this exact contents has already been serialized before, instead simply returns the offset of the existing string. This uses a map stored on the heap, but only stores the numerical offsets.
Offset< String >	CreateSharedString (const std::string &str)
	Store a string in the buffer, which can contain any binary data. If a string with this exact contents has already been serialized before, instead simply returns the offset of the existing string. This uses a map stored on the heap, but only stores the numerical offsets.
Offset< String >	CreateSharedString (const String *str)
	Store a string in the buffer, which can contain any binary data. If a string with this exact contents has already been serialized before, instead simply returns the offset of the existing string. This uses a map stored on the heap, but only stores the numerical offsets.
OffsetT< VectorT< T > >	CreateVector (const T *v, size_t len)
	Serialize an array into a FlatBuffer vector.
Offset< Vector< T > >	CreateVector (const C &array)
	Serialize an array like object into a FlatBuffer vector.
Offset< Vector< T > >	CreateVector (std::initializer_list< T > v)
	Serialize an initializer list into a FlatBuffer vector.
Offset< Vector< Offset< T > > >	CreateVector (const Offset< T > *v, size_t len)
Offset< Vector< T > >	CreateVector (const std::vector< T, Alloc > &v)
	Serialize a std::vector into a FlatBuffer vector.
Offset< Vector< uint8_t > >	CreateVector (const std::vector< bool > &v)
Offset< Vector< T > >	CreateVector (size_t vector_size, const std::function< T(size_t i)> &f)
	Serialize values returned by a function into a FlatBuffer vector. This is a convenience function that takes care of iteration for you.
Offset< Vector< T > >	CreateVector (size_t vector_size, F f, S *state)
	Serialize values returned by a function into a FlatBuffer vector. This is a convenience function that takes care of iteration for you. This uses a vector stored on the heap to store the intermediate results of the iteration.
Offset64< VectorT< T > >	CreateVector64 (const std::vector< T > &v)
Offset< Vector< Offset< String > > >	CreateVectorOfStrings (const std::vector< StringType, Alloc > &v)
	Serialize a std::vector<StringType> into a FlatBuffer vector. whereas StringType is any type that is accepted by the CreateString() overloads. This is a convenience function for a common case.
Offset< Vector< Offset< String > > >	CreateVectorOfStrings (It begin, It end)
	Serialize a collection of Strings into a FlatBuffer vector. This is a convenience function for a common case.
OffsetT< VectorT< const T * > >	CreateVectorOfStructs (const T *v, size_t len)
	Serialize an array of structs into a FlatBuffer vector.
Offset< Vector< const T * > >	CreateVectorOfStructs (size_t vector_size, const std::function< void(size_t i, T *)> &filler)
	Serialize an array of structs into a FlatBuffer vector.
Offset< Vector< const T * > >	CreateVectorOfStructs (size_t vector_size, F f, S *state)
	Serialize an array of structs into a FlatBuffer vector.
OffsetT< VectorT< const T * > >	CreateVectorOfStructs (const std::vector< T, Alloc > &v)
	Serialize a std::vector of structs into a FlatBuffer vector.
Offset64< VectorT< const T * > >	CreateVectorOfStructs64 (const std::vector< T > &v)
Offset< Vector< const T * > >	CreateVectorOfNativeStructs (const S *v, size_t len, T(*const pack_func)(const S &))
	Serialize an array of native structs into a FlatBuffer vector.
Offset< Vector< const T * > >	CreateVectorOfNativeStructs (const S *v, size_t len)
	Serialize an array of native structs into a FlatBuffer vector.
Offset< Vector< const T * > >	CreateVectorOfNativeStructs (const std::vector< S, Alloc > &v, T(*const pack_func)(const S &))
	Serialize a std::vector of native structs into a FlatBuffer vector.
Offset< Vector< const T * > >	CreateVectorOfNativeStructs (const std::vector< S, Alloc > &v)
	Serialize a std::vector of native structs into a FlatBuffer vector.
Offset< Vector< const T * > >	CreateVectorOfSortedStructs (std::vector< T, Alloc > *v)
	Serialize a std::vector of structs into a FlatBuffer vector in sorted order.
Offset< Vector< const T * > >	CreateVectorOfSortedStructs (T *v, size_t len)
	Serialize an array of structs into a FlatBuffer vector in sorted order.
Offset< Vector< const T * > >	CreateVectorOfSortedNativeStructs (std::vector< S, Alloc > *v)
	Serialize a std::vector of native structs into a FlatBuffer vector in sorted order.
Offset< Vector< const T * > >	CreateVectorOfSortedNativeStructs (S *v, size_t len)
	Serialize an array of native structs into a FlatBuffer vector in sorted order.
Offset< Vector< Offset< T > > >	CreateVectorOfSortedTables (Offset< T > *v, size_t len)
	Serialize an array of table offsets as a vector in the buffer in sorted order.
Offset< Vector< Offset< T > > >	CreateVectorOfSortedTables (std::vector< Offset< T >, Alloc > *v)
	Serialize an array of table offsets as a vector in the buffer in sorted order.
uoffset_t	CreateUninitializedVector (size_t len, size_t elemsize, size_t alignment, uint8_t **buf)
	Specialized version of CreateVector for non-copying use cases. Write the data any time later to the returned buffer pointer buf.
uoffset_t	CreateUninitializedVector (size_t len, size_t elemsize, uint8_t **buf)
Offset< Vector< T > >	CreateUninitializedVector (size_t len, T **buf)
	Specialized version of CreateVector for non-copying use cases. Write the data any time later to the returned buffer pointer buf.
Offset< Vector< const T * > >	CreateUninitializedVectorOfStructs (size_t len, T **buf)
Offset< Vector< T > >	CreateVectorScalarCast (const U *v, size_t len)
Offset< const T * >	CreateStruct (const T &structobj)
	Write a struct by itself, typically to be part of a union.
void	Finish (Offset< T > root, const char *file_identifier=nullptr)
	Finish serializing a buffer by writing the root offset.
void	FinishSizePrefixed (Offset< T > root, const char *file_identifier=nullptr)
	Finish a buffer with a 32 bit size field pre-fixed (size of the buffer following the size field). These buffers are NOT compatible with standard buffers created by Finish, i.e. you can't call GetRoot on them, you have to use GetSizePrefixedRoot instead. All >32 bit quantities in this buffer will be aligned when the whole size pre-fixed buffer is aligned. These kinds of buffers are useful for creating a stream of FlatBuffers.
void	SwapBufAllocator (FlatBufferBuilderImpl &other)

Additional Inherited Members
Public Types inherited from flatbuffers::FlatBufferBuilderImpl< false >
typedef std::conditional< Is64Aware, uoffset64_t, uoffset_t >::type	SizeT
Static Public Attributes inherited from flatbuffers::FlatBufferBuilderImpl< false >
static const size_t	kFileIdentifierLength
	The length of a FlatBuffer file header.
Protected Types inherited from flatbuffers::FlatBufferBuilderImpl< false >
typedef std::set< Offset< String >, StringOffsetCompare >	StringOffsetMap
Protected Member Functions inherited from flatbuffers::FlatBufferBuilderImpl< false >
	FlatBufferBuilderImpl (const FlatBufferBuilderImpl &)
FlatBufferBuilderImpl &	operator= (const FlatBufferBuilderImpl &)
void	Finish (uoffset_t root, const char *file_identifier, bool size_prefix)
Protected Attributes inherited from flatbuffers::FlatBufferBuilderImpl< false >
vector_downward< SizeT >	buf_
uoffset_t	num_field_loc
voffset_t	max_voffset_
size_t	length_of_64_bit_region_
bool	nested
bool	finished
size_t	minalign_
bool	force_defaults_
bool	dedup_vtables_
StringOffsetMap *	string_pool

Detailed Description

Definition at line 150 of file grpc.h.

Constructor & Destructor Documentation

MessageBuilder() [1/4]

flatbuffers::grpc::MessageBuilder::MessageBuilder ( uoffset_t  initial_size = 1024 )

inlineexplicit

Definition at line 153 of file grpc.h.

      : FlatBufferBuilder(initial_size, &slice_allocator_, false) {}

MessageBuilder() [2/4]

flatbuffers::grpc::MessageBuilder::MessageBuilder ( const MessageBuilder &  other )

delete

MessageBuilder() [3/4]

flatbuffers::grpc::MessageBuilder::MessageBuilder ( MessageBuilder &&  other )

inline

Definition at line 159 of file grpc.h.

      : FlatBufferBuilder(1024, &slice_allocator_, false) {
    // Default construct and swap idiom.
    Swap(other);
  }

References Swap().

MessageBuilder() [4/4]

flatbuffers::grpc::MessageBuilder::MessageBuilder ( FlatBufferBuilder &&  src, void(*)(void *, size_t)  dealloc = &DefaultAllocator::dealloc  )

inlineexplicit

Create a MessageBuilder from a FlatBufferBuilder.

Definition at line 166 of file grpc.h.

      : FlatBufferBuilder(1024, &slice_allocator_, false) {
    src.Swap(*this);
    src.SwapBufAllocator(*this);
    if (buf_.capacity()) {
      uint8_t *buf = buf_.scratch_data();  // pointer to memory
      size_t capacity = buf_.capacity();   // size of memory
      slice_allocator_.slice_ = ::grpc::Slice(buf, capacity, dealloc);
    } else {
      slice_allocator_.slice_ = ::grpc::Slice();
    }
  }

References flatbuffers::FlatBufferBuilderImpl< false >::buf_, flatbuffers::vector_downward< SizeT >::capacity(), flatbuffers::vector_downward< SizeT >::scratch_data(), and flatbuffers::FlatBufferBuilderImpl< Is64Aware >::Swap().

~MessageBuilder()

flatbuffers::grpc::MessageBuilder::~MessageBuilder ( )

inline

Definition at line 219 of file grpc.h.

{}

Member Function Documentation

GetMessage()

template<class T >

Message< T > flatbuffers::grpc::MessageBuilder::GetMessage ( )

inline

Definition at line 224 of file grpc.h.

                                            {
    auto buf_data = buf_.scratch_data();  // pointer to memory
    auto buf_size = buf_.capacity();      // size of memory
    auto msg_data = buf_.data();          // pointer to msg
    auto msg_size = buf_.size();          // size of msg
    // Do some sanity checks on data/size
    FLATBUFFERS_ASSERT(msg_data);
    FLATBUFFERS_ASSERT(msg_size);
    FLATBUFFERS_ASSERT(msg_data >= buf_data);
    FLATBUFFERS_ASSERT(msg_data + msg_size <= buf_data + buf_size);
    // Calculate offsets from the buffer start
    auto begin = msg_data - buf_data;
    auto end = begin + msg_size;
    // Get the slice we are working with (no refcount change)
    ::grpc::Slice slice = slice_allocator_.get_slice(buf_data, buf_size);
    // Extract a subslice of the existing slice (increment refcount)
    ::grpc::Slice subslice = slice.sub(begin, end);
    // Wrap the subslice in a `Message<T>`, but don't increment refcount
    Message<T> msg(subslice);
    return msg;
  }

References begin, flatbuffers::FlatBufferBuilderImpl< false >::buf_, flatbuffers::vector_downward< SizeT >::capacity(), flatbuffers::vector_downward< SizeT >::data(), FLATBUFFERS_ASSERT, flatbuffers::vector_downward< SizeT >::scratch_data(), and flatbuffers::vector_downward< SizeT >::size().

operator=() [1/3]

MessageBuilder & flatbuffers::grpc::MessageBuilder::operator= ( const MessageBuilder &  other )

delete

operator=() [2/3]

MessageBuilder & flatbuffers::grpc::MessageBuilder::operator= ( FlatBufferBuilder &&  src )

inline

Move-assign a FlatBufferBuilder to a MessageBuilder. Only FlatBufferBuilder with default allocator (basically, nullptr) is supported.

Definition at line 184 of file grpc.h.

                                                     {
    // Move construct a temporary and swap
    MessageBuilder temp(std::move(src));
    Swap(temp);
    return *this;
  }

References Swap().

operator=() [3/3]

MessageBuilder & flatbuffers::grpc::MessageBuilder::operator= ( MessageBuilder &&  other )

inline

Definition at line 191 of file grpc.h.

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

References Swap().

ReleaseMessage()

template<class T >

Message< T > flatbuffers::grpc::MessageBuilder::ReleaseMessage ( )

inline

Definition at line 246 of file grpc.h.

                                                {
    Message<T> msg = GetMessage<T>();
    Reset();
    return msg;
  }

References flatbuffers::FlatBufferBuilderImpl< false >::Reset().

ReleaseRaw()

uint8_t * flatbuffers::grpc::MessageBuilder::ReleaseRaw ( size_t &  size, size_t &  offset, ::grpc::Slice &  slice  )

inline

Definition at line 212 of file grpc.h.

                                                                      {
    uint8_t *buf = FlatBufferBuilder::ReleaseRaw(size, offset);
    slice = slice_allocator_.slice_;
    slice_allocator_.slice_ = ::grpc::Slice();
    return buf;
  }

References offset(), flatbuffers::FlatBufferBuilderImpl< false >::ReleaseRaw(), and size.

Swap()

void flatbuffers::grpc::MessageBuilder::Swap ( MessageBuilder &  other )

inline

Definition at line 198 of file grpc.h.

                                   {
    slice_allocator_.swap(other.slice_allocator_);
    FlatBufferBuilder::Swap(other);
    // After swapping the FlatBufferBuilder, we swap back the allocator, which
    // restores the original allocator back in place. This is necessary because
    // MessageBuilder's allocator is its own member (SliceAllocatorMember). The
    // allocator passed to FlatBufferBuilder::vector_downward must point to this
    // member.
    buf_.swap_allocator(other.buf_);
  }

References flatbuffers::FlatBufferBuilderImpl< Is64Aware >::buf_, flatbuffers::FlatBufferBuilderImpl< false >::buf_, flatbuffers::FlatBufferBuilderImpl< false >::Swap(), and flatbuffers::vector_downward< SizeT >::swap_allocator().

Referenced by MessageBuilder(), operator=(), and operator=().

---

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

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