Namespaces
namespace	grpc

namespace	internal

Data Structures
class	Allocator

class	Array

class	Array< OffsetT< T >, length >

class	BaseGenerator

struct	bool_constant

struct	BufferRef

struct	BufferRefBase

class	CheckedError

class	CodeGenerator

struct	CodeGenOptions

class	CodeWriter

struct	CommentConfig

struct	conditional

class	DefaultAllocator

struct	Definition

class	DetachedBuffer

struct	EmptyOffset

struct	EnumDef

struct	EnumVal

struct	FieldDef

class	FileManager

class	FlatBufferBuilderImpl

class	FLATBUFFERS_FINAL_CLASS

class	FlatCompiler

struct	FlatCOption

struct	FlatCOptions

class	FloatConstantGenerator

struct	FnvTraits

struct	FnvTraits< uint32_t >

struct	FnvTraits< uint64_t >

struct	IDLOptions

struct	IncludedFile

struct	integral_constant

struct	is_enum

struct	is_floating_point

struct	is_same

struct	is_scalar

struct	is_unsigned

struct	IterationVisitor

struct	make_unsigned

struct	NamedHashFunction

struct	Namespace

struct	NativeTable

struct	nullopt_t

class	numeric_limits

class	Parser

struct	ParserState

class	pointer_inside_vector

class	Registry

struct	RPCCall

struct	ServiceDef

class	SimpleFloatConstantGenerator

struct	String

struct	StructDef

class	SymbolTable

class	Table

struct	ToStringVisitor

struct	Type

struct	TypeCode

class	TypedFloatConstantGenerator

struct	TypeTable

class	unique_ptr

struct	Value

class	Vector

class	vector_downward

struct	VectorIterator

class	VectorOfAny

struct	VectorReverseIterator

Typedefs
using	FlatBufferBuilder = FlatBufferBuilderImpl< false >

using	FlatBufferBuilder64 = FlatBufferBuilderImpl< true >

typedef uint64_t	hash_value_t
	Function types to be used with resolving hashes into objects and back again. The resolver gets a pointer to a field inside an object API object that is of the type specified in the schema using the attribute `cpp_type` (it is thus important whatever you write to this address matches that type). The value of this field is initially null, so you may choose to implement a delayed binding lookup using this function if you wish. The resolver does the opposite lookup, for when the object is being serialized again.

typedef std::function< void(void **pointer_adr, hash_value_t hash)>	resolver_function_t

typedef std::function< hash_value_t(void *pointer)>	rehasher_function_t

typedef const TypeTable (	TypeFunction) ()

typedef bool_constant< true >	true_type

typedef bool_constant< false >	false_type

typedef bool(*	LoadFileFunction) (const char filename, bool binary, std::string dest)

typedef bool(*	FileExistsFunction) (const char *filename)

template<typename T , typename IT , typename SizeT = uoffset_t>
using	VectorConstIterator = VectorIterator< T, IT, const uint8_t *, SizeT >

template<typename T >
using	Vector64 = Vector< T, uoffset64_t >

Enumerations
enum	SequenceType { ST_TABLE , ST_STRUCT , ST_UNION , ST_ENUM }

enum	ElementaryType

enum	BaseType

enum class	Case { kUnknown = 0 , kUpperCamel = 1 , kLowerCamel = 2 , kSnake = 3 , kScreamingSnake = 4 , kAllUpper = 5 , kAllLower = 6 , kDasher = 7 , kKeep = 8 , kSnake2 = 9 }

Functions
template<class U , uint16_t N>
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< U, N >	make_span (Array< U, N > &arr) FLATBUFFERS_NOEXCEPT

template<class U , uint16_t N>
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const U, N >	make_span (const Array< U, N > &arr) FLATBUFFERS_NOEXCEPT

template<class U , uint16_t N>
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< uint8_t, sizeof(U) *N >	make_bytes_span (Array< U, N > &arr) FLATBUFFERS_NOEXCEPT

template<class U , uint16_t N>
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const uint8_t, sizeof(U) *N >	make_bytes_span (const Array< U, N > &arr) FLATBUFFERS_NOEXCEPT

template<typename T , uint16_t length>
Array< T, length > &	CastToArray (T(&arr)[length])

template<typename T , uint16_t length>
const Array< T, length > &	CastToArray (const T(&arr)[length])

template<typename E , typename T , uint16_t length>
Array< E, length > &	CastToArrayOfEnum (T(&arr)[length])

template<typename E , typename T , uint16_t length>
const Array< E, length > &	CastToArrayOfEnum (const T(&arr)[length])

template<typename T , uint16_t length>
bool	operator== (const Array< T, length > &lhs, const Array< T, length > &rhs) noexcept

void	GenComment (const std::vector< std::string > &dc, std::string code_ptr, const CommentConfig config, const char *prefix="")

std::string	JavaCSharpMakeRule (const bool java, const Parser &parser, const std::string &path, const std::string &file_name)

uint8_t *	Allocate (Allocator *allocator, size_t size)

void	Deallocate (Allocator allocator, uint8_t p, size_t size)

uint8_t *	ReallocateDownward (Allocator allocator, uint8_t old_p, size_t old_size, size_t new_size, size_t in_use_back, size_t in_use_front)

voffset_t	FieldIndexToOffset (voffset_t field_id)

template<typename T , typename Alloc = std::allocator<T>>
const T *	data (const std::vector< T, Alloc > &v)

template<typename T , typename Alloc = std::allocator<T>>
T *	data (std::vector< T, Alloc > &v)

template<typename T >
T *	GetMutableTemporaryPointer (FlatBufferBuilder &fbb, Offset< T > offset)

template<typename T >
const T *	GetTemporaryPointer (FlatBufferBuilder &fbb, Offset< T > offset)

const uint8_t *	GetBufferStartFromRootPointer (const void *root)
	This can compute the start of a FlatBuffer from a root pointer, i.e. it is the opposite transformation of GetRoot(). This may be useful if you want to pass on a root and have the recipient delete the buffer afterwards.

template<typename SizeT = uoffset_t>
SizeT	GetPrefixedSize (const uint8_t *buf)
	This return the prefixed size of a FlatBuffer.

template<typename SizeT = uoffset_t>
SizeT	GetSizePrefixedBufferLength (const uint8_t *const buf)

template<typename T >
bool	IsFieldPresent (const T *table, typename T::FlatBuffersVTableOffset field)

int	LookupEnum (const char *names, const char name)

const char const	ElementaryTypeNames ()

const char *	flatbuffers_version_string ()

void	LogCompilerWarn (const std::string &warn)

void	LogCompilerError (const std::string &err)

template<typename T >
T	HashFnv1 (const char *input)

template<typename T >
T	HashFnv1a (const char *input)

template<>
uint16_t	HashFnv1< uint16_t > (const char *input)

template<>
uint16_t	HashFnv1a< uint16_t > (const char *input)

NamedHashFunction< uint16_t >::HashFunction	FindHashFunction16 (const char *name)

NamedHashFunction< uint32_t >::HashFunction	FindHashFunction32 (const char *name)

NamedHashFunction< uint64_t >::HashFunction	FindHashFunction64 (const char *name)

bool	IsScalar (BaseType t)

bool	IsInteger (BaseType t)

bool	IsFloat (BaseType t)

bool	IsLong (BaseType t)

bool	IsBool (BaseType t)

bool	IsOneByte (BaseType t)

bool	IsVector (BaseType t)

bool	IsUnsigned (BaseType t)

size_t	SizeOf (const BaseType t)

const char *	TypeName (const BaseType t)

const char *	StringOf (const BaseType t)

bool	operator< (const Namespace &a, const Namespace &b)

bool	IsString (const Type &type)

bool	IsStruct (const Type &type)

bool	IsIncompleteStruct (const Type &type)

bool	IsTable (const Type &type)

bool	IsUnion (const Type &type)

bool	IsUnionType (const Type &type)

bool	IsVector (const Type &type)

bool	IsVectorOfStruct (const Type &type)

bool	IsVectorOfTable (const Type &type)

bool	IsArray (const Type &type)

bool	IsSeries (const Type &type)

bool	IsEnum (const Type &type)

size_t	InlineSize (const Type &type)

size_t	InlineAlignment (const Type &type)

bool	operator== (const EnumVal &lhs, const EnumVal &rhs)

bool	operator!= (const EnumVal &lhs, const EnumVal &rhs)

bool	EqualByName (const Type &a, const Type &b)

bool	operator< (const IncludedFile &a, const IncludedFile &b)

const char *	GenTextFromTable (const Parser &parser, const void table, const std::string &tablename, std::string text)

const char *	GenText (const Parser &parser, const void flatbuffer, std::string text)

const char *	GenTextFile (const Parser &parser, const std::string &path, const std::string &file_name)

bool	GenerateCppGRPC (const Parser &parser, const std::string &path, const std::string &file_name)

bool	GenerateGoGRPC (const Parser &parser, const std::string &path, const std::string &file_name)

bool	GenerateJavaGRPC (const Parser &parser, const std::string &path, const std::string &file_name)

bool	GeneratePythonGRPC (const Parser &parser, const std::string &path, const std::string &file_name)

bool	GenerateSwiftGRPC (const Parser &parser, const std::string &path, const std::string &file_name)

bool	GenerateTSGRPC (const Parser &parser, const std::string &path, const std::string &file_name)

size_t	InlineSize (ElementaryType type, const TypeTable *type_table)

int64_t	LookupEnum (int64_t enum_val, const int64_t *values, size_t num_values)

template<typename T >
const char *	EnumName (T tval, const TypeTable *type_table)

void	IterateObject (const uint8_t obj, const TypeTable type_table, IterationVisitor *visitor)

void	IterateValue (ElementaryType type, const uint8_t val, const TypeTable type_table, const uint8_t prev_val, soffset_t vector_index, IterationVisitor visitor)

void	IterateFlatBuffer (const uint8_t buffer, const TypeTable type_table, IterationVisitor *callback)

std::string	FlatBufferToString (const uint8_t buffer, const TypeTable type_table, bool multi_line=false, bool vector_delimited=true, const std::string &indent="")

bool	IsScalar (reflection::BaseType t)

bool	IsInteger (reflection::BaseType t)

bool	IsFloat (reflection::BaseType t)

bool	IsLong (reflection::BaseType t)

size_t	GetTypeSize (reflection::BaseType base_type)

size_t	GetTypeSizeInline (reflection::BaseType base_type, int type_index, const reflection::Schema &schema)

Table *	GetAnyRoot (uint8_t *const flatbuf)

const Table *	GetAnyRoot (const uint8_t *const flatbuf)

Table *	GetAnySizePrefixedRoot (uint8_t *const flatbuf)

const Table *	GetAnySizePrefixedRoot (const uint8_t *const flatbuf)

template<typename T >
T	GetFieldDefaultI (const reflection::Field &field)

template<typename T >
T	GetFieldDefaultF (const reflection::Field &field)

template<typename T >
T	GetFieldI (const Table &table, const reflection::Field &field)

template<typename T >
T	GetFieldF (const Table &table, const reflection::Field &field)

const String *	GetFieldS (const Table &table, const reflection::Field &field)

template<typename T >
Vector< T > *	GetFieldV (const Table &table, const reflection::Field &field)

VectorOfAny *	GetFieldAnyV (const Table &table, const reflection::Field &field)

Table *	GetFieldT (const Table &table, const reflection::Field &field)

const Struct *	GetFieldStruct (const Table &table, const reflection::Field &field)

const Struct *	GetFieldStruct (const Struct &structure, const reflection::Field &field)

int64_t	GetAnyValueI (reflection::BaseType type, const uint8_t *data)

double	GetAnyValueF (reflection::BaseType type, const uint8_t *data)

std::string	GetAnyValueS (reflection::BaseType type, const uint8_t data, const reflection::Schema schema, int type_index)

int64_t	GetAnyFieldI (const Table &table, const reflection::Field &field)

double	GetAnyFieldF (const Table &table, const reflection::Field &field)

std::string	GetAnyFieldS (const Table &table, const reflection::Field &field, const reflection::Schema *schema)

int64_t	GetAnyFieldI (const Struct &st, const reflection::Field &field)

double	GetAnyFieldF (const Struct &st, const reflection::Field &field)

std::string	GetAnyFieldS (const Struct &st, const reflection::Field &field)

int64_t	GetAnyVectorElemI (const VectorOfAny *vec, reflection::BaseType elem_type, size_t i)

double	GetAnyVectorElemF (const VectorOfAny *vec, reflection::BaseType elem_type, size_t i)

std::string	GetAnyVectorElemS (const VectorOfAny *vec, reflection::BaseType elem_type, size_t i)

template<typename T >
T *	GetAnyVectorElemPointer (const VectorOfAny *vec, size_t i)

template<typename T >
T *	GetAnyVectorElemAddressOf (const VectorOfAny *vec, size_t i, size_t elem_size)

template<typename T >
T *	GetAnyFieldAddressOf (const Table &table, const reflection::Field &field)

template<typename T >
T *	GetAnyFieldAddressOf (const Struct &st, const reflection::Field &field)

void	ForAllFields (const reflection::Object object, bool reverse, std::function< void(const reflection::Field )> func)

template<typename T >
bool	SetField (Table *table, const reflection::Field &field, T val)

void	SetAnyValueI (reflection::BaseType type, uint8_t *data, int64_t val)

void	SetAnyValueF (reflection::BaseType type, uint8_t *data, double val)

void	SetAnyValueS (reflection::BaseType type, uint8_t data, const char val)

bool	SetAnyFieldI (Table *table, const reflection::Field &field, int64_t val)

bool	SetAnyFieldF (Table *table, const reflection::Field &field, double val)

bool	SetAnyFieldS (Table table, const reflection::Field &field, const char val)

void	SetAnyFieldI (Struct *st, const reflection::Field &field, int64_t val)

void	SetAnyFieldF (Struct *st, const reflection::Field &field, double val)

void	SetAnyFieldS (Struct st, const reflection::Field &field, const char val)

void	SetAnyVectorElemI (VectorOfAny *vec, reflection::BaseType elem_type, size_t i, int64_t val)

void	SetAnyVectorElemF (VectorOfAny *vec, reflection::BaseType elem_type, size_t i, double val)

void	SetAnyVectorElemS (VectorOfAny vec, reflection::BaseType elem_type, size_t i, const char val)

template<typename T , typename U >
pointer_inside_vector< T, U >	piv (T *ptr, std::vector< U > &vec)

const char *	UnionTypeFieldSuffix ()

const reflection::Object &	GetUnionType (const reflection::Schema &schema, const reflection::Object &parent, const reflection::Field &unionfield, const Table &table)

void	SetString (const reflection::Schema &schema, const std::string &val, const String str, std::vector< uint8_t > flatbuf, const reflection::Object *root_table=nullptr)

uint8_t *	ResizeAnyVector (const reflection::Schema &schema, uoffset_t newsize, const VectorOfAny vec, uoffset_t num_elems, uoffset_t elem_size, std::vector< uint8_t > flatbuf, const reflection::Object *root_table=nullptr)

template<typename T >
void	ResizeVector (const reflection::Schema &schema, uoffset_t newsize, T val, const Vector< T > vec, std::vector< uint8_t > flatbuf, const reflection::Object *root_table=nullptr)

const uint8_t *	AddFlatBuffer (std::vector< uint8_t > &flatbuf, const uint8_t *newbuf, size_t newlen)

bool	SetFieldT (Table table, const reflection::Field &field, const uint8_t val)

Offset< const Table * >	CopyTable (FlatBufferBuilder &fbb, const reflection::Schema &schema, const reflection::Object &objectdef, const Table &table, bool use_string_pooling=false)

bool	Verify (const reflection::Schema &schema, const reflection::Object &root, const uint8_t *buf, size_t length, uoffset_t max_depth=64, uoffset_t max_tables=1000000)

bool	VerifySizePrefixed (const reflection::Schema &schema, const reflection::Object &root, const uint8_t *buf, size_t length, uoffset_t max_depth=64, uoffset_t max_tables=1000000)

template<class T >
FLATBUFFERS_CONSTEXPR_CPP11 bool	operator== (const Optional< T > &opt, nullopt_t) FLATBUFFERS_NOEXCEPT

template<class T >
FLATBUFFERS_CONSTEXPR_CPP11 bool	operator== (nullopt_t, const Optional< T > &opt) FLATBUFFERS_NOEXCEPT

template<class T , class U >
FLATBUFFERS_CONSTEXPR_CPP11 bool	operator== (const Optional< T > &lhs, const U &rhs) FLATBUFFERS_NOEXCEPT

template<class T , class U >
FLATBUFFERS_CONSTEXPR_CPP11 bool	operator== (const T &lhs, const Optional< U > &rhs) FLATBUFFERS_NOEXCEPT

template<class T , class U >
FLATBUFFERS_CONSTEXPR_CPP11 bool	operator== (const Optional< T > &lhs, const Optional< U > &rhs) FLATBUFFERS_NOEXCEPT

bool	check_ascii_range (char x, char a, char b)

bool	is_alpha (char c)

bool	is_alpha_upper (char c)

bool	is_alpha_char (char c, char alpha)

bool	is_digit (char c)

bool	is_xdigit (char c)

bool	is_alnum (char c)

char	CharToUpper (char c)

char	CharToLower (char c)

template<typename T >
std::string	NumToString (T t)

template<>
std::string	NumToString< signed char > (signed char t)

template<>
std::string	NumToString< unsigned char > (unsigned char t)

template<>
std::string	NumToString< char > (char t)

template<typename T >
std::string	FloatToString (T t, int precision)

template<>
std::string	NumToString< double > (double t)

template<>
std::string	NumToString< float > (float t)

std::string	IntToStringHex (int i, int xdigits)

void	strtoval_impl (int64_t val, const char str, char **endptr, int base)

void	strtoval_impl (uint64_t val, const char str, char **endptr, int base)

void	strtoval_impl (double val, const char str, char **endptr)

void	strtoval_impl (float val, const char str, char **endptr)

template<typename T >
bool	StringToIntegerImpl (T val, const char const str, const int base=0, const bool check_errno=true)

template<typename T >
bool	StringToFloatImpl (T val, const char const str)

template<typename T >
bool	StringToNumber (const char s, T val)

template<>
bool	StringToNumber< int64_t > (const char str, int64_t val)

template<>
bool	StringToNumber< uint64_t > (const char str, uint64_t val)

template<>
bool	StringToNumber (const char s, float val)

template<>
bool	StringToNumber (const char s, double val)

int64_t	StringToInt (const char *s, int base=10)

uint64_t	StringToUInt (const char *s, int base=10)

bool	StringIsFlatbufferNan (const std::string &s)

bool	StringIsFlatbufferPositiveInfinity (const std::string &s)

bool	StringIsFlatbufferNegativeInfinity (const std::string &s)

LoadFileFunction	SetLoadFileFunction (LoadFileFunction load_file_function)

FileExistsFunction	SetFileExistsFunction (FileExistsFunction file_exists_function)

bool	FileExists (const char *name)

bool	DirExists (const char *name)

bool	LoadFile (const char name, bool binary, std::string buf)

bool	SaveFile (const char name, const char buf, size_t len, bool binary)

bool	SaveFile (const char *name, const std::string &buf, bool binary)

std::string	StripExtension (const std::string &filepath)

std::string	GetExtension (const std::string &filepath)

std::string	StripPath (const std::string &filepath)

std::string	StripFileName (const std::string &filepath)

std::string	StripPrefix (const std::string &filepath, const std::string &prefix_to_remove)

std::string	ConCatPathFileName (const std::string &path, const std::string &filename)

std::string	PosixPath (const char *path)

std::string	PosixPath (const std::string &path)

void	EnsureDirExists (const std::string &filepath)

std::string	AbsolutePath (const std::string &filepath)

std::string	RelativeToRootPath (const std::string &project, const std::string &filepath)

int	ToUTF8 (uint32_t ucc, std::string *out)

int	FromUTF8 (const char **in)

std::string	WordWrap (const std::string in, size_t max_length, const std::string wrapped_line_prefix, const std::string wrapped_line_suffix)

bool	EscapeString (const char s, size_t length, std::string _text, bool allow_non_utf8, bool natural_utf8)

std::string	BufferToHexText (const void *buffer, size_t buffer_size, size_t max_length, const std::string &wrapped_line_prefix, const std::string &wrapped_line_suffix)

std::string	RemoveStringQuotes (const std::string &s)

bool	SetGlobalTestLocale (const char locale_name, std::string _value=nullptr)

bool	ReadEnvironmentVariable (const char var_name, std::string _value=nullptr)

std::string	ConvertCase (const std::string &input, Case output_case, Case input_case=Case::kSnake)

template<class U >
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< U >	make_span (Vector< U > &vec) FLATBUFFERS_NOEXCEPT

template<class U >
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const U >	make_span (const Vector< U > &vec) FLATBUFFERS_NOEXCEPT

template<class U >
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< uint8_t >	make_bytes_span (Vector< U > &vec) FLATBUFFERS_NOEXCEPT

template<class U >
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const uint8_t >	make_bytes_span (const Vector< U > &vec) FLATBUFFERS_NOEXCEPT

template<class U >
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< U >	make_span (Vector< U > *ptr) FLATBUFFERS_NOEXCEPT

template<class U >
FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const U >	make_span (const Vector< U > *ptr) FLATBUFFERS_NOEXCEPT

template<typename T , typename U >
Vector< Offset< T > > *	VectorCast (Vector< Offset< U > > *ptr)

template<typename T , typename U >
const Vector< Offset< T > > *	VectorCast (const Vector< Offset< U > > *ptr)

Variables
const NamedHashFunction< uint16_t >	kHashFunctions16 []

const NamedHashFunction< uint32_t >	kHashFunctions32 []

const NamedHashFunction< uint64_t >	kHashFunctions64 []

FLATBUFFERS_CONSTEXPR std::size_t	dynamic_extent = static_cast<std::size_t>(-1)

FLATBUFFERS_CONSTEXPR char	kPathSeparator = '/'

Typedef Documentation

◆ false_type

typedef bool_constant<false> flatbuffers::false_type

Definition at line 108 of file stl_emulation.h.

◆ FileExistsFunction

typedef bool(* flatbuffers::FileExistsFunction) (const char *filename)

Definition at line 412 of file util.h.

◆ FlatBufferBuilder

using flatbuffers::FlatBufferBuilder = typedef FlatBufferBuilderImpl<false>

Definition at line 1414 of file flatbuffer_builder.h.

◆ FlatBufferBuilder64

using flatbuffers::FlatBufferBuilder64 = typedef FlatBufferBuilderImpl<true>

Definition at line 1415 of file flatbuffer_builder.h.

◆ hash_value_t

typedef uint64_t flatbuffers::hash_value_t

Function types to be used with resolving hashes into objects and back again. The resolver gets a pointer to a field inside an object API object that is of the type specified in the schema using the attribute cpp_type (it is thus important whatever you write to this address matches that type). The value of this field is initially null, so you may choose to implement a delayed binding lookup using this function if you wish. The resolver does the opposite lookup, for when the object is being serialized again.

Definition at line 108 of file flatbuffers.h.

◆ LoadFileFunction

typedef bool(* flatbuffers::LoadFileFunction) (const char *filename, bool binary, std::string *dest)

Definition at line 410 of file util.h.

◆ rehasher_function_t

typedef std::function<hash_value_t(void *pointer)> flatbuffers::rehasher_function_t

Definition at line 111 of file flatbuffers.h.

◆ resolver_function_t

typedef std::function<void(void **pointer_adr, hash_value_t hash)> flatbuffers::resolver_function_t

Definition at line 110 of file flatbuffers.h.

◆ true_type

typedef bool_constant<true> flatbuffers::true_type

Definition at line 107 of file stl_emulation.h.

◆ TypeFunction

typedef const TypeTable *(* flatbuffers::TypeFunction) ()

Definition at line 230 of file flatbuffers.h.

◆ Vector64

template<typename T >

using flatbuffers::Vector64 = typedef Vector<T, uoffset64_t>

Definition at line 304 of file vector.h.

◆ VectorConstIterator

template<typename T , typename IT , typename SizeT = uoffset_t>

using flatbuffers::VectorConstIterator = typedef VectorIterator<T, IT, const uint8_t *, SizeT>

Definition at line 124 of file vector.h.

Enumeration Type Documentation

◆ BaseType

enum flatbuffers::BaseType

Definition at line 118 of file idl.h.

              {
  #define FLATBUFFERS_TD(ENUM, IDLTYPE, \
              CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE, STYPE, ENUM_VALUE) \
    BASE_TYPE_ ## ENUM = ENUM_VALUE,
    FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
  #undef FLATBUFFERS_TD
};

◆ Case

enum class flatbuffers::Case

strong

Enumerator
kUnknown
kUpperCamel
kLowerCamel
kSnake
kScreamingSnake
kAllUpper
kAllLower
kDasher
kKeep
kSnake2

Definition at line 703 of file util.h.

                {
  kUnknown = 0,
  // TheQuickBrownFox
  kUpperCamel = 1,
  // theQuickBrownFox
  kLowerCamel = 2,
  // the_quick_brown_fox
  kSnake = 3,
  // THE_QUICK_BROWN_FOX
  kScreamingSnake = 4,
  // THEQUICKBROWNFOX
  kAllUpper = 5,
  // thequickbrownfox
  kAllLower = 6,
  // the-quick-brown-fox
  kDasher = 7,
  // THEQuiCKBr_ownFox (or whatever you want, we won't change it)
  kKeep = 8,
  // the_quick_brown_fox123 (as opposed to the_quick_brown_fox_123)
  kSnake2 = 9,
};

◆ ElementaryType

enum flatbuffers::ElementaryType

Definition at line 196 of file flatbuffers.h.

                    {
  #define FLATBUFFERS_ET(E) E,
    FLATBUFFERS_GEN_ELEMENTARY_TYPES(FLATBUFFERS_ET)
  #undef FLATBUFFERS_ET
};

◆ SequenceType

enum flatbuffers::SequenceType

Enumerator
ST_TABLE
ST_STRUCT
ST_UNION
ST_ENUM

Definition at line 176 of file flatbuffers.h.

176{ ST_TABLE, ST_STRUCT, ST_UNION, ST_ENUM };

flatbuffers::ST_UNION

@ ST_UNION

Definition flatbuffers.h:176

flatbuffers::ST_ENUM

@ ST_ENUM

Definition flatbuffers.h:176

flatbuffers::ST_TABLE

@ ST_TABLE

Definition flatbuffers.h:176

flatbuffers::ST_STRUCT

@ ST_STRUCT

Definition flatbuffers.h:176

Function Documentation

◆ AbsolutePath()

std::string flatbuffers::AbsolutePath ( const std::string & filepath )

◆ AddFlatBuffer()

const uint8_t * flatbuffers::AddFlatBuffer	(	std::vector< uint8_t > &	flatbuf,
		const uint8_t *	newbuf,
		size_t	newlen
	)

◆ Allocate()

uint8_t * flatbuffers::Allocate	(	Allocator *	allocator,
		size_t	size
	)

inline

Definition at line 41 of file default_allocator.h.

                                                            {
  return allocator ? allocator->allocate(size)
                   : DefaultAllocator().allocate(size);
}

References flatbuffers::DefaultAllocator::allocate(), allocator(), and size.

◆ BufferToHexText()

std::string flatbuffers::BufferToHexText	(	const void *	buffer,
		size_t	buffer_size,
		size_t	max_length,
		const std::string &	wrapped_line_prefix,
		const std::string &	wrapped_line_suffix
	)

inline

Definition at line 664 of file util.h.

                                                                         {
  std::string text = wrapped_line_prefix;
  size_t start_offset = 0;
  const char *s = reinterpret_cast<const char *>(buffer);
  for (size_t i = 0; s && i < buffer_size; i++) {
    // Last iteration or do we have more?
    bool have_more = i + 1 < buffer_size;
    text += "0x";
    text += IntToStringHex(static_cast<uint8_t>(s[i]), 2);
    if (have_more) { text += ','; }
    // If we have more to process and we reached max_length
    if (have_more &&
        text.size() + wrapped_line_suffix.size() >= start_offset + max_length) {
      text += wrapped_line_suffix;
      text += '\n';
      start_offset = text.size();
      text += wrapped_line_prefix;
    }
  }
  text += wrapped_line_suffix;
  return text;
}

References IntToStringHex().

◆ CastToArray() [1/2]

template<typename T , uint16_t length>

const Array< T, length > & flatbuffers::CastToArray ( const T(&) arr[length] )

Definition at line 230 of file array.h.

                                                            {
  return *reinterpret_cast<const Array<T, length> *>(arr);
}

◆ CastToArray() [2/2]

template<typename T , uint16_t length>

Array< T, length > & flatbuffers::CastToArray ( T(&) arr[length] )

Definition at line 225 of file array.h.

                                                {
  return *reinterpret_cast<Array<T, length> *>(arr);
}

◆ CastToArrayOfEnum() [1/2]

template<typename E , typename T , uint16_t length>

const Array< E, length > & flatbuffers::CastToArrayOfEnum ( const T(&) arr[length] )

Definition at line 241 of file array.h.

                                                                  {
  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
  return *reinterpret_cast<const Array<E, length> *>(arr);
}

◆ CastToArrayOfEnum() [2/2]

template<typename E , typename T , uint16_t length>

Array< E, length > & flatbuffers::CastToArrayOfEnum ( T(&) arr[length] )

Definition at line 235 of file array.h.

                                                      {
  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
  return *reinterpret_cast<Array<E, length> *>(arr);
}

◆ CharToLower()

char flatbuffers::CharToLower ( char c )

inline

Definition at line 86 of file util.h.

                                {
  return static_cast<char>(::tolower(static_cast<unsigned char>(c)));
}

◆ CharToUpper()

char flatbuffers::CharToUpper ( char c )

inline

Definition at line 82 of file util.h.

                                {
  return static_cast<char>(::toupper(static_cast<unsigned char>(c)));
}

◆ check_ascii_range()

bool flatbuffers::check_ascii_range	(	char	x,
		char	a,
		char	b
	)

inline

Definition at line 44 of file util.h.

                                                      {
  FLATBUFFERS_ASSERT(a <= b);
  // (Hacker's Delight): `a <= x <= b` <=> `(x-a) <={u} (b-a)`.
  // The x, a, b will be promoted to int and subtracted without overflow.
  return static_cast<unsigned int>(x - a) <= static_cast<unsigned int>(b - a);
}

References FLATBUFFERS_ASSERT.

Referenced by is_alpha(), is_alpha_upper(), is_digit(), and is_xdigit().

◆ ConCatPathFileName()

std::string flatbuffers::ConCatPathFileName	(	const std::string &	path,
		const std::string &	filename
	)

◆ ConvertCase()

std::string flatbuffers::ConvertCase	(	const std::string &	input,
		Case	output_case,
		Case	input_case = `Case::kSnake`
	)

◆ CopyTable()

Offset< const Table * > flatbuffers::CopyTable	(	FlatBufferBuilder &	fbb,
		const reflection::Schema &	schema,
		const reflection::Object &	objectdef,
		const Table &	table,
		bool	use_string_pooling = `false`
	)

◆ data() [1/2]

template<typename T , typename Alloc = std::allocator<T>>

const T * flatbuffers::data ( const std::vector< T, Alloc > & v )

Definition at line 52 of file flatbuffer_builder.h.

                                            {
  // Eventually the returned pointer gets passed down to memcpy, so
  // we need it to be non-null to avoid undefined behavior.
  static uint8_t t;
  return v.empty() ? reinterpret_cast<const T *>(&t) : &v.front();
}

◆ data() [2/2]

template<typename T , typename Alloc = std::allocator<T>>

T * flatbuffers::data ( std::vector< T, Alloc > & v )

Definition at line 59 of file flatbuffer_builder.h.

                                {
  // Eventually the returned pointer gets passed down to memcpy, so
  // we need it to be non-null to avoid undefined behavior.
  static uint8_t t;
  return v.empty() ? reinterpret_cast<T *>(&t) : &v.front();
}

◆ Deallocate()

void flatbuffers::Deallocate	(	Allocator *	allocator,
		uint8_t *	p,
		size_t	size
	)

inline

Definition at line 46 of file default_allocator.h.

                                                                      {
  if (allocator)
    allocator->deallocate(p, size);
  else
    DefaultAllocator().deallocate(p, size);
}

References allocator(), flatbuffers::DefaultAllocator::deallocate(), p, and size.

Referenced by flatbuffers::vector_downward< SizeT >::clear_buffer(), and flatbuffers::DetachedBuffer::destroy().

◆ DirExists()

bool flatbuffers::DirExists ( const char * name )

◆ ElementaryTypeNames()

const char *const * flatbuffers::ElementaryTypeNames ( )

inline

Definition at line 202 of file flatbuffers.h.

                                                 {
  static const char * const names[] = {
    #define FLATBUFFERS_ET(E) #E,
      FLATBUFFERS_GEN_ELEMENTARY_TYPES(FLATBUFFERS_ET)
    #undef FLATBUFFERS_ET
  };
  return names;
}

References FLATBUFFERS_ET, and FLATBUFFERS_GEN_ELEMENTARY_TYPES.

◆ EnsureDirExists()

void flatbuffers::EnsureDirExists ( const std::string & filepath )

◆ EnumName()

template<typename T >

const char * flatbuffers::EnumName	(	T	tval,
		const TypeTable *	type_table
	)

Definition at line 108 of file minireflect.h.

                                                                               {
  if (!type_table || !type_table->names) return nullptr;
  auto i = LookupEnum(static_cast<int64_t>(tval), type_table->values,
                      type_table->num_elems);
  if (i >= 0 && i < static_cast<int64_t>(type_table->num_elems)) {
    return type_table->names[i];
  }
  return nullptr;
}

References LookupEnum(), flatbuffers::TypeTable::names, flatbuffers::TypeTable::num_elems, and flatbuffers::TypeTable::values.

Referenced by IterateValue().

◆ EqualByName()

bool flatbuffers::EqualByName	(	const Type &	a,
		const Type &	b
	)

inline

Definition at line 584 of file idl.h.

                                                      {
  return a.base_type == b.base_type && a.element == b.element &&
         (a.struct_def == b.struct_def ||
          (a.struct_def != nullptr && b.struct_def != nullptr &&
           a.struct_def->name == b.struct_def->name)) &&
         (a.enum_def == b.enum_def ||
          (a.enum_def != nullptr && b.enum_def != nullptr &&
           a.enum_def->name == b.enum_def->name));
}

References flatbuffers::Type::base_type, flatbuffers::Type::element, flatbuffers::Type::enum_def, flatbuffers::Definition::name, and flatbuffers::Type::struct_def.

◆ EscapeString()

bool flatbuffers::EscapeString	(	const char *	s,
		size_t	length,
		std::string *	_text,
		bool	allow_non_utf8,
		bool	natural_utf8
	)

inline

Definition at line 594 of file util.h.

                                                                 {
  std::string &text = *_text;
  text += "\"";
  for (uoffset_t i = 0; i < length; i++) {
    char c = s[i];
    switch (c) {
      case '\n': text += "\\n"; break;
      case '\t': text += "\\t"; break;
      case '\r': text += "\\r"; break;
      case '\b': text += "\\b"; break;
      case '\f': text += "\\f"; break;
      case '\"': text += "\\\""; break;
      case '\\': text += "\\\\"; break;
      default:
        if (c >= ' ' && c <= '~') {
          text += c;
        } else {
          // Not printable ASCII data. Let's see if it's valid UTF-8 first:
          const char *utf8 = s + i;
          int ucc = FromUTF8(&utf8);
          if (ucc < 0) {
            if (allow_non_utf8) {
              text += "\\x";
              text += IntToStringHex(static_cast<uint8_t>(c), 2);
            } else {
              // There are two cases here:
              //
              // 1) We reached here by parsing an IDL file. In that case,
              // we previously checked for non-UTF-8, so we shouldn't reach
              // here.
              //
              // 2) We reached here by someone calling GenText()
              // on a previously-serialized flatbuffer. The data might have
              // non-UTF-8 Strings, or might be corrupt.
              //
              // In both cases, we have to give up and inform the caller
              // they have no JSON.
              return false;
            }
          } else {
            if (natural_utf8) {
              // utf8 points to past all utf-8 bytes parsed
              text.append(s + i, static_cast<size_t>(utf8 - s - i));
            } else if (ucc <= 0xFFFF) {
              // Parses as Unicode within JSON's \uXXXX range, so use that.
              text += "\\u";
              text += IntToStringHex(ucc, 4);
            } else if (ucc <= 0x10FFFF) {
              // Encode Unicode SMP values to a surrogate pair using two \u
              // escapes.
              uint32_t base = ucc - 0x10000;
              auto high_surrogate = (base >> 10) + 0xD800;
              auto low_surrogate = (base & 0x03FF) + 0xDC00;
              text += "\\u";
              text += IntToStringHex(high_surrogate, 4);
              text += "\\u";
              text += IntToStringHex(low_surrogate, 4);
            }
            // Skip past characters recognized.
            i = static_cast<uoffset_t>(utf8 - s - 1);
          }
        }
        break;
    }
  }
  text += "\"";
  return true;
}

References FromUTF8(), and IntToStringHex().

Referenced by flatbuffers::ToStringVisitor::String(), and flexbuffers::Reference::ToString().

◆ FieldIndexToOffset()

voffset_t flatbuffers::FieldIndexToOffset ( voffset_t field_id )

inline

Definition at line 44 of file flatbuffer_builder.h.

                                                        {
  // Should correspond to what EndTable() below builds up.
  const voffset_t fixed_fields =
      2 * sizeof(voffset_t);  // Vtable size and Object Size.
  return fixed_fields + field_id * sizeof(voffset_t);
}

Referenced by IterateObject().

◆ FileExists()

bool flatbuffers::FileExists ( const char * name )

◆ FindHashFunction16()

NamedHashFunction< uint16_t >::HashFunction flatbuffers::FindHashFunction16 ( const char * name )

inline

Definition at line 92 of file hash.h.

                      {
  std::size_t size = sizeof(kHashFunctions16) / sizeof(kHashFunctions16[0]);
  for (std::size_t i = 0; i < size; ++i) {
    if (std::strcmp(name, kHashFunctions16[i].name) == 0) {
      return kHashFunctions16[i].function;
    }
  }
  return nullptr;
}

References flatbuffers::NamedHashFunction< T >::function, kHashFunctions16, and size.

◆ FindHashFunction32()

NamedHashFunction< uint32_t >::HashFunction flatbuffers::FindHashFunction32 ( const char * name )

inline

Definition at line 103 of file hash.h.

                      {
  std::size_t size = sizeof(kHashFunctions32) / sizeof(kHashFunctions32[0]);
  for (std::size_t i = 0; i < size; ++i) {
    if (std::strcmp(name, kHashFunctions32[i].name) == 0) {
      return kHashFunctions32[i].function;
    }
  }
  return nullptr;
}

References flatbuffers::NamedHashFunction< T >::function, kHashFunctions32, and size.

◆ FindHashFunction64()

NamedHashFunction< uint64_t >::HashFunction flatbuffers::FindHashFunction64 ( const char * name )

inline

Definition at line 114 of file hash.h.

                      {
  std::size_t size = sizeof(kHashFunctions64) / sizeof(kHashFunctions64[0]);
  for (std::size_t i = 0; i < size; ++i) {
    if (std::strcmp(name, kHashFunctions64[i].name) == 0) {
      return kHashFunctions64[i].function;
    }
  }
  return nullptr;
}

References flatbuffers::NamedHashFunction< T >::function, kHashFunctions64, and size.

◆ flatbuffers_version_string()

const char * flatbuffers::flatbuffers_version_string ( )

inline

Definition at line 243 of file flatbuffers.h.

                                                {
  return "FlatBuffers " FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MAJOR) "."
      FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MINOR) "."
      FLATBUFFERS_STRING(FLATBUFFERS_VERSION_REVISION);
}

◆ FlatBufferToString()

std::string flatbuffers::FlatBufferToString	(	const uint8_t *	buffer,
		const TypeTable *	type_table,
		bool	multi_line = `false`,
		bool	vector_delimited = `true`,
		const std::string &	indent = `""`
	)

inline

Definition at line 407 of file minireflect.h.

                                                                    {
  ToStringVisitor tostring_visitor(multi_line ? "\n" : " ", false, indent,
                                   vector_delimited);
  IterateFlatBuffer(buffer, type_table, &tostring_visitor);
  return tostring_visitor.s;
}

References IterateFlatBuffer(), and flatbuffers::ToStringVisitor::s.

◆ FloatToString()

template<typename T >

std::string flatbuffers::FloatToString	(	T	t,
		int	precision
	)

Definition at line 153 of file util.h.

                                                                 {
  // clang-format off
 
  #ifndef FLATBUFFERS_PREFER_PRINTF
    // to_string() prints different numbers of digits for floats depending on
    // platform and isn't available on Android, so we use stringstream
    std::stringstream ss;
    // Use std::fixed to suppress scientific notation.
    ss << std::fixed;
    // Default precision is 6, we want that to be higher for doubles.
    ss << std::setprecision(precision);
    ss << t;
    auto s = ss.str();
  #else // FLATBUFFERS_PREFER_PRINTF
    auto v = static_cast<double>(t);
    auto s = NumToStringImplWrapper(v, "%0.*f", precision);
  #endif // FLATBUFFERS_PREFER_PRINTF
  // clang-format on
  // Sadly, std::fixed turns "1" into "1.00000", so here we undo that.
  auto p = s.find_last_not_of('0');
  if (p != std::string::npos) {
    // Strip trailing zeroes. If it is a whole number, keep one zero.
    s.resize(p + (s[p] == '.' ? 2 : 1));
  }
  return s;
}

References p.

Referenced by NumToString< double >(), and NumToString< float >().

◆ ForAllFields()

void flatbuffers::ForAllFields	(	const reflection::Object *	object,
		bool	reverse,
		std::function< void(const reflection::Field *)>	func
	)

◆ FromUTF8()

int flatbuffers::FromUTF8 ( const char ** in )

inline

Definition at line 522 of file util.h.

                                     {
  int len = 0;
  // Count leading 1 bits.
  for (int mask = 0x80; mask >= 0x04; mask >>= 1) {
    if (**in & mask) {
      len++;
    } else {
      break;
    }
  }
  if ((static_cast<unsigned char>(**in) << len) & 0x80)
    return -1;  // Bit after leading 1's must be 0.
  if (!len) return *(*in)++;
  // UTF-8 encoded values with a length are between 2 and 4 bytes.
  if (len < 2 || len > 4) { return -1; }
  // Grab initial bits of the code.
  int ucc = *(*in)++ & ((1 << (7 - len)) - 1);
  for (int i = 0; i < len - 1; i++) {
    if ((**in & 0xC0) != 0x80) return -1;  // Upper bits must 1 0.
    ucc <<= 6;
    ucc |= *(*in)++ & 0x3F;  // Grab 6 more bits of the code.
  }
  // UTF-8 cannot encode values between 0xD800 and 0xDFFF (reserved for
  // UTF-16 surrogate pairs).
  if (ucc >= 0xD800 && ucc <= 0xDFFF) { return -1; }
  // UTF-8 must represent code points in their shortest possible encoding.
  switch (len) {
    case 2:
      // Two bytes of UTF-8 can represent code points from U+0080 to U+07FF.
      if (ucc < 0x0080 || ucc > 0x07FF) { return -1; }
      break;
    case 3:
      // Three bytes of UTF-8 can represent code points from U+0800 to U+FFFF.
      if (ucc < 0x0800 || ucc > 0xFFFF) { return -1; }
      break;
    case 4:
      // Four bytes of UTF-8 can represent code points from U+10000 to U+10FFFF.
      if (ucc < 0x10000 || ucc > 0x10FFFF) { return -1; }
      break;
  }
  return ucc;
}

Referenced by EscapeString().

◆ GenComment()

void flatbuffers::GenComment	(	const std::vector< std::string > &	dc,
		std::string *	code_ptr,
		const CommentConfig *	config,
		const char *	prefix = `""`
	)

extern

◆ GenerateCppGRPC()

bool flatbuffers::GenerateCppGRPC	(	const Parser &	parser,
		const std::string &	path,
		const std::string &	file_name
	)

◆ GenerateGoGRPC()

bool flatbuffers::GenerateGoGRPC	(	const Parser &	parser,
		const std::string &	path,
		const std::string &	file_name
	)

◆ GenerateJavaGRPC()

bool flatbuffers::GenerateJavaGRPC	(	const Parser &	parser,
		const std::string &	path,
		const std::string &	file_name
	)

◆ GeneratePythonGRPC()

bool flatbuffers::GeneratePythonGRPC	(	const Parser &	parser,
		const std::string &	path,
		const std::string &	file_name
	)

◆ GenerateSwiftGRPC()

bool flatbuffers::GenerateSwiftGRPC	(	const Parser &	parser,
		const std::string &	path,
		const std::string &	file_name
	)

extern

◆ GenerateTSGRPC()

bool flatbuffers::GenerateTSGRPC	(	const Parser &	parser,
		const std::string &	path,
		const std::string &	file_name
	)

extern

◆ GenText()

const char * flatbuffers::GenText	(	const Parser &	parser,
		const void *	flatbuffer,
		std::string *	text
	)

extern

Referenced by flatbuffers::Registry::FlatBufferToText().

◆ GenTextFile()

const char * flatbuffers::GenTextFile	(	const Parser &	parser,
		const std::string &	path,
		const std::string &	file_name
	)

extern

◆ GenTextFromTable()

const char * flatbuffers::GenTextFromTable	(	const Parser &	parser,
		const void *	table,
		const std::string &	tablename,
		std::string *	text
	)

extern

◆ GetAnyFieldAddressOf() [1/2]

template<typename T >

T * flatbuffers::GetAnyFieldAddressOf	(	const Struct &	st,
		const reflection::Field &	field
	)

Definition at line 288 of file reflection.h.

                                                                        {
  return reinterpret_cast<T *>(st.GetAddressOf(field.offset()));
}

◆ GetAnyFieldAddressOf() [2/2]

template<typename T >

T * flatbuffers::GetAnyFieldAddressOf	(	const Table &	table,
		const reflection::Field &	field
	)

Definition at line 282 of file reflection.h.

                                                                          {
  return reinterpret_cast<T *>(table.GetAddressOf(field.offset()));
}

References flatbuffers::Table::GetAddressOf().

◆ GetAnyFieldF() [1/2]

double flatbuffers::GetAnyFieldF	(	const Struct &	st,
		const reflection::Field &	field
	)

inline

Definition at line 229 of file reflection.h.

                                                                           {
  return GetAnyValueF(field.type()->base_type(),
                      st.GetAddressOf(field.offset()));
}

References GetAnyValueF().

◆ GetAnyFieldF() [2/2]

double flatbuffers::GetAnyFieldF	(	const Table &	table,
		const reflection::Field &	field
	)

inline

Definition at line 204 of file reflection.h.

                                                                             {
  auto field_ptr = table.GetAddressOf(field.offset());
  return field_ptr ? GetAnyValueF(field.type()->base_type(), field_ptr)
                   : field.default_real();
}

References flatbuffers::Table::GetAddressOf(), and GetAnyValueF().

◆ GetAnyFieldI() [1/2]

int64_t flatbuffers::GetAnyFieldI	(	const Struct &	st,
		const reflection::Field &	field
	)

inline

Definition at line 223 of file reflection.h.

                                                                            {
  return GetAnyValueI(field.type()->base_type(),
                      st.GetAddressOf(field.offset()));
}

References GetAnyValueI().

◆ GetAnyFieldI() [2/2]

int64_t flatbuffers::GetAnyFieldI	(	const Table &	table,
		const reflection::Field &	field
	)

inline

Definition at line 196 of file reflection.h.

                                                          {
  auto field_ptr = table.GetAddressOf(field.offset());
  return field_ptr ? GetAnyValueI(field.type()->base_type(), field_ptr)
                   : field.default_integer();
}

References flatbuffers::Table::GetAddressOf(), and GetAnyValueI().

◆ GetAnyFieldS() [1/2]

std::string flatbuffers::GetAnyFieldS	(	const Struct &	st,
		const reflection::Field &	field
	)

inline

Definition at line 235 of file reflection.h.

                                                              {
  return GetAnyValueS(field.type()->base_type(),
                      st.GetAddressOf(field.offset()), nullptr, -1);
}

References GetAnyValueS().

◆ GetAnyFieldS() [2/2]

std::string flatbuffers::GetAnyFieldS	(	const Table &	table,
		const reflection::Field &	field,
		const reflection::Schema *	schema
	)

inline

Definition at line 213 of file reflection.h.

                                                                {
  auto field_ptr = table.GetAddressOf(field.offset());
  return field_ptr ? GetAnyValueS(field.type()->base_type(), field_ptr, schema,
                                  field.type()->index())
                   : "";
}

References flatbuffers::Table::GetAddressOf(), and GetAnyValueS().

◆ GetAnyRoot() [1/2]

const Table * flatbuffers::GetAnyRoot ( const uint8_t *const flatbuf )

inline

Definition at line 96 of file reflection.h.

                                                             {
  return GetRoot<Table>(flatbuf);
}

◆ GetAnyRoot() [2/2]

Table * flatbuffers::GetAnyRoot ( uint8_t *const flatbuf )

inline

Definition at line 92 of file reflection.h.

                                                 {
  return GetMutableRoot<Table>(flatbuf);
}

◆ GetAnySizePrefixedRoot() [1/2]

const Table * flatbuffers::GetAnySizePrefixedRoot ( const uint8_t *const flatbuf )

inline

Definition at line 104 of file reflection.h.

                                                                         {
  return GetSizePrefixedRoot<Table>(flatbuf);
}

◆ GetAnySizePrefixedRoot() [2/2]

Table * flatbuffers::GetAnySizePrefixedRoot ( uint8_t *const flatbuf )

inline

Definition at line 100 of file reflection.h.

                                                             {
  return GetMutableSizePrefixedRoot<Table>(flatbuf);
}

◆ GetAnyValueF()

double flatbuffers::GetAnyValueF	(	reflection::BaseType	type,
		const uint8_t *	data
	)

Referenced by GetAnyFieldF(), GetAnyFieldF(), and GetAnyVectorElemF().

◆ GetAnyValueI()

int64_t flatbuffers::GetAnyValueI	(	reflection::BaseType	type,
		const uint8_t *	data
	)

Referenced by GetAnyFieldI(), GetAnyFieldI(), and GetAnyVectorElemI().

◆ GetAnyValueS()

std::string flatbuffers::GetAnyValueS	(	reflection::BaseType	type,
		const uint8_t *	data,
		const reflection::Schema *	schema,
		int	type_index
	)

Referenced by GetAnyFieldS(), GetAnyFieldS(), and GetAnyVectorElemS().

◆ GetAnyVectorElemAddressOf()

template<typename T >

T * flatbuffers::GetAnyVectorElemAddressOf	(	const VectorOfAny *	vec,
		size_t	i,
		size_t	elem_size
	)

Definition at line 275 of file reflection.h.

                                               {
  return reinterpret_cast<T *>(vec->Data() + elem_size * i);
}

References flatbuffers::VectorOfAny::Data().

◆ GetAnyVectorElemF()

double flatbuffers::GetAnyVectorElemF	(	const VectorOfAny *	vec,
		reflection::BaseType	elem_type,
		size_t	i
	)

inline

Definition at line 248 of file reflection.h.

                                                                        {
  return GetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i);
}

References flatbuffers::VectorOfAny::Data(), GetAnyValueF(), and GetTypeSize().

◆ GetAnyVectorElemI()

int64_t flatbuffers::GetAnyVectorElemI	(	const VectorOfAny *	vec,
		reflection::BaseType	elem_type,
		size_t	i
	)

inline

Definition at line 242 of file reflection.h.

                                                                         {
  return GetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i);
}

References flatbuffers::VectorOfAny::Data(), GetAnyValueI(), and GetTypeSize().

◆ GetAnyVectorElemPointer()

template<typename T >

T * flatbuffers::GetAnyVectorElemPointer	(	const VectorOfAny *	vec,
		size_t	i
	)

Definition at line 264 of file reflection.h.

                                                             {
  auto elem_ptr = vec->Data() + sizeof(uoffset_t) * i;
  return reinterpret_cast<T *>(elem_ptr + ReadScalar<uoffset_t>(elem_ptr));
}

References flatbuffers::VectorOfAny::Data().

◆ GetAnyVectorElemS()

std::string flatbuffers::GetAnyVectorElemS	(	const VectorOfAny *	vec,
		reflection::BaseType	elem_type,
		size_t	i
	)

inline

Definition at line 254 of file reflection.h.

                                                                             {
  return GetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i,
                      nullptr, -1);
}

References flatbuffers::VectorOfAny::Data(), GetAnyValueS(), and GetTypeSize().

◆ GetBufferStartFromRootPointer()

const uint8_t * flatbuffers::GetBufferStartFromRootPointer ( const void * root )

inline

This can compute the start of a FlatBuffer from a root pointer, i.e. it is the opposite transformation of GetRoot(). This may be useful if you want to pass on a root and have the recipient delete the buffer afterwards.

Definition at line 44 of file flatbuffers.h.

                                                                      {
  auto table = reinterpret_cast<const Table *>(root);
  auto vtable = table->GetVTable();
  // Either the vtable is before the root or after the root.
  auto start = (std::min)(vtable, reinterpret_cast<const uint8_t *>(root));
  // Align to at least sizeof(uoffset_t).
  start = reinterpret_cast<const uint8_t *>(reinterpret_cast<uintptr_t>(start) &
                                            ~(sizeof(uoffset_t) - 1));
  // Additionally, there may be a file_identifier in the buffer, and the root
  // offset. The buffer may have been aligned to any size between
  // sizeof(uoffset_t) and FLATBUFFERS_MAX_ALIGNMENT (see "force_align").
  // Sadly, the exact alignment is only known when constructing the buffer,
  // since it depends on the presence of values with said alignment properties.
  // So instead, we simply look at the next uoffset_t values (root,
  // file_identifier, and alignment padding) to see which points to the root.
  // None of the other values can "impersonate" the root since they will either
  // be 0 or four ASCII characters.
  static_assert(flatbuffers::kFileIdentifierLength == sizeof(uoffset_t),
                "file_identifier is assumed to be the same size as uoffset_t");
  for (auto possible_roots = FLATBUFFERS_MAX_ALIGNMENT / sizeof(uoffset_t) + 1;
       possible_roots; possible_roots--) {
    start -= sizeof(uoffset_t);
    if (ReadScalar<uoffset_t>(start) + start ==
        reinterpret_cast<const uint8_t *>(root))
      return start;
  }
  // We didn't find the root, either the "root" passed isn't really a root,
  // or the buffer is corrupt.
  // Assert, because calling this function with bad data may cause reads
  // outside of buffer boundaries.
  FLATBUFFERS_ASSERT(false);
  return nullptr;
}

References FLATBUFFERS_ASSERT, and flatbuffers::Table::GetVTable().

◆ GetExtension()

std::string flatbuffers::GetExtension ( const std::string & filepath )

◆ GetFieldAnyV()

VectorOfAny * flatbuffers::GetFieldAnyV	(	const Table &	table,
		const reflection::Field &	field
	)

inline

Definition at line 154 of file reflection.h.

                                                               {
  return table.GetPointer<VectorOfAny *>(field.offset());
}

References flatbuffers::Table::GetPointer().

◆ GetFieldDefaultF()

template<typename T >

T flatbuffers::GetFieldDefaultF ( const reflection::Field & field )

Definition at line 115 of file reflection.h.

                                                                      {
  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
  return static_cast<T>(field.default_real());
}

References FLATBUFFERS_ASSERT, and GetTypeSize().

◆ GetFieldDefaultI()

template<typename T >

T flatbuffers::GetFieldDefaultI ( const reflection::Field & field )

Definition at line 109 of file reflection.h.

                                                                      {
  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
  return static_cast<T>(field.default_integer());
}

References FLATBUFFERS_ASSERT, and GetTypeSize().

◆ GetFieldF()

template<typename T >

T flatbuffers::GetFieldF	(	const Table &	table,
		const reflection::Field &	field
	)

Definition at line 130 of file reflection.h.

                                                              {
  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
  return table.GetField<T>(field.offset(),
                           static_cast<T>(field.default_real()));
}

References FLATBUFFERS_ASSERT, flatbuffers::Table::GetField(), and GetTypeSize().

◆ GetFieldI()

template<typename T >

T flatbuffers::GetFieldI	(	const Table &	table,
		const reflection::Field &	field
	)

Definition at line 122 of file reflection.h.

                                                              {
  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
  return table.GetField<T>(field.offset(),
                           static_cast<T>(field.default_integer()));
}

References FLATBUFFERS_ASSERT, flatbuffers::Table::GetField(), and GetTypeSize().

◆ GetFieldS()

const String * flatbuffers::GetFieldS	(	const Table &	table,
		const reflection::Field &	field
	)

inline

Definition at line 137 of file reflection.h.

                                                             {
  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::String);
  return table.GetPointer<const String *>(field.offset());
}

References FLATBUFFERS_ASSERT, and flatbuffers::Table::GetPointer().

◆ GetFieldStruct() [1/2]

const Struct * flatbuffers::GetFieldStruct	(	const Struct &	structure,
		const reflection::Field &	field
	)

inline

Definition at line 176 of file reflection.h.

                                                                  {
  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj);
  return structure.GetStruct<const Struct *>(field.offset());
}

References FLATBUFFERS_ASSERT.

◆ GetFieldStruct() [2/2]

const Struct * flatbuffers::GetFieldStruct	(	const Table &	table,
		const reflection::Field &	field
	)

inline

Definition at line 167 of file reflection.h.

                                                                  {
  // TODO: This does NOT check if the field is a table or struct, but we'd need
  // access to the schema to check the is_struct flag.
  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj);
  return table.GetStruct<const Struct *>(field.offset());
}

References FLATBUFFERS_ASSERT, and flatbuffers::Table::GetStruct().

◆ GetFieldT()

Table * flatbuffers::GetFieldT	(	const Table &	table,
		const reflection::Field &	field
	)

inline

Definition at line 160 of file reflection.h.

                                                                          {
  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj ||
                     field.type()->base_type() == reflection::Union);
  return table.GetPointer<Table *>(field.offset());
}

References FLATBUFFERS_ASSERT, and flatbuffers::Table::GetPointer().

◆ GetFieldV()

template<typename T >

Vector< T > * flatbuffers::GetFieldV	(	const Table &	table,
		const reflection::Field &	field
	)

Definition at line 145 of file reflection.h.

                                                                       {
  FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Vector &&
                     sizeof(T) == GetTypeSize(field.type()->element()));
  return table.GetPointer<Vector<T> *>(field.offset());
}

References FLATBUFFERS_ASSERT, flatbuffers::Table::GetPointer(), and GetTypeSize().

◆ GetMutableTemporaryPointer()

template<typename T >

T * flatbuffers::GetMutableTemporaryPointer	(	FlatBufferBuilder &	fbb,
		Offset< T >	offset
	)

Helpers to get a typed pointer to objects that are currently being built.

Warning: Creating new objects will lead to reallocations and invalidates the pointer!

Definition at line 1453 of file flatbuffer_builder.h.

                                                                        {
  return reinterpret_cast<T *>(fbb.GetCurrentBufferPointer() + fbb.GetSize() -
                               offset.o);
}

References flatbuffers::FlatBufferBuilderImpl< Is64Aware >::GetCurrentBufferPointer(), flatbuffers::FlatBufferBuilderImpl< Is64Aware >::GetSize(), and offset().

◆ GetPrefixedSize()

template<typename SizeT = uoffset_t>

SizeT flatbuffers::GetPrefixedSize ( const uint8_t * buf )

inline

This return the prefixed size of a FlatBuffer.

Definition at line 80 of file flatbuffers.h.

                                                 {
  return ReadScalar<SizeT>(buf);
}

◆ GetSizePrefixedBufferLength()

template<typename SizeT = uoffset_t>

SizeT flatbuffers::GetSizePrefixedBufferLength ( const uint8_t *const buf )

inline

Definition at line 91 of file flatbuffers.h.

                                                                   {
  return ReadScalar<SizeT>(buf) + sizeof(SizeT);
}

◆ GetTemporaryPointer()

template<typename T >

const T * flatbuffers::GetTemporaryPointer	(	FlatBufferBuilder &	fbb,
		Offset< T >	offset
	)

Definition at line 1459 of file flatbuffer_builder.h.

                                                                       {
  return GetMutableTemporaryPointer<T>(fbb, offset);
}

References offset().

◆ GetTypeSize()

size_t flatbuffers::GetTypeSize ( reflection::BaseType base_type )

inline

Definition at line 47 of file reflection.h.

                                                        {
  // This needs to correspond to the BaseType enum.
  static size_t sizes[] = {
    0,  // None
    1,  // UType
    1,  // Bool
    1,  // Byte
    1,  // UByte
    2,  // Short
    2,  // UShort
    4,  // Int
    4,  // UInt
    8,  // Long
    8,  // ULong
    4,  // Float
    8,  // Double
    4,  // String
    4,  // Vector
    4,  // Obj
    4,  // Union
    0,  // Array. Only used in structs. 0 was chosen to prevent out-of-bounds
        // errors.
    8,  // Vector64
 
    0  // MaxBaseType. This must be kept the last entry in this array.
  };
  static_assert(sizeof(sizes) / sizeof(size_t) == reflection::MaxBaseType + 1,
                "Size of sizes[] array does not match the count of BaseType "
                "enum values.");
  return sizes[base_type];
}

Referenced by GetAnyVectorElemF(), GetAnyVectorElemI(), GetAnyVectorElemS(), GetFieldDefaultF(), GetFieldDefaultI(), GetFieldF(), GetFieldI(), GetFieldV(), GetTypeSizeInline(), SetAnyVectorElemF(), SetAnyVectorElemI(), SetAnyVectorElemS(), SetField(), and SetFieldT().

◆ GetTypeSizeInline()

size_t flatbuffers::GetTypeSizeInline	(	reflection::BaseType	base_type,
		int	type_index,
		const reflection::Schema &	schema
	)

inline

Definition at line 81 of file reflection.h.

                                                                {
  if (base_type == reflection::Obj &&
      schema.objects()->Get(type_index)->is_struct()) {
    return schema.objects()->Get(type_index)->bytesize();
  } else {
    return GetTypeSize(base_type);
  }
}

References GetTypeSize().

◆ GetUnionType()

const reflection::Object & flatbuffers::GetUnionType	(	const reflection::Schema &	schema,
		const reflection::Object &	parent,
		const reflection::Field &	unionfield,
		const Table &	table
	)

inline

Definition at line 421 of file reflection.h.

                                                           {
  auto enumdef = schema.enums()->Get(unionfield.type()->index());
  // TODO: this is clumsy and slow, but no other way to find it?
  auto type_field = parent.fields()->LookupByKey(
      (unionfield.name()->str() + UnionTypeFieldSuffix()).c_str());
  FLATBUFFERS_ASSERT(type_field);
  auto union_type = GetFieldI<uint8_t>(table, *type_field);
  auto enumval = enumdef->values()->LookupByKey(union_type);
  return *schema.objects()->Get(enumval->union_type()->index());
}

References FLATBUFFERS_ASSERT, and UnionTypeFieldSuffix().

◆ HashFnv1()

template<typename T >

T flatbuffers::HashFnv1 ( const char * input )

Definition at line 42 of file hash.h.

                                                   {
  T hash = FnvTraits<T>::kOffsetBasis;
  for (const char *c = input; *c; ++c) {
    hash *= FnvTraits<T>::kFnvPrime;
    hash ^= static_cast<unsigned char>(*c);
  }
  return hash;
}

◆ HashFnv1< uint16_t >()

template<>

uint16_t flatbuffers::HashFnv1< uint16_t > ( const char * input )

inline

Definition at line 60 of file hash.h.

                                                                 {
  uint32_t hash = HashFnv1<uint32_t>(input);
  return (hash >> 16) ^ (hash & 0xffff);
}

◆ HashFnv1a()

template<typename T >

T flatbuffers::HashFnv1a ( const char * input )

Definition at line 51 of file hash.h.

                                                    {
  T hash = FnvTraits<T>::kOffsetBasis;
  for (const char *c = input; *c; ++c) {
    hash ^= static_cast<unsigned char>(*c);
    hash *= FnvTraits<T>::kFnvPrime;
  }
  return hash;
}

◆ HashFnv1a< uint16_t >()

template<>

uint16_t flatbuffers::HashFnv1a< uint16_t > ( const char * input )

inline

Definition at line 65 of file hash.h.

                                                                  {
  uint32_t hash = HashFnv1a<uint32_t>(input);
  return (hash >> 16) ^ (hash & 0xffff);
}

◆ InlineAlignment()

size_t flatbuffers::InlineAlignment ( const Type & type )

inline

Definition at line 567 of file idl.h.

                                                {
  if (IsStruct(type)) {
    return type.struct_def->minalign;
  } else if (IsArray(type)) {
    return IsStruct(type.VectorType()) ? type.struct_def->minalign
                                       : SizeOf(type.element);
  } else {
    return SizeOf(type.base_type);
  }
}

References IsArray(), IsStruct(), SizeOf(), and type.

◆ InlineSize() [1/2]

size_t flatbuffers::InlineSize ( const Type & type )

inline

Definition at line 559 of file idl.h.

                                           {
  return IsStruct(type)
             ? type.struct_def->bytesize
             : (IsArray(type)
                    ? InlineSize(type.VectorType()) * type.fixed_length
                    : SizeOf(type.base_type));
}

References InlineSize(), IsArray(), IsStruct(), SizeOf(), and type.

Referenced by InlineSize(), and IterateObject().

◆ InlineSize() [2/2]

size_t flatbuffers::InlineSize	(	ElementaryType	type,
		const TypeTable *	type_table
	)

inline

Definition at line 72 of file minireflect.h.

                                                                           {
  switch (type) {
    case ET_UTYPE:
    case ET_BOOL:
    case ET_CHAR:
    case ET_UCHAR: return 1;
    case ET_SHORT:
    case ET_USHORT: return 2;
    case ET_INT:
    case ET_UINT:
    case ET_FLOAT:
    case ET_STRING: return 4;
    case ET_LONG:
    case ET_ULONG:
    case ET_DOUBLE: return 8;
    case ET_SEQUENCE:
      switch (type_table->st) {
        case ST_TABLE:
        case ST_UNION: return 4;
        case ST_STRUCT:
          return static_cast<size_t>(type_table->values[type_table->num_elems]);
        default: FLATBUFFERS_ASSERT(false); return 1;
      }
    default: FLATBUFFERS_ASSERT(false); return 1;
  }
}

References FLATBUFFERS_ASSERT, flatbuffers::TypeTable::num_elems, flatbuffers::TypeTable::st, ST_STRUCT, ST_TABLE, ST_UNION, type, and flatbuffers::TypeTable::values.

◆ IntToStringHex()

std::string flatbuffers::IntToStringHex	(	int	i,
		int	xdigits
	)

inline

Definition at line 190 of file util.h.

                                                    {
  FLATBUFFERS_ASSERT(i >= 0);
  // clang-format off
 
  #ifndef FLATBUFFERS_PREFER_PRINTF
    std::stringstream ss;
    ss << std::setw(xdigits) << std::setfill('0') << std::hex << std::uppercase
       << i;
    return ss.str();
  #else // FLATBUFFERS_PREFER_PRINTF
    return NumToStringImplWrapper(i, "%.*X", xdigits);
  #endif // FLATBUFFERS_PREFER_PRINTF
  // clang-format on
}

References FLATBUFFERS_ASSERT.

Referenced by BufferToHexText(), and EscapeString().

◆ is_alnum()

bool flatbuffers::is_alnum ( char c )

inline

Definition at line 80 of file util.h.

80{ return is_alpha(c) || is_digit(c); }

flatbuffers::is_alpha

bool is_alpha(char c)

Definition util.h:52

flatbuffers::is_digit

bool is_digit(char c)

Definition util.h:72

References is_alpha(), and is_digit().

Referenced by flexbuffers::Reference::ToString().

◆ is_alpha()

bool flatbuffers::is_alpha ( char c )

inline

Definition at line 52 of file util.h.

                             {
  // ASCII only: alpha to upper case => reset bit 0x20 (~0x20 = 0xDF).
  return check_ascii_range(c & 0xDF, 'a' & 0xDF, 'z' & 0xDF);
}

References check_ascii_range().

Referenced by is_alnum(), is_alpha_char(), and flexbuffers::Reference::ToString().

◆ is_alpha_char()

bool flatbuffers::is_alpha_char	(	char	c,
		char	alpha
	)

inline

Definition at line 61 of file util.h.

                                              {
  FLATBUFFERS_ASSERT(is_alpha(alpha));
  // ASCII only: alpha to upper case => reset bit 0x20 (~0x20 = 0xDF).
  return ((c & 0xDF) == (alpha & 0xDF));
}

References FLATBUFFERS_ASSERT, and is_alpha().

Referenced by StringToIntegerImpl().

◆ is_alpha_upper()

bool flatbuffers::is_alpha_upper ( char c )

inline

Definition at line 58 of file util.h.

58{ return check_ascii_range(c, 'A', 'Z'); }

References check_ascii_range().

◆ is_digit()

bool flatbuffers::is_digit ( char c )

inline

Definition at line 72 of file util.h.

72{ return check_ascii_range(c, '0', '9'); }

References check_ascii_range().

Referenced by is_alnum(), is_xdigit(), StringToIntegerImpl(), and StringToNumber< uint64_t >().

◆ is_xdigit()

bool flatbuffers::is_xdigit ( char c )

inline

Definition at line 74 of file util.h.

                              {
  // Replace by look-up table.
  return is_digit(c) || check_ascii_range(c & 0xDF, 'a' & 0xDF, 'f' & 0xDF);
}

References check_ascii_range(), and is_digit().

◆ IsArray()

bool flatbuffers::IsArray ( const Type & type )

inline

Definition at line 547 of file idl.h.

                                      {
  return type.base_type == BASE_TYPE_ARRAY;
}

References type.

Referenced by InlineAlignment(), InlineSize(), and IsSeries().

◆ IsBool()

bool flatbuffers::IsBool ( BaseType t )

inline

Definition at line 140 of file idl.h.

140{ return t == BASE_TYPE_BOOL; }

◆ IsEnum()

bool flatbuffers::IsEnum ( const Type & type )

inline

Definition at line 555 of file idl.h.

                                     {
  return type.enum_def != nullptr && IsInteger(type.base_type);
}

References IsInteger(), and type.

◆ IsFieldPresent()

template<typename T >

bool flatbuffers::IsFieldPresent	(	const T *	table,
		typename T::FlatBuffersVTableOffset	field
	)

Definition at line 121 of file flatbuffers.h.

                                                                             {
  // Cast, since Table is a private baseclass of any table types.
  return reinterpret_cast<const Table *>(table)->CheckField(
      static_cast<voffset_t>(field));
}

◆ IsFloat() [1/2]

bool flatbuffers::IsFloat ( BaseType t )

inline

Definition at line 136 of file idl.h.

136 { return t == BASE_TYPE_FLOAT ||

137 t == BASE_TYPE_DOUBLE; }

Referenced by SetField().

◆ IsFloat() [2/2]

bool flatbuffers::IsFloat ( reflection::BaseType t )

inline

Definition at line 39 of file reflection.h.

                                          {
  return t == reflection::Float || t == reflection::Double;
}

◆ IsIncompleteStruct()

bool flatbuffers::IsIncompleteStruct ( const Type & type )

inline

Definition at line 521 of file idl.h.

                                                 {
  return type.base_type == BASE_TYPE_STRUCT && type.struct_def->predecl;
}

References type.

◆ IsInteger() [1/2]

bool flatbuffers::IsInteger ( BaseType t )

inline

Definition at line 134 of file idl.h.

134 { return t >= BASE_TYPE_UTYPE &&

135 t <= BASE_TYPE_ULONG; }

Referenced by IsEnum(), IsUnionType(), and SetField().

◆ IsInteger() [2/2]

bool flatbuffers::IsInteger ( reflection::BaseType t )

inline

Definition at line 36 of file reflection.h.

                                            {
  return t >= reflection::UType && t <= reflection::ULong;
}

◆ IsLong() [1/2]

bool flatbuffers::IsLong ( BaseType t )

inline

Definition at line 138 of file idl.h.

138 { return t == BASE_TYPE_LONG ||

139 t == BASE_TYPE_ULONG; }

◆ IsLong() [2/2]

bool flatbuffers::IsLong ( reflection::BaseType t )

inline

Definition at line 42 of file reflection.h.

                                         {
  return t == reflection::Long || t == reflection::ULong;
}

◆ IsOneByte()

bool flatbuffers::IsOneByte ( BaseType t )

inline

Definition at line 141 of file idl.h.

141 { return t >= BASE_TYPE_UTYPE &&

142 t <= BASE_TYPE_UCHAR; }

◆ IsScalar() [1/2]

bool flatbuffers::IsScalar ( BaseType t )

inline

Definition at line 132 of file idl.h.

132 { return t >= BASE_TYPE_UTYPE &&

133 t <= BASE_TYPE_DOUBLE; }

Referenced by flatbuffers::FieldDef::IsScalarOptional(), and SetField().

◆ IsScalar() [2/2]

bool flatbuffers::IsScalar ( reflection::BaseType t )

inline

Definition at line 33 of file reflection.h.

                                           {
  return t >= reflection::UType && t <= reflection::Double;
}

◆ IsSeries()

bool flatbuffers::IsSeries ( const Type & type )

inline

Definition at line 551 of file idl.h.

                                       {
  return IsVector(type) || IsArray(type);
}

References IsArray(), IsVector(), and type.

◆ IsString()

bool flatbuffers::IsString ( const Type & type )

inline

Definition at line 513 of file idl.h.

                                       {
  return type.base_type == BASE_TYPE_STRING;
}

References type.

◆ IsStruct()

bool flatbuffers::IsStruct ( const Type & type )

inline

Definition at line 517 of file idl.h.

                                       {
  return type.base_type == BASE_TYPE_STRUCT && type.struct_def->fixed;
}

References type.

Referenced by InlineAlignment(), InlineSize(), and IsVectorOfStruct().

◆ IsTable()

bool flatbuffers::IsTable ( const Type & type )

inline

Definition at line 525 of file idl.h.

                                      {
  return type.base_type == BASE_TYPE_STRUCT && !type.struct_def->fixed;
}

References type.

Referenced by IsVectorOfTable().

◆ IsUnion()

bool flatbuffers::IsUnion ( const Type & type )

inline

Definition at line 529 of file idl.h.

                                      {
  return type.enum_def != nullptr && type.enum_def->is_union;
}

References type.

Referenced by IsUnionType().

◆ IsUnionType()

bool flatbuffers::IsUnionType ( const Type & type )

inline

Definition at line 533 of file idl.h.

                                          {
  return IsUnion(type) && IsInteger(type.base_type);
}

References IsInteger(), IsUnion(), and type.

◆ IsUnsigned()

bool flatbuffers::IsUnsigned ( BaseType t )

inline

Definition at line 146 of file idl.h.

                                   {
  return (t == BASE_TYPE_UTYPE)  || (t == BASE_TYPE_UCHAR) ||
         (t == BASE_TYPE_USHORT) || (t == BASE_TYPE_UINT)  ||
         (t == BASE_TYPE_ULONG);
}

◆ IsVector() [1/2]

bool flatbuffers::IsVector ( BaseType t )

inline

Definition at line 143 of file idl.h.

143 { return t == BASE_TYPE_VECTOR ||

144 t == BASE_TYPE_VECTOR64; }

Referenced by IsSeries(), IsVector(), IsVectorOfStruct(), and IsVectorOfTable().

◆ IsVector() [2/2]

bool flatbuffers::IsVector ( const Type & type )

inline

Definition at line 537 of file idl.h.

537{ return IsVector(type.base_type); }

References IsVector(), and type.

◆ IsVectorOfStruct()

bool flatbuffers::IsVectorOfStruct ( const Type & type )

inline

Definition at line 539 of file idl.h.

                                               {
  return IsVector(type) && IsStruct(type.VectorType());
}

References IsStruct(), IsVector(), and type.

◆ IsVectorOfTable()

bool flatbuffers::IsVectorOfTable ( const Type & type )

inline

Definition at line 543 of file idl.h.

                                              {
  return IsVector(type) && IsTable(type.VectorType());
}

References IsTable(), IsVector(), and type.

◆ IterateFlatBuffer()

void flatbuffers::IterateFlatBuffer	(	const uint8_t *	buffer,
		const TypeTable *	type_table,
		IterationVisitor *	callback
	)

inline

Definition at line 287 of file minireflect.h.

                                                          {
  IterateObject(GetRoot<uint8_t>(buffer), type_table, callback);
}

References IterateObject().

Referenced by FlatBufferToString().

◆ IterateObject()

void flatbuffers::IterateObject	(	const uint8_t *	obj,
		const TypeTable *	type_table,
		IterationVisitor *	visitor
	)

inline

Definition at line 232 of file minireflect.h.

                                                     {
  visitor->StartSequence();
  const uint8_t *prev_val = nullptr;
  size_t set_idx = 0;
  size_t array_idx = 0;
  for (size_t i = 0; i < type_table->num_elems; i++) {
    auto type_code = type_table->type_codes[i];
    auto type = static_cast<ElementaryType>(type_code.base_type);
    auto is_repeating = type_code.is_repeating != 0;
    auto ref_idx = type_code.sequence_ref;
    const TypeTable *ref = nullptr;
    if (ref_idx >= 0) { ref = type_table->type_refs[ref_idx](); }
    auto name = type_table->names ? type_table->names[i] : nullptr;
    const uint8_t *val = nullptr;
    if (type_table->st == ST_TABLE) {
      val = reinterpret_cast<const Table *>(obj)->GetAddressOf(
          FieldIndexToOffset(static_cast<voffset_t>(i)));
    } else {
      val = obj + type_table->values[i];
    }
    visitor->Field(i, set_idx, type, is_repeating, ref, name, val);
    if (val) {
      set_idx++;
      if (is_repeating) {
        auto elem_ptr = val;
        size_t size = 0;
        if (type_table->st == ST_TABLE) {
          // variable length vector
          val += ReadScalar<uoffset_t>(val);
          auto vec = reinterpret_cast<const Vector<uint8_t> *>(val);
          elem_ptr = vec->Data();
          size = vec->size();
        } else {
          // otherwise fixed size array
          size = type_table->array_sizes[array_idx];
          ++array_idx;
        }
        visitor->StartVector();
        for (size_t j = 0; j < size; j++) {
          visitor->Element(j, type, ref, elem_ptr);
          IterateValue(type, elem_ptr, ref, prev_val, static_cast<soffset_t>(j),
                       visitor);
          elem_ptr += InlineSize(type, ref);
        }
        visitor->EndVector();
      } else {
        IterateValue(type, val, ref, prev_val, -1, visitor);
      }
    }
    prev_val = val;
  }
  visitor->EndSequence();
}

References flatbuffers::TypeTable::array_sizes, flatbuffers::Vector< T, SizeT >::Data(), flatbuffers::IterationVisitor::Element(), flatbuffers::IterationVisitor::EndSequence(), flatbuffers::IterationVisitor::EndVector(), flatbuffers::IterationVisitor::Field(), FieldIndexToOffset(), InlineSize(), flatbuffers::TypeCode::is_repeating, IterateValue(), flatbuffers::TypeTable::names, flatbuffers::TypeTable::num_elems, size, flatbuffers::TypeTable::st, ST_TABLE, flatbuffers::IterationVisitor::StartSequence(), flatbuffers::IterationVisitor::StartVector(), type, flatbuffers::TypeTable::type_codes, flatbuffers::TypeTable::type_refs, and flatbuffers::TypeTable::values.

Referenced by IterateFlatBuffer(), and IterateValue().

◆ IterateValue()

void flatbuffers::IterateValue	(	ElementaryType	type,
		const uint8_t *	val,
		const TypeTable *	type_table,
		const uint8_t *	prev_val,
		soffset_t	vector_index,
		IterationVisitor *	visitor
	)

inline

Definition at line 121 of file minireflect.h.

                                                                            {
  switch (type) {
    case ET_UTYPE: {
      auto tval = ReadScalar<uint8_t>(val);
      visitor->UType(tval, EnumName(tval, type_table));
      break;
    }
    case ET_BOOL: {
      visitor->Bool(ReadScalar<uint8_t>(val) != 0);
      break;
    }
    case ET_CHAR: {
      auto tval = ReadScalar<int8_t>(val);
      visitor->Char(tval, EnumName(tval, type_table));
      break;
    }
    case ET_UCHAR: {
      auto tval = ReadScalar<uint8_t>(val);
      visitor->UChar(tval, EnumName(tval, type_table));
      break;
    }
    case ET_SHORT: {
      auto tval = ReadScalar<int16_t>(val);
      visitor->Short(tval, EnumName(tval, type_table));
      break;
    }
    case ET_USHORT: {
      auto tval = ReadScalar<uint16_t>(val);
      visitor->UShort(tval, EnumName(tval, type_table));
      break;
    }
    case ET_INT: {
      auto tval = ReadScalar<int32_t>(val);
      visitor->Int(tval, EnumName(tval, type_table));
      break;
    }
    case ET_UINT: {
      auto tval = ReadScalar<uint32_t>(val);
      visitor->UInt(tval, EnumName(tval, type_table));
      break;
    }
    case ET_LONG: {
      visitor->Long(ReadScalar<int64_t>(val));
      break;
    }
    case ET_ULONG: {
      visitor->ULong(ReadScalar<uint64_t>(val));
      break;
    }
    case ET_FLOAT: {
      visitor->Float(ReadScalar<float>(val));
      break;
    }
    case ET_DOUBLE: {
      visitor->Double(ReadScalar<double>(val));
      break;
    }
    case ET_STRING: {
      val += ReadScalar<uoffset_t>(val);
      visitor->String(reinterpret_cast<const String *>(val));
      break;
    }
    case ET_SEQUENCE: {
      switch (type_table->st) {
        case ST_TABLE:
          val += ReadScalar<uoffset_t>(val);
          IterateObject(val, type_table, visitor);
          break;
        case ST_STRUCT: IterateObject(val, type_table, visitor); break;
        case ST_UNION: {
          val += ReadScalar<uoffset_t>(val);
          FLATBUFFERS_ASSERT(prev_val);
          auto union_type = *prev_val;  // Always a uint8_t.
          if (vector_index >= 0) {
            auto type_vec = reinterpret_cast<const Vector<uint8_t> *>(prev_val);
            union_type = type_vec->Get(static_cast<uoffset_t>(vector_index));
          }
          auto type_code_idx =
              LookupEnum(union_type, type_table->values, type_table->num_elems);
          if (type_code_idx >= 0 &&
              type_code_idx < static_cast<int32_t>(type_table->num_elems)) {
            auto type_code = type_table->type_codes[type_code_idx];
            switch (type_code.base_type) {
              case ET_SEQUENCE: {
                auto ref = type_table->type_refs[type_code.sequence_ref]();
                IterateObject(val, ref, visitor);
                break;
              }
              case ET_STRING:
                visitor->String(reinterpret_cast<const String *>(val));
                break;
              default: visitor->Unknown(val);
            }
          } else {
            visitor->Unknown(val);
          }
          break;
        }
        case ST_ENUM: FLATBUFFERS_ASSERT(false); break;
      }
      break;
    }
    default: {
      visitor->Unknown(val);
      break;
    }
  }
}

Referenced by IterateObject().

◆ JavaCSharpMakeRule()

std::string flatbuffers::JavaCSharpMakeRule	(	const bool	java,
		const Parser &	parser,
		const std::string &	path,
		const std::string &	file_name
	)

◆ LoadFile()

bool flatbuffers::LoadFile	(	const char *	name,
		bool	binary,
		std::string *	buf
	)

◆ LogCompilerError()

void flatbuffers::LogCompilerError ( const std::string & err )

extern

◆ LogCompilerWarn()

void flatbuffers::LogCompilerWarn ( const std::string & warn )

extern

◆ LookupEnum() [1/2]

int flatbuffers::LookupEnum	(	const char **	names,
		const char *	name
	)

inline

Definition at line 130 of file flatbuffers.h.

                                                            {
  for (const char **p = names; *p; p++)
    if (!strcmp(*p, name)) return static_cast<int>(p - names);
  return -1;
}

References p.

Referenced by EnumName(), and IterateValue().

◆ LookupEnum() [2/2]

int64_t flatbuffers::LookupEnum	(	int64_t	enum_val,
		const int64_t *	values,
		size_t	num_values
	)

inline

Definition at line 99 of file minireflect.h.

                                             {
  if (!values) return enum_val;
  for (size_t i = 0; i < num_values; i++) {
    if (enum_val == values[i]) return static_cast<int64_t>(i);
  }
  return -1;  // Unknown enum value.
}

◆ make_bytes_span() [1/4]

template<class U , uint16_t N>

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< uint8_t, sizeof(U) *N > flatbuffers::make_bytes_span ( Array< U, N > & arr )

Definition at line 207 of file array.h.

                                                       {
  static_assert(Array<U, N>::is_span_observable,
                "internal error, Array<T> might hold only scalars or structs");
  return span<uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
}

◆ make_bytes_span() [2/4]

template<class U , uint16_t N>

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const uint8_t, sizeof(U) *N > flatbuffers::make_bytes_span ( const Array< U, N > & arr )

Definition at line 215 of file array.h.

                                                             {
  static_assert(Array<U, N>::is_span_observable,
                "internal error, Array<T> might hold only scalars or structs");
  return span<const uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
}

◆ make_bytes_span() [3/4]

template<class U >

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const uint8_t > flatbuffers::make_bytes_span ( const Vector & vec )

Definition at line 331 of file vector.h.

                                               {
  static_assert(Vector<U>::scalar_tag::value,
                "wrong type U, only LE-scalar, or byte types are allowed");
  return span<const uint8_t>(vec.Data(), vec.size() * sizeof(U));
}

◆ make_bytes_span() [4/4]

template<class U >

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< uint8_t > flatbuffers::make_bytes_span ( Vector & vec )

Definition at line 323 of file vector.h.

                                         {
  static_assert(Vector<U>::scalar_tag::value,
                "wrong type U, only LE-scalar, or byte types are allowed");
  return span<uint8_t>(vec.Data(), vec.size() * sizeof(U));
}

◆ make_span() [1/6]

template<class U , uint16_t N>

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< U, N > flatbuffers::make_span ( Array< U, N > & arr )

Definition at line 188 of file array.h.

                         {
  static_assert(
      Array<U, N>::is_span_observable,
      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
  return span<U, N>(arr.data(), N);
}

Referenced by make_span(), and make_span().

◆ make_span() [2/6]

template<class U , uint16_t N>

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const U, N > flatbuffers::make_span ( const Array< U, N > & arr )

Definition at line 197 of file array.h.

                                                 {
  static_assert(
      Array<U, N>::is_span_observable,
      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
  return span<const U, N>(arr.data(), N);
}

◆ make_span() [3/6]

template<class U >

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const U > flatbuffers::make_span ( const Vector & vec )

Definition at line 315 of file vector.h.

                                               {
  static_assert(Vector<U>::is_span_observable,
                "wrong type U, only LE-scalar, or byte types are allowed");
  return span<const U>(vec.data(), vec.size());
}

◆ make_span() [4/6]

template<class U >

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span< const U > flatbuffers::make_span ( const Vector * ptr )

Definition at line 349 of file vector.h.

                                               {
  static_assert(Vector<U>::is_span_observable,
                "wrong type U, only LE-scalar, or byte types are allowed");
  return ptr ? make_span(*ptr) : span<const U>();
}

References make_span().

◆ make_span() [5/6]

template<class U >

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span flatbuffers::make_span ( Vector & vec )

Definition at line 307 of file vector.h.

                         {
  static_assert(Vector<U>::is_span_observable,
                "wrong type U, only LE-scalar, or byte types are allowed");
  return span<U>(vec.data(), vec.size());
}

◆ make_span() [6/6]

template<class U >

FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span flatbuffers::make_span ( Vector * ptr )

Definition at line 341 of file vector.h.

                         {
  static_assert(Vector<U>::is_span_observable,
                "wrong type U, only LE-scalar, or byte types are allowed");
  return ptr ? make_span(*ptr) : span<U>();
}

References make_span().

◆ NumToString()

template<typename T >

std::string flatbuffers::NumToString ( T t )

Definition at line 128 of file util.h.

                                                {
  // clang-format off
 
  #ifndef FLATBUFFERS_PREFER_PRINTF
    std::stringstream ss;
    ss << t;
    return ss.str();
  #else // FLATBUFFERS_PREFER_PRINTF
    auto v = static_cast<long long>(t);
    return NumToStringImplWrapper(v, "%.*lld");
  #endif // FLATBUFFERS_PREFER_PRINTF
  // clang-format on
}

Referenced by flatbuffers::ToStringVisitor::Double(), flatbuffers::ToStringVisitor::Float(), flatbuffers::ToStringVisitor::Long(), flatbuffers::ToStringVisitor::Named(), NumToString< char >(), NumToString< signed char >(), NumToString< unsigned char >(), flexbuffers::Reference::ToString(), flatbuffers::EnumDef::ToString(), and flatbuffers::ToStringVisitor::ULong().

◆ NumToString< char >()

template<>

std::string flatbuffers::NumToString< char > ( char t )

inline

Definition at line 148 of file util.h.

                                                      {
  return NumToString(static_cast<int>(t));
}

References NumToString().

◆ NumToString< double >()

template<>

std::string flatbuffers::NumToString< double > ( double t )

inline

Definition at line 180 of file util.h.

                                                          {
  return FloatToString(t, 12);
}

References FloatToString().

◆ NumToString< float >()

template<>

std::string flatbuffers::NumToString< float > ( float t )

inline

Definition at line 183 of file util.h.

                                                        {
  return FloatToString(t, 6);
}

References FloatToString().

◆ NumToString< signed char >()

template<>

std::string flatbuffers::NumToString< signed char > ( signed char t )

inline

Definition at line 142 of file util.h.

                                                                    {
  return NumToString(static_cast<int>(t));
}

References NumToString().

◆ NumToString< unsigned char >()

template<>

std::string flatbuffers::NumToString< unsigned char > ( unsigned char t )

inline

Definition at line 145 of file util.h.

                                                                        {
  return NumToString(static_cast<int>(t));
}

References NumToString().

◆ operator!=()

bool flatbuffers::operator!=	(	const EnumVal &	lhs,
		const EnumVal &	rhs
	)

inline

Definition at line 580 of file idl.h.

                                                               {
  return !(lhs == rhs);
}

◆ operator<() [1/2]

bool flatbuffers::operator<	(	const IncludedFile &	a,
		const IncludedFile &	b
	)

inline

Definition at line 625 of file idl.h.

                                                                    {
  return a.filename < b.filename;
}

References flatbuffers::IncludedFile::filename.

◆ operator<() [2/2]

bool flatbuffers::operator<	(	const Namespace &	a,
		const Namespace &	b
	)

inline

Definition at line 286 of file idl.h.

                                                              {
  size_t min_size = std::min(a.components.size(), b.components.size());
  for (size_t i = 0; i < min_size; ++i) {
    if (a.components[i] != b.components[i])
      return a.components[i] < b.components[i];
  }
  return a.components.size() < b.components.size();
}

References flatbuffers::Namespace::components.

◆ operator==() [1/7]

template<typename T , uint16_t length>

bool flatbuffers::operator==	(	const Array< T, length > &	lhs,
		const Array< T, length > &	rhs
	)

noexcept

Definition at line 247 of file array.h.

                                                      {
  return std::addressof(lhs) == std::addressof(rhs) ||
         (lhs.size() == rhs.size() &&
          std::memcmp(lhs.Data(), rhs.Data(), rhs.size() * sizeof(T)) == 0);
}

◆ operator==() [2/7]

bool flatbuffers::operator==	(	const EnumVal &	lhs,
		const EnumVal &	rhs
	)

inline

Definition at line 577 of file idl.h.

                                                               {
  return lhs.value == rhs.value;
}

◆ operator==() [3/7]

template<class T , class U >

FLATBUFFERS_CONSTEXPR_CPP11 bool flatbuffers::operator==	(	const Optional< T > &	lhs,
		const Optional< U > &	rhs
	)

Definition at line 272 of file stl_emulation.h.

                                                                                                                 {
  return static_cast<bool>(lhs) != static_cast<bool>(rhs)
              ? false
              : !static_cast<bool>(lhs) ? false : (*lhs == *rhs);
}

◆ operator==() [4/7]

template<class T , class U >

FLATBUFFERS_CONSTEXPR_CPP11 bool flatbuffers::operator==	(	const Optional< T > &	lhs,
		const U &	rhs
	)

Definition at line 262 of file stl_emulation.h.

                                                                                                       {
  return static_cast<bool>(lhs) && (*lhs == rhs);
}

◆ operator==() [5/7]

template<class T >

FLATBUFFERS_CONSTEXPR_CPP11 bool flatbuffers::operator==	(	const Optional< T > &	opt,
		nullopt_t
	)

Definition at line 253 of file stl_emulation.h.

                                                                                                    {
  return !opt;
}

◆ operator==() [6/7]

template<class T , class U >

FLATBUFFERS_CONSTEXPR_CPP11 bool flatbuffers::operator==	(	const T &	lhs,
		const Optional< U > &	rhs
	)

Definition at line 267 of file stl_emulation.h.

                                                                                                       {
  return static_cast<bool>(rhs) && (lhs == *rhs);
}

◆ operator==() [7/7]

template<class T >

FLATBUFFERS_CONSTEXPR_CPP11 bool flatbuffers::operator==	(	nullopt_t	,
		const Optional< T > &	opt
	)

Definition at line 257 of file stl_emulation.h.

                                                                                                    {
  return !opt;
}

◆ piv()

template<typename T , typename U >

pointer_inside_vector< T, U > flatbuffers::piv	(	T *	ptr,
		std::vector< U > &	vec
	)

Definition at line 414 of file reflection.h.

                                                           {
  return pointer_inside_vector<T, U>(ptr, vec);
}

◆ PosixPath() [1/2]

std::string flatbuffers::PosixPath ( const char * path )

◆ PosixPath() [2/2]

std::string flatbuffers::PosixPath ( const std::string & path )

◆ ReadEnvironmentVariable()

bool flatbuffers::ReadEnvironmentVariable	(	const char *	var_name,
		std::string *	_value = `nullptr`
	)

◆ ReallocateDownward()

uint8_t * flatbuffers::ReallocateDownward	(	Allocator *	allocator,
		uint8_t *	old_p,
		size_t	old_size,
		size_t	new_size,
		size_t	in_use_back,
		size_t	in_use_front
	)

inline

Definition at line 53 of file default_allocator.h.

                                                                            {
  return allocator ? allocator->reallocate_downward(old_p, old_size, new_size,
                                                    in_use_back, in_use_front)
                   : DefaultAllocator().reallocate_downward(
                         old_p, old_size, new_size, in_use_back, in_use_front);
}

References allocator(), and flatbuffers::Allocator::reallocate_downward().

◆ RelativeToRootPath()

std::string flatbuffers::RelativeToRootPath	(	const std::string &	project,
		const std::string &	filepath
	)

◆ RemoveStringQuotes()

std::string flatbuffers::RemoveStringQuotes ( const std::string & s )

◆ ResizeAnyVector()

uint8_t * flatbuffers::ResizeAnyVector	(	const reflection::Schema &	schema,
		uoffset_t	newsize,
		const VectorOfAny *	vec,
		uoffset_t	num_elems,
		uoffset_t	elem_size,
		std::vector< uint8_t > *	flatbuf,
		const reflection::Object *	root_table = `nullptr`
	)

Referenced by ResizeVector().

◆ ResizeVector()

template<typename T >

void flatbuffers::ResizeVector	(	const reflection::Schema &	schema,
		uoffset_t	newsize,
		T	val,
		const Vector< T > *	vec,
		std::vector< uint8_t > *	flatbuf,
		const reflection::Object *	root_table = `nullptr`
	)

Definition at line 454 of file reflection.h.

                                                                {
  auto delta_elem = static_cast<int>(newsize) - static_cast<int>(vec->size());
  auto newelems = ResizeAnyVector(
      schema, newsize, reinterpret_cast<const VectorOfAny *>(vec), vec->size(),
      static_cast<uoffset_t>(sizeof(T)), flatbuf, root_table);
  // Set new elements to "val".
  for (int i = 0; i < delta_elem; i++) {
    auto loc = newelems + i * sizeof(T);
    auto is_scalar = flatbuffers::is_scalar<T>::value;
    if (is_scalar) {
      WriteScalar(loc, val);
    } else {  // struct
      *reinterpret_cast<T *>(loc) = val;
    }
  }
}

References ResizeAnyVector(), and flatbuffers::Vector< T, SizeT >::size().

◆ SaveFile() [1/2]

bool flatbuffers::SaveFile	(	const char *	name,
		const char *	buf,
		size_t	len,
		bool	binary
	)

Referenced by SaveFile().

◆ SaveFile() [2/2]

bool flatbuffers::SaveFile	(	const char *	name,
		const std::string &	buf,
		bool	binary
	)

inline

Definition at line 442 of file util.h.

                                                                          {
  return SaveFile(name, buf.c_str(), buf.size(), binary);
}

References SaveFile().

◆ SetAnyFieldF() [1/2]

void flatbuffers::SetAnyFieldF	(	Struct *	st,
		const reflection::Field &	field,
		double	val
	)

inline

Definition at line 359 of file reflection.h.

                                     {
  SetAnyValueF(field.type()->base_type(), st->GetAddressOf(field.offset()),
               val);
}

References SetAnyValueF().

◆ SetAnyFieldF() [2/2]

bool flatbuffers::SetAnyFieldF	(	Table *	table,
		const reflection::Field &	field,
		double	val
	)

inline

Definition at line 334 of file reflection.h.

                                     {
  auto field_ptr = table->GetAddressOf(field.offset());
  if (!field_ptr) return val == GetFieldDefaultF<double>(field);
  SetAnyValueF(field.type()->base_type(), field_ptr, val);
  return true;
}

References flatbuffers::Table::GetAddressOf(), and SetAnyValueF().

◆ SetAnyFieldI() [1/2]

void flatbuffers::SetAnyFieldI	(	Struct *	st,
		const reflection::Field &	field,
		int64_t	val
	)

inline

Definition at line 352 of file reflection.h.

                                      {
  SetAnyValueI(field.type()->base_type(), st->GetAddressOf(field.offset()),
               val);
}

References SetAnyValueI().

◆ SetAnyFieldI() [2/2]

bool flatbuffers::SetAnyFieldI	(	Table *	table,
		const reflection::Field &	field,
		int64_t	val
	)

inline

Definition at line 325 of file reflection.h.

                                      {
  auto field_ptr = table->GetAddressOf(field.offset());
  if (!field_ptr) return val == GetFieldDefaultI<int64_t>(field);
  SetAnyValueI(field.type()->base_type(), field_ptr, val);
  return true;
}

References flatbuffers::Table::GetAddressOf(), and SetAnyValueI().

◆ SetAnyFieldS() [1/2]

void flatbuffers::SetAnyFieldS	(	Struct *	st,
		const reflection::Field &	field,
		const char *	val
	)

inline

Definition at line 366 of file reflection.h.

                                          {
  SetAnyValueS(field.type()->base_type(), st->GetAddressOf(field.offset()),
               val);
}

References SetAnyValueS().

◆ SetAnyFieldS() [2/2]

bool flatbuffers::SetAnyFieldS	(	Table *	table,
		const reflection::Field &	field,
		const char *	val
	)

inline

Definition at line 343 of file reflection.h.

                                          {
  auto field_ptr = table->GetAddressOf(field.offset());
  if (!field_ptr) return false;
  SetAnyValueS(field.type()->base_type(), field_ptr, val);
  return true;
}

References flatbuffers::Table::GetAddressOf(), and SetAnyValueS().

◆ SetAnyValueF()

void flatbuffers::SetAnyValueF	(	reflection::BaseType	type,
		uint8_t *	data,
		double	val
	)

Referenced by SetAnyFieldF(), SetAnyFieldF(), and SetAnyVectorElemF().

◆ SetAnyValueI()

void flatbuffers::SetAnyValueI	(	reflection::BaseType	type,
		uint8_t *	data,
		int64_t	val
	)

Referenced by SetAnyFieldI(), SetAnyFieldI(), and SetAnyVectorElemI().

◆ SetAnyValueS()

void flatbuffers::SetAnyValueS	(	reflection::BaseType	type,
		uint8_t *	data,
		const char *	val
	)

Referenced by SetAnyFieldS(), SetAnyFieldS(), and SetAnyVectorElemS().

◆ SetAnyVectorElemF()

void flatbuffers::SetAnyVectorElemF	(	VectorOfAny *	vec,
		reflection::BaseType	elem_type,
		size_t	i,
		double	val
	)

inline

Definition at line 379 of file reflection.h.

                                                    {
  SetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
}

References flatbuffers::VectorOfAny::Data(), GetTypeSize(), and SetAnyValueF().

◆ SetAnyVectorElemI()

void flatbuffers::SetAnyVectorElemI	(	VectorOfAny *	vec,
		reflection::BaseType	elem_type,
		size_t	i,
		int64_t	val
	)

inline

Definition at line 373 of file reflection.h.

                                                     {
  SetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
}

References flatbuffers::VectorOfAny::Data(), GetTypeSize(), and SetAnyValueI().

◆ SetAnyVectorElemS()

void flatbuffers::SetAnyVectorElemS	(	VectorOfAny *	vec,
		reflection::BaseType	elem_type,
		size_t	i,
		const char *	val
	)

inline

Definition at line 385 of file reflection.h.

                                                         {
  SetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
}

References flatbuffers::VectorOfAny::Data(), GetTypeSize(), and SetAnyValueS().

◆ SetField()

template<typename T >

bool flatbuffers::SetField	(	Table *	table,
		const reflection::Field &	field,
		T	val
	)

Definition at line 302 of file reflection.h.

                                                                 {
  reflection::BaseType type = field.type()->base_type();
  if (!IsScalar(type)) { return false; }
  FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(type));
  T def;
  if (IsInteger(type)) {
    def = GetFieldDefaultI<T>(field);
  } else {
    FLATBUFFERS_ASSERT(IsFloat(type));
    def = GetFieldDefaultF<T>(field);
  }
  return table->SetField(field.offset(), val, def);
}

References FLATBUFFERS_ASSERT, GetTypeSize(), IsFloat(), IsInteger(), IsScalar(), flatbuffers::Table::SetField(), and type.

◆ SetFieldT()

bool flatbuffers::SetFieldT	(	Table *	table,
		const reflection::Field &	field,
		const uint8_t *	val
	)

inline

Definition at line 484 of file reflection.h.

                                          {
  FLATBUFFERS_ASSERT(sizeof(uoffset_t) ==
                     GetTypeSize(field.type()->base_type()));
  return table->SetPointer(field.offset(), val);
}

References FLATBUFFERS_ASSERT, GetTypeSize(), and flatbuffers::Table::SetPointer().

◆ SetFileExistsFunction()

FileExistsFunction flatbuffers::SetFileExistsFunction ( FileExistsFunction file_exists_function )

◆ SetGlobalTestLocale()

bool flatbuffers::SetGlobalTestLocale	(	const char *	locale_name,
		std::string *	_value = `nullptr`
	)

◆ SetLoadFileFunction()

LoadFileFunction flatbuffers::SetLoadFileFunction ( LoadFileFunction load_file_function )

◆ SetString()

void flatbuffers::SetString	(	const reflection::Schema &	schema,
		const std::string &	val,
		const String *	str,
		std::vector< uint8_t > *	flatbuf,
		const reflection::Object *	root_table = `nullptr`
	)

◆ SizeOf()

size_t flatbuffers::SizeOf ( const BaseType t )

inline

Definition at line 152 of file idl.h.

                                       {
  switch (t) {
  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
    case BASE_TYPE_##ENUM: return sizeof(CTYPE);
      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
  #undef FLATBUFFERS_TD
    default: FLATBUFFERS_ASSERT(0);
  }
  return 0;
}

References FLATBUFFERS_ASSERT, FLATBUFFERS_GEN_TYPES, and FLATBUFFERS_TD.

Referenced by InlineAlignment(), and InlineSize().

◆ StringIsFlatbufferNan()

bool flatbuffers::StringIsFlatbufferNan ( const std::string & s )

inline

Definition at line 398 of file util.h.

                                                      {
  return s == "nan" || s == "+nan" || s == "-nan";
}

◆ StringIsFlatbufferNegativeInfinity()

bool flatbuffers::StringIsFlatbufferNegativeInfinity ( const std::string & s )

inline

Definition at line 406 of file util.h.

                                                                   {
  return s == "-inf" || s == "-infinity";
}

◆ StringIsFlatbufferPositiveInfinity()

bool flatbuffers::StringIsFlatbufferPositiveInfinity ( const std::string & s )

inline

Definition at line 402 of file util.h.

                                                                   {
  return s == "inf" || s == "+inf" || s == "infinity" || s == "+infinity";
}

◆ StringOf()

const char * flatbuffers::StringOf ( const BaseType t )

inline

Definition at line 174 of file idl.h.

                                              {
  switch (t) {
  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
    case BASE_TYPE_##ENUM: return #CTYPE;
      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
  #undef FLATBUFFERS_TD
    default: FLATBUFFERS_ASSERT(0);
  }
  return "";
}

References FLATBUFFERS_ASSERT, FLATBUFFERS_GEN_TYPES, and FLATBUFFERS_TD.

◆ StringToFloatImpl()

template<typename T >

bool flatbuffers::StringToFloatImpl	(	T *	val,
		const char *const	str
	)

inline

Definition at line 310 of file util.h.

                                                             {
  // Type T must be either float or double.
  FLATBUFFERS_ASSERT(str && val);
  auto end = str;
  strtoval_impl(val, str, const_cast<char **>(&end));
  auto done = (end != str) && (*end == '\0');
  if (!done) *val = 0;  // erase partial result
  if (done && std::isnan(*val)) { *val = std::numeric_limits<T>::quiet_NaN(); }
  return done;
}

References FLATBUFFERS_ASSERT, and strtoval_impl().

Referenced by StringToNumber(), and StringToNumber().

◆ StringToInt()

int64_t flatbuffers::StringToInt	(	const char *	s,
		int	base = `10`
	)

inline

Definition at line 388 of file util.h.

                                                         {
  int64_t val;
  return StringToIntegerImpl(&val, s, base) ? val : 0;
}

References StringToIntegerImpl().

Referenced by flexbuffers::Reference::AsInt64().

◆ StringToIntegerImpl()

template<typename T >

bool flatbuffers::StringToIntegerImpl	(	T *	val,
		const char *const	str,
		const int	base = `0`,
		const bool	check_errno = `true`
	)

inline

Definition at line 283 of file util.h.

                                                               {
  // T is int64_t or uint64_T
  FLATBUFFERS_ASSERT(str);
  if (base <= 0) {
    auto s = str;
    while (*s && !is_digit(*s)) s++;
    if (s[0] == '0' && is_alpha_char(s[1], 'X'))
      return StringToIntegerImpl(val, str, 16, check_errno);
    // if a prefix not match, try base=10
    return StringToIntegerImpl(val, str, 10, check_errno);
  } else {
    if (check_errno) errno = 0;  // clear thread-local errno
    auto endptr = str;
    strtoval_impl(val, str, const_cast<char **>(&endptr), base);
    if ((*endptr != '\0') || (endptr == str)) {
      *val = 0;      // erase partial result
      return false;  // invalid string
    }
    // errno is out-of-range, return MAX/MIN
    if (check_errno && errno) return false;
    return true;
  }
}

References FLATBUFFERS_ASSERT, is_alpha_char(), is_digit(), StringToIntegerImpl(), and strtoval_impl().

Referenced by StringToInt(), StringToIntegerImpl(), StringToNumber(), StringToNumber< int64_t >(), StringToNumber< uint64_t >(), and StringToUInt().

◆ StringToNumber() [1/3]

template<>

bool flatbuffers::StringToNumber	(	const char *	s,
		double *	val
	)

inline

Definition at line 384 of file util.h.

                                                                  {
  return StringToFloatImpl(val, s);
}

References StringToFloatImpl().

◆ StringToNumber() [2/3]

template<>

bool flatbuffers::StringToNumber	(	const char *	s,
		float *	val
	)

inline

Definition at line 380 of file util.h.

                                                                 {
  return StringToFloatImpl(val, s);
}

References StringToFloatImpl().

◆ StringToNumber() [3/3]

template<typename T >

bool flatbuffers::StringToNumber	(	const char *	s,
		T *	val
	)

inline

Definition at line 327 of file util.h.

                                                                       {
  // Assert on `unsigned long` and `signed long` on LP64.
  // If it is necessary, it could be solved with flatbuffers::enable_if<B,T>.
  static_assert(sizeof(T) < sizeof(int64_t), "unexpected type T");
  FLATBUFFERS_ASSERT(s && val);
  int64_t i64;
  // The errno check isn't needed, will return MAX/MIN on overflow.
  if (StringToIntegerImpl(&i64, s, 0, false)) {
    const int64_t max = (flatbuffers::numeric_limits<T>::max)();
    const int64_t min = flatbuffers::numeric_limits<T>::lowest();
    if (i64 > max) {
      *val = static_cast<T>(max);
      return false;
    }
    if (i64 < min) {
      // For unsigned types return max to distinguish from
      // "no conversion can be performed" when 0 is returned.
      *val = static_cast<T>(flatbuffers::is_unsigned<T>::value ? max : min);
      return false;
    }
    *val = static_cast<T>(i64);
    return true;
  }
  *val = 0;
  return false;
}

References FLATBUFFERS_ASSERT, and StringToIntegerImpl().

Referenced by flexbuffers::Reference::AsDouble().

◆ StringToNumber< int64_t >()

template<>

bool flatbuffers::StringToNumber< int64_t >	(	const char *	str,
		int64_t *	val
	)

inline

Definition at line 354 of file util.h.

                                                                              {
  return StringToIntegerImpl(val, str);
}

References StringToIntegerImpl().

◆ StringToNumber< uint64_t >()

template<>

bool flatbuffers::StringToNumber< uint64_t >	(	const char *	str,
		uint64_t *	val
	)

inline

Definition at line 359 of file util.h.

                                                                     {
  if (!StringToIntegerImpl(val, str)) return false;
  // The strtoull accepts negative numbers:
  // If the minus sign was part of the input sequence, the numeric value
  // calculated from the sequence of digits is negated as if by unary minus
  // in the result type, which applies unsigned integer wraparound rules.
  // Fix this behaviour (except -0).
  if (*val) {
    auto s = str;
    while (*s && !is_digit(*s)) s++;
    s = (s > str) ? (s - 1) : s;  // step back to one symbol
    if (*s == '-') {
      // For unsigned types return the max to distinguish from
      // "no conversion can be performed".
      *val = (flatbuffers::numeric_limits<uint64_t>::max)();
      return false;
    }
  }
  return true;
}

References is_digit(), and StringToIntegerImpl().

◆ StringToUInt()

uint64_t flatbuffers::StringToUInt	(	const char *	s,
		int	base = `10`
	)

inline

Definition at line 393 of file util.h.

                                                           {
  uint64_t val;
  return StringToIntegerImpl(&val, s, base) ? val : 0;
}

References StringToIntegerImpl().

Referenced by flexbuffers::Reference::AsUInt64().

◆ StripExtension()

std::string flatbuffers::StripExtension ( const std::string & filepath )

◆ StripFileName()

std::string flatbuffers::StripFileName ( const std::string & filepath )

◆ StripPath()

std::string flatbuffers::StripPath ( const std::string & filepath )

◆ StripPrefix()

std::string flatbuffers::StripPrefix	(	const std::string &	filepath,
		const std::string &	prefix_to_remove
	)

◆ strtoval_impl() [1/4]

void flatbuffers::strtoval_impl	(	double *	val,
		const char *	str,
		char **	endptr
	)

inline

Definition at line 255 of file util.h.

                                                                       {
  *val = __strtod_impl(str, endptr);
}

References __strtod_impl.

◆ strtoval_impl() [2/4]

void flatbuffers::strtoval_impl	(	float *	val,
		const char *	str,
		char **	endptr
	)

inline

Definition at line 261 of file util.h.

                                                                      {
  *val = __strtof_impl(str, endptr);
}

References __strtof_impl.

◆ strtoval_impl() [3/4]

void flatbuffers::strtoval_impl	(	int64_t *	val,
		const char *	str,
		char **	endptr,
		int	base
	)

inline

Definition at line 245 of file util.h.

                                           {
    *val = __strtoll_impl(str, endptr, base);
}

References __strtoll_impl.

Referenced by StringToFloatImpl(), and StringToIntegerImpl().

◆ strtoval_impl() [4/4]

void flatbuffers::strtoval_impl	(	uint64_t *	val,
		const char *	str,
		char **	endptr,
		int	base
	)

inline

Definition at line 250 of file util.h.

                                           {
  *val = __strtoull_impl(str, endptr, base);
}

References __strtoull_impl.

◆ ToUTF8()

int flatbuffers::ToUTF8	(	uint32_t	ucc,
		std::string *	out
	)

inline

Definition at line 494 of file util.h.

                                                {
  FLATBUFFERS_ASSERT(!(ucc & 0x80000000));  // Top bit can't be set.
  // 6 possible encodings: http://en.wikipedia.org/wiki/UTF-8
  for (int i = 0; i < 6; i++) {
    // Max bits this encoding can represent.
    uint32_t max_bits = 6 + i * 5 + static_cast<int>(!i);
    if (ucc < (1u << max_bits)) {  // does it fit?
      // Remaining bits not encoded in the first byte, store 6 bits each
      uint32_t remain_bits = i * 6;
      // Store first byte:
      (*out) += static_cast<char>((0xFE << (max_bits - remain_bits)) |
                                  (ucc >> remain_bits));
      // Store remaining bytes:
      for (int j = i - 1; j >= 0; j--) {
        (*out) += static_cast<char>(((ucc >> (j * 6)) & 0x3F) | 0x80);
      }
      return i + 1;  // Return the number of bytes added.
    }
  }
  FLATBUFFERS_ASSERT(0);  // Impossible to arrive here.
  return -1;
}

References FLATBUFFERS_ASSERT.

◆ TypeName()

const char * flatbuffers::TypeName ( const BaseType t )

inline

Definition at line 163 of file idl.h.

                                              {
  switch (t) {
  #define FLATBUFFERS_TD(ENUM, IDLTYPE, ...) \
    case BASE_TYPE_##ENUM: return IDLTYPE;
      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
  #undef FLATBUFFERS_TD
    default: FLATBUFFERS_ASSERT(0);
  }
  return nullptr;
}

References FLATBUFFERS_ASSERT, FLATBUFFERS_GEN_TYPES, and FLATBUFFERS_TD.

◆ UnionTypeFieldSuffix()

const char * flatbuffers::UnionTypeFieldSuffix ( )

inline

Definition at line 418 of file reflection.h.

418{ return "_type"; }

Referenced by GetUnionType().

◆ VectorCast() [1/2]

template<typename T , typename U >

const Vector< Offset< T > > * flatbuffers::VectorCast ( const Vector< Offset > * ptr )

Definition at line 384 of file vector.h.

                                                                  {
  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
  return reinterpret_cast<const Vector<Offset<T>> *>(ptr);
}

◆ VectorCast() [2/2]

template<typename T , typename U >

Vector< Offset< T > > * flatbuffers::VectorCast ( Vector< Offset > * ptr )

Definition at line 378 of file vector.h.

                                                      {
  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
  return reinterpret_cast<Vector<Offset<T>> *>(ptr);
}

◆ Verify()

bool flatbuffers::Verify	(	const reflection::Schema &	schema,
		const reflection::Object &	root,
		const uint8_t *	buf,
		size_t	length,
		uoffset_t	max_depth = `64`,
		uoffset_t	max_tables = `1000000`
	)

◆ VerifySizePrefixed()

bool flatbuffers::VerifySizePrefixed	(	const reflection::Schema &	schema,
		const reflection::Object &	root,
		const uint8_t *	buf,
		size_t	length,
		uoffset_t	max_depth = `64`,
		uoffset_t	max_tables = `1000000`
	)

◆ WordWrap()

std::string flatbuffers::WordWrap	(	const std::string	in,
		size_t	max_length,
		const std::string	wrapped_line_prefix,
		const std::string	wrapped_line_suffix
	)

inline

Definition at line 570 of file util.h.

                                                                 {
  std::istringstream in_stream(in);
  std::string wrapped, line, word;
 
  in_stream >> word;
  line = word;
 
  while (in_stream >> word) {
    if ((line.length() + 1 + word.length() + wrapped_line_suffix.length()) <
        max_length) {
      line += " " + word;
    } else {
      wrapped += line + wrapped_line_suffix + "\n";
      line = wrapped_line_prefix + word;
    }
  }
  wrapped += line;
 
  return wrapped;
}

Variable Documentation

◆ dynamic_extent

FLATBUFFERS_CONSTEXPR std::size_t flatbuffers::dynamic_extent = static_cast<std::size_t>(-1)

Definition at line 287 of file stl_emulation.h.

Referenced by flatbuffers::FLATBUFFERS_FINAL_CLASS< T >::span(), and flatbuffers::FLATBUFFERS_FINAL_CLASS< T >::span().

◆ kHashFunctions16

const NamedHashFunction<uint16_t> flatbuffers::kHashFunctions16[]

Initial value:

= {
  { "fnv1_16", HashFnv1<uint16_t> },
  { "fnv1a_16", HashFnv1a<uint16_t> },
}

Definition at line 77 of file hash.h.

                                                       {
  { "fnv1_16", HashFnv1<uint16_t> },
  { "fnv1a_16", HashFnv1a<uint16_t> },
};

Referenced by FindHashFunction16().

◆ kHashFunctions32

const NamedHashFunction<uint32_t> flatbuffers::kHashFunctions32[]

Initial value:

= {
  { "fnv1_32", HashFnv1<uint32_t> },
  { "fnv1a_32", HashFnv1a<uint32_t> },
}

Definition at line 82 of file hash.h.

                                                       {
  { "fnv1_32", HashFnv1<uint32_t> },
  { "fnv1a_32", HashFnv1a<uint32_t> },
};

Referenced by FindHashFunction32().

◆ kHashFunctions64

const NamedHashFunction<uint64_t> flatbuffers::kHashFunctions64[]

Initial value:

= {
  { "fnv1_64", HashFnv1<uint64_t> },
  { "fnv1a_64", HashFnv1a<uint64_t> },
}

Definition at line 87 of file hash.h.

                                                       {
  { "fnv1_64", HashFnv1<uint64_t> },
  { "fnv1a_64", HashFnv1a<uint64_t> },
};

Referenced by FindHashFunction64().

◆ kPathSeparator

FLATBUFFERS_CONSTEXPR char flatbuffers::kPathSeparator = '/'

Definition at line 452 of file util.h.

Namespaces

Data Structures

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ false_type

◆ FileExistsFunction

◆ FlatBufferBuilder

◆ FlatBufferBuilder64

◆ hash_value_t

◆ LoadFileFunction

◆ rehasher_function_t

◆ resolver_function_t

◆ true_type

◆ TypeFunction

◆ Vector64

◆ VectorConstIterator

Enumeration Type Documentation

◆ BaseType

◆ Case

◆ ElementaryType

◆ SequenceType

Function Documentation

◆ AbsolutePath()

◆ AddFlatBuffer()

◆ Allocate()

◆ BufferToHexText()

◆ CastToArray() [1/2]

◆ CastToArray() [2/2]

◆ CastToArrayOfEnum() [1/2]

◆ CastToArrayOfEnum() [2/2]

◆ CharToLower()

◆ CharToUpper()

◆ check_ascii_range()

◆ ConCatPathFileName()

◆ ConvertCase()

◆ CopyTable()

◆ data() [1/2]

◆ data() [2/2]

◆ Deallocate()

◆ DirExists()

◆ ElementaryTypeNames()

◆ EnsureDirExists()

◆ EnumName()

◆ EqualByName()

◆ EscapeString()

◆ FieldIndexToOffset()

◆ FileExists()

◆ FindHashFunction16()

◆ FindHashFunction32()

◆ FindHashFunction64()

◆ flatbuffers_version_string()

◆ FlatBufferToString()

◆ FloatToString()

◆ ForAllFields()

◆ FromUTF8()

◆ GenComment()

◆ GenerateCppGRPC()

◆ GenerateGoGRPC()

◆ GenerateJavaGRPC()

◆ GeneratePythonGRPC()

◆ GenerateSwiftGRPC()

◆ GenerateTSGRPC()

◆ GenText()

◆ GenTextFile()

◆ GenTextFromTable()

◆ GetAnyFieldAddressOf() [1/2]

◆ GetAnyFieldAddressOf() [2/2]

◆ GetAnyFieldF() [1/2]

◆ GetAnyFieldF() [2/2]

◆ GetAnyFieldI() [1/2]

◆ GetAnyFieldI() [2/2]

◆ GetAnyFieldS() [1/2]

◆ GetAnyFieldS() [2/2]

◆ GetAnyRoot() [1/2]

◆ GetAnyRoot() [2/2]

◆ GetAnySizePrefixedRoot() [1/2]

◆ GetAnySizePrefixedRoot() [2/2]