Namespaces
namespace	grpc

namespace	internal

Data Structures
class	Allocator

class	Array

class	Array< Offset< T >, length >

class	BaseGenerator

struct	bool_constant

class	CheckedError

class	CodeWriter

struct	CommentConfig

struct	conditional

class	DefaultAllocator

struct	Definition

class	DetachedBuffer

struct	EnumDef

struct	EnumVal

struct	FieldDef

class	FlatBufferBuilder
	Helper class to hold data needed in creation of a FlatBuffer. To serialize data, you typically call one of the `Create*()` functions in the generated code, which in turn call a sequence of `StartTable`/ `PushElement`/`AddElement`/`EndTable`, or the builtin `CreateString`/ `CreateVector` functions. Do this is depth-first order to build up a tree to the root. `Finish()` wraps up the buffer ready for transport. More...

class	FLATBUFFERS_FINAL_CLASS

class	FlatCompiler

class	FloatConstantGenerator

struct	FnvTraits

struct	FnvTraits< uint32_t >

struct	FnvTraits< uint64_t >

struct	IDLOptions

struct	IndirectHelper

struct	IndirectHelper< const T * >

struct	IndirectHelper< Offset< T > >

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	nullopt_t

class	numeric_limits

struct	Offset

class	Parser

struct	ParserState

class	pointer_inside_vector

class	Registry

struct	RPCCall

struct	ServiceDef

class	SimpleFloatConstantGenerator

struct	String

struct	StructDef

class	SymbolTable

struct	ToStringVisitor

struct	Type

class	TypedFloatConstantGenerator

class	unique_ptr

struct	Value

class	Vector

class	vector_downward

struct	VectorIterator

class	VectorOfAny

struct	VectorReverseIterator

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

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

Enumerations
enum	BaseType

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

template<typename T >
bool	IsTheSameAs (T e, T def)

template<typename T >
bool	IsOutRange (const T &v, const T &low, const T &high)

template<typename T >
bool	IsInRange (const T &v, const T &low, const T &high)

void	EndianCheck ()

template<typename T >
FLATBUFFERS_CONSTEXPR size_t	AlignOf ()

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)

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])

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 >
const T *	data (const std::vector< T, Alloc > &v)

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

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	IsUnsigned (BaseType t)

size_t	SizeOf (BaseType t)

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

bool	IsString (const Type &type)

bool	IsStruct (const Type &type)

bool	IsUnion (const Type &type)

bool	IsVector (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)

std::string	MakeCamel (const std::string &in, bool first=true)

std::string	MakeScreamingCamel (const std::string &in)

bool	GenerateTextFromTable (const Parser &parser, const void table, const std::string &tablename, std::string text)

bool	GenerateText (const Parser &parser, const void flatbuffer, std::string text)

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

bool	GenerateJsonSchema (const Parser &parser, std::string *json)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string	GenerateFBS (const Parser &parser, const std::string &file_name)

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

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

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

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

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

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

std::string	TextMakeRule (const Parser &parser, const std::string &path, const std::string &file_names)

std::string	BinaryMakeRule (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)

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 *flatbuf)

const Table *	GetAnyRoot (const uint8_t *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)

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)

char &	string_back (std::string &value)

char	string_back (const std::string &value)

template<typename T >
T *	vector_data (std::vector< T > &vector)

template<typename T >
const T *	vector_data (const std::vector< T > &vector)

template<typename T , typename V >
void	vector_emplace_back (std::vector< T > *vector, V &&data)

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)

	__supress_ubsan__ ("float-cast-overflow") inline void strtoval_impl(float *val

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)

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	ConCatPathFileName (const std::string &path, const std::string &filename)

std::string	PosixPath (const char *path)

void	EnsureDirExists (const std::string &filepath)

std::string	AbsolutePath (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)

void	SetupDefaultCRTReportMode ()

Variables
const NamedHashFunction< uint16_t >	kHashFunctions16 []

const NamedHashFunction< uint32_t >	kHashFunctions32 []

const NamedHashFunction< uint64_t >	kHashFunctions64 []

const char *const	kTypeNames []

const char	kTypeSizes []

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

const char *	str

const char char **	endptr

FLATBUFFERS_CONSTEXPR char	kPathSeparator = '/'

Typedef Documentation

◆ FileExistsFunction

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

Definition at line 448 of file util.h.

◆ LoadFileFunction

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

Definition at line 447 of file util.h.

Enumeration Type Documentation

◆ BaseType

enum flatbuffers::BaseType

Definition at line 119 of file idl.h.

              {
  #define FLATBUFFERS_TD(ENUM, ...) \
    BASE_TYPE_ ## ENUM,
    FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
  #undef FLATBUFFERS_TD
};

Function Documentation

◆ __supress_ubsan__()

flatbuffers::__supress_ubsan__ ( "float-cast-overflow" )

◆ 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
	)

◆ AlignOf()

template<typename T >

FLATBUFFERS_CONSTEXPR size_t flatbuffers::AlignOf ( )

Definition at line 86 of file flatbuffers.h.

{
#ifdef _MSC_VER
  return __alignof(T);
#else
#ifndef alignof
  return __alignof__(T);
#else
  return alignof(T);
#endif
#endif
  // clang-format on
}

◆ Allocate()

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

inline

Definition at line 731 of file flatbuffers.h.

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

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

◆ BinaryMakeRule()

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

extern

◆ 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 753 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 614 of file flatbuffers.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 609 of file flatbuffers.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 627 of file flatbuffers.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 620 of file flatbuffers.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 90 of file util.h.

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

◆ CharToUpper()

char flatbuffers::CharToUpper ( char c )

inline

Definition at line 85 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 43 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
	)

◆ CopyTable()

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

◆ CPPMakeRule()

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

extern

◆ DartMakeRule()

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

extern

◆ data() [1/2]

template<typename T , typename Alloc >

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

Definition at line 1145 of file flatbuffers.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 >

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

Definition at line 1152 of file flatbuffers.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 736 of file flatbuffers.h.

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

References flatbuffers::Allocator::deallocate(), flatbuffers::DefaultAllocator::deallocate(), and size.

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

◆ DirExists()

bool flatbuffers::DirExists ( const char * name )

◆ EndianCheck()

void flatbuffers::EndianCheck ( )

inline

Definition at line 78 of file flatbuffers.h.

{
  int endiantest = 1;
  // If this fails, see FLATBUFFERS_LITTLEENDIAN above.
  FLATBUFFERS_ASSERT(*reinterpret_cast<char *>(&endiantest) == FLATBUFFERS_LITTLEENDIAN);
  (void)endiantest;
}

References FLATBUFFERS_ASSERT.

Referenced by flatbuffers::FlatBufferBuilder::FlatBufferBuilder(), and flatbuffers::FlatBufferBuilder::FlatBufferBuilder().

◆ 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 128 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().

Referenced by IterateValue().

◆ EqualByName()

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

inline

Definition at line 510 of file idl.h.

{
  return a.base_type == b.base_type && a.element == b.element &&
         (a.struct_def == b.struct_def || a.struct_def->name == b.struct_def->name) &&
         (a.enum_def == b.enum_def || 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 652 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 GenerateText()
              // 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 1138 of file flatbuffers.h.

{
  // Should correspond to what EndTable() below builds up.
  const int fixed_fields = 2; // Vtable size and Object Size.
  return static_cast<voffset_t>((field_id + fixed_fields) * 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 104 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 117 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 130 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.

◆ FlatBufferToString()

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

inline

Definition at line 497 of file minireflect.h.

{
  ToStringVisitor tostring_visitor(multi_line ? "\n" : " ", false, "", 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 183 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;
}

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

◆ FromUTF8()

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

inline

Definition at line 552 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

◆ GenerateBinary()

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

extern

◆ GenerateCPP()

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

extern

◆ GenerateCppGRPC()

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

◆ GenerateCSharp()

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

extern

◆ GenerateDart()

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

extern

◆ GenerateFBS() [1/2]

std::string flatbuffers::GenerateFBS	(	const Parser &	parser,
		const std::string &	file_name
	)

extern

◆ GenerateFBS() [2/2]

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

extern

◆ GenerateGo()

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

extern

◆ GenerateGoGRPC()

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

◆ GenerateJava()

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

extern

◆ GenerateJavaGRPC()

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

◆ GenerateJsonSchema() [1/2]

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

extern

◆ GenerateJsonSchema() [2/2]

bool flatbuffers::GenerateJsonSchema	(	const Parser &	parser,
		std::string *	json
	)

extern

◆ GenerateKotlin()

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

extern

◆ GenerateLobster()

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

extern

◆ GenerateLua()

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

extern

◆ GeneratePhp()

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

extern

◆ GeneratePython()

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

extern

◆ GeneratePythonGRPC()

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

◆ GenerateRust()

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

extern

◆ GenerateSwift()

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

extern

◆ GenerateSwiftGRPC()

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

extern

◆ GenerateText()

bool flatbuffers::GenerateText	(	const Parser &	parser,
		const void *	flatbuffer,
		std::string *	text
	)

extern

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

◆ GenerateTextFile()

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

extern

◆ GenerateTextFromTable()

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

extern

◆ GenerateTS()

bool flatbuffers::GenerateTS	(	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

◆ GetAnyFieldAddressOf() [1/2]

template<typename T >

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

Definition at line 282 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 276 of file reflection.h.

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

◆ GetAnyFieldF() [1/2]

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

inline

Definition at line 225 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 200 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 GetAnyValueF().

◆ GetAnyFieldI() [1/2]

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

inline

Definition at line 219 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 193 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 GetAnyValueI().

◆ GetAnyFieldS() [1/2]

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

inline

Definition at line 231 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 209 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 GetAnyValueS().

◆ GetAnyRoot() [1/2]

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

inline

Definition at line 102 of file reflection.h.

102{ return GetRoot<Table>(flatbuf); }

◆ GetAnyRoot() [2/2]

Table * flatbuffers::GetAnyRoot ( uint8_t * flatbuf )

inline

Definition at line 101 of file reflection.h.

101{ return GetMutableRoot<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 270 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 243 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 237 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 258 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 249 of file reflection.h.

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

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

◆ GetExtension()

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

◆ GetFieldAnyV()

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

inline

Definition at line 150 of file reflection.h.

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

◆ GetFieldDefaultF()

template<typename T >

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

Definition at line 112 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 105 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 126 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, and GetTypeSize().

◆ GetFieldI()

template<typename T >

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

Definition at line 119 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, and GetTypeSize().

◆ GetFieldS()

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

inline

Definition at line 133 of file reflection.h.

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

References FLATBUFFERS_ASSERT.

◆ GetFieldStruct() [1/2]

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

inline

Definition at line 173 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 164 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.

◆ GetFieldT()

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

inline

Definition at line 156 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.

◆ GetFieldV()

template<typename T >

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

Definition at line 140 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, and GetTypeSize().

◆ GetTypeSize()

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

inline

Definition at line 53 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.
 
    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 87 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 423 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 *enumval->object();
}

References FLATBUFFERS_ASSERT, and UnionTypeFieldSuffix().

◆ HashFnv1()

template<typename T >

T flatbuffers::HashFnv1 ( const char * input )

Definition at line 47 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 69 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 58 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 75 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 492 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(), and SizeOf().

◆ InlineSize() [1/2]

size_t flatbuffers::InlineSize ( const Type & type )

inline

Definition at line 485 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(), and SizeOf().

Referenced by InlineSize(), and IterateObject().

◆ InlineSize() [2/2]

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

inline

Definition at line 77 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.

◆ IntToStringHex()

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

inline

Definition at line 218 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 83 of file util.h.

83{ 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:74

References is_alpha(), and is_digit().

◆ 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(), and is_alpha_char().

◆ is_alpha_char()

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

inline

Definition at line 62 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 59 of file util.h.

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

References check_ascii_range().

◆ is_digit()

bool flatbuffers::is_digit ( char c )

inline

Definition at line 74 of file util.h.

74{ 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 76 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 476 of file idl.h.

476{ return type.base_type == BASE_TYPE_ARRAY; }

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 480 of file idl.h.

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

References IsInteger().

◆ 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 43 of file reflection.h.

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

◆ IsInRange()

template<typename T >

bool flatbuffers::IsInRange	(	const T &	v,
		const T &	low,
		const T &	high
	)

inline

Definition at line 62 of file flatbuffers.h.

{
  return !IsOutRange(v, low, high);
}

References IsOutRange().

◆ 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(), and SetField().

◆ IsInteger() [2/2]

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

inline

Definition at line 39 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 47 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; }

◆ IsOutRange()

template<typename T >

bool flatbuffers::IsOutRange	(	const T &	v,
		const T &	low,
		const T &	high
	)

inline

Definition at line 56 of file flatbuffers.h.

{
  return (v < low) || (high < v);
}

Referenced by IsInRange().

◆ 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 35 of file reflection.h.

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

◆ IsSeries()

bool flatbuffers::IsSeries ( const Type & type )

inline

Definition at line 478 of file idl.h.

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

flatbuffers::IsVector

bool IsVector(const Type &type)

Definition idl.h:474

References IsArray(), and IsVector().

◆ IsString()

bool flatbuffers::IsString ( const Type & type )

inline

Definition at line 462 of file idl.h.

462{ return type.base_type == BASE_TYPE_STRING; }

◆ IsStruct()

bool flatbuffers::IsStruct ( const Type & type )

inline

Definition at line 464 of file idl.h.

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

Referenced by InlineAlignment(), and InlineSize().

◆ IsTheSameAs()

template<typename T >

bool flatbuffers::IsTheSameAs	(	T	e,
		T	def
	)

inline

Definition at line 37 of file flatbuffers.h.

37{ return e == def; }

◆ IsUnion()

bool flatbuffers::IsUnion ( const Type & type )

inline

Definition at line 469 of file idl.h.

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

◆ IsUnsigned()

bool flatbuffers::IsUnsigned ( BaseType t )

inline

Definition at line 144 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()

bool flatbuffers::IsVector ( const Type & type )

inline

Definition at line 474 of file idl.h.

474{ return type.base_type == BASE_TYPE_VECTOR; }

Referenced by IsSeries().

◆ IterateFlatBuffer()

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

inline

Definition at line 350 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 280 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::Vector< T >::Data(), flatbuffers::IterationVisitor::Element(), flatbuffers::IterationVisitor::EndSequence(), flatbuffers::IterationVisitor::EndVector(), flatbuffers::IterationVisitor::Field(), FieldIndexToOffset(), InlineSize(), IterateValue(), size, flatbuffers::IterationVisitor::StartSequence(), and flatbuffers::IterationVisitor::StartVector().

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 142 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 Parser &	parser,
		const std::string &	path,
		const std::string &	file_name
	)

extern

◆ 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()

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

inline

Definition at line 116 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.
}

Referenced by EnumName(), and IterateValue().

◆ MakeCamel()

std::string flatbuffers::MakeCamel	(	const std::string &	in,
		bool	first = `true`
	)

extern

◆ MakeScreamingCamel()

std::string flatbuffers::MakeScreamingCamel ( const std::string & in )

extern

◆ NumToString()

template<typename T >

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

Definition at line 139 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 162 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 212 of file util.h.

212{ return FloatToString(t, 12); }

flatbuffers::FloatToString

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

Definition util.h:183

References FloatToString().

◆ NumToString< float >()

template<>

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

inline

Definition at line 213 of file util.h.

213{ return FloatToString(t, 6); }

References FloatToString().

◆ NumToString< signed char >()

template<>

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

inline

Definition at line 154 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 158 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 508 of file idl.h.

508{ return !(lhs == rhs); }

◆ operator<()

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

inline

Definition at line 265 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/6]

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

inline

Definition at line 507 of file idl.h.

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

◆ operator==() [2/6]

template<class T , class U >

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

Definition at line 465 of file stl_emulation.h.

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

◆ operator==() [3/6]

template<class T , class U >

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

Definition at line 455 of file stl_emulation.h.

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

◆ operator==() [4/6]

template<class T >

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

Definition at line 446 of file stl_emulation.h.

                                                                                                    {
  return !opt;
}

◆ operator==() [5/6]

template<class T , class U >

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

Definition at line 460 of file stl_emulation.h.

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

◆ operator==() [6/6]

template<class T >

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

Definition at line 450 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 415 of file reflection.h.

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

◆ PosixPath()

std::string flatbuffers::PosixPath ( const char * 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 744 of file flatbuffers.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 flatbuffers::Allocator::reallocate_downward().

◆ 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 457 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 >::size().

◆ RustMakeRule()

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

extern

◆ 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 477 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 356 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 330 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 SetAnyValueF().

◆ SetAnyFieldI() [1/2]

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

inline

Definition at line 350 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 320 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 SetAnyValueI().

◆ SetAnyFieldS() [1/2]

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

inline

Definition at line 362 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 340 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 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 375 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 368 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 382 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 290 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(), and IsScalar().

◆ SetFieldT()

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

inline

Definition at line 490 of file reflection.h.

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

References FLATBUFFERS_ASSERT, and GetTypeSize().

◆ 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`
	)

◆ SetupDefaultCRTReportMode()

void flatbuffers::SetupDefaultCRTReportMode ( )

◆ SizeOf()

size_t flatbuffers::SizeOf ( BaseType t )

inline

Definition at line 155 of file idl.h.

155{ return kTypeSizes[t]; }

flatbuffers::kTypeSizes

const char kTypeSizes[]

References kTypeSizes.

Referenced by InlineAlignment(), and InlineSize().

◆ string_back() [1/2]

char flatbuffers::string_back ( const std::string & value )

inline

Definition at line 76 of file stl_emulation.h.

                                                {
  return value[value.length() - 1];
}

◆ string_back() [2/2]

char & flatbuffers::string_back ( std::string & value )

inline

Definition at line 72 of file stl_emulation.h.

                                           {
  return value[value.length() - 1];
}

◆ StringToFloatImpl()

template<typename T >

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

inline

Definition at line 345 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
  return done;
}

References FLATBUFFERS_ASSERT, str, and strtoval_impl().

Referenced by StringToNumber(), and StringToNumber().

◆ StringToInt()

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

inline

Definition at line 435 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 312 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 endptr, FLATBUFFERS_ASSERT, is_alpha_char(), is_digit(), str, 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 430 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 425 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 363 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 394 of file util.h.

{
  return StringToIntegerImpl(val, str);
}

References str, and StringToIntegerImpl().

◆ StringToNumber< uint64_t >()

template<>

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

inline

Definition at line 399 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(), str, and StringToIntegerImpl().

◆ StringToUInt()

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

inline

Definition at line 441 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 )

◆ strtoval_impl() [1/3]

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

inline

Definition at line 284 of file util.h.

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

References __strtod_impl, endptr, and str.

◆ strtoval_impl() [2/3]

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

inline

Definition at line 274 of file util.h.

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

References __strtoll_impl, endptr, and str.

Referenced by StringToFloatImpl(), and StringToIntegerImpl().

◆ strtoval_impl() [3/3]

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

inline

Definition at line 279 of file util.h.

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

References __strtoull_impl, endptr, and str.

◆ TextMakeRule()

std::string flatbuffers::TextMakeRule	(	const Parser &	parser,
		const std::string &	path,
		const std::string &	file_names
	)

extern

◆ ToUTF8()

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

inline

Definition at line 521 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.

◆ TSMakeRule()

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

extern

◆ UnionTypeFieldSuffix()

const char * flatbuffers::UnionTypeFieldSuffix ( )

inline

Definition at line 420 of file reflection.h.

420{ return "_type"; }

Referenced by GetUnionType().

◆ vector_data() [1/2]

template<typename T >

const T * flatbuffers::vector_data ( const std::vector< T > & vector )

inline

Definition at line 88 of file stl_emulation.h.

                                {
  return vector.empty() ? nullptr : &vector[0];
}

◆ vector_data() [2/2]

template<typename T >

T * flatbuffers::vector_data ( std::vector< T > & vector )

inline

Definition at line 82 of file stl_emulation.h.

                                                                  {
  // In some debug environments, operator[] does bounds checking, so &vector[0]
  // can't be used.
  return vector.empty() ? nullptr : &vector[0];
}

Referenced by flexbuffers::FLATBUFFERS_FINAL_CLASS::Blob(), flexbuffers::FLATBUFFERS_FINAL_CLASS::EndMap(), flexbuffers::GetRoot(), flatbuffers::pointer_inside_vector< T, U >::operator*(), and flexbuffers::FLATBUFFERS_FINAL_CLASS::Vector().

◆ vector_emplace_back()

template<typename T , typename V >

void flatbuffers::vector_emplace_back	(	std::vector< T > *	vector,
		V &&	data
	)

inline

Definition at line 94 of file stl_emulation.h.

                                                                {
  #if defined(FLATBUFFERS_CPP98_STL)
    vector->push_back(data);
  #else
    vector->emplace_back(std::forward<V>(data));
  #endif  // defined(FLATBUFFERS_CPP98_STL)
}

References data().

Referenced by flatbuffers::SymbolTable< T >::Add().

◆ VectorCast() [1/2]

template<typename T , typename U >

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

Definition at line 436 of file flatbuffers.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< U > > * ptr )

Definition at line 430 of file flatbuffers.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`
	)

◆ 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 624 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 480 of file stl_emulation.h.

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

◆ endptr

const char char** flatbuffers::endptr

Initial value:

{

*val = __strtof_impl(str, endptr)

__strtof_impl

#define __strtof_impl(s, pe)

Definition util.h:264

Definition at line 290 of file util.h.

Referenced by StringToIntegerImpl(), strtoval_impl(), strtoval_impl(), and strtoval_impl().

◆ kHashFunctions16

const NamedHashFunction<uint16_t> flatbuffers::kHashFunctions16[]

Initial value:

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

Definition at line 89 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 94 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 99 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 488 of file util.h.

◆ kTypeNames

const char* const flatbuffers::kTypeNames[]

extern

◆ kTypeSizes

const char flatbuffers::kTypeSizes[]

extern

Referenced by SizeOf().

◆ str

const char* flatbuffers::str

Namespaces

Data Structures

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ FileExistsFunction

◆ LoadFileFunction

Enumeration Type Documentation

◆ BaseType

Function Documentation

◆ __supress_ubsan__()

◆ AbsolutePath()

◆ AddFlatBuffer()

◆ AlignOf()

◆ Allocate()

◆ BinaryMakeRule()

◆ BufferToHexText()

◆ CastToArray() [1/2]

◆ CastToArray() [2/2]

◆ CastToArrayOfEnum() [1/2]

◆ CastToArrayOfEnum() [2/2]

◆ CharToLower()

◆ CharToUpper()

◆ check_ascii_range()

◆ ConCatPathFileName()

◆ CopyTable()

◆ CPPMakeRule()

◆ DartMakeRule()

◆ data() [1/2]

◆ data() [2/2]

◆ Deallocate()

◆ DirExists()

◆ EndianCheck()

◆ EnsureDirExists()

◆ EnumName()

◆ EqualByName()

◆ EscapeString()

◆ FieldIndexToOffset()

◆ FileExists()

◆ FindHashFunction16()

◆ FindHashFunction32()

◆ FindHashFunction64()

◆ FlatBufferToString()

◆ FloatToString()

◆ FromUTF8()

◆ GenComment()

◆ GenerateBinary()

◆ GenerateCPP()

◆ GenerateCppGRPC()

◆ GenerateCSharp()

◆ GenerateDart()

◆ GenerateFBS() [1/2]

◆ GenerateFBS() [2/2]

◆ GenerateGo()

◆ GenerateGoGRPC()

◆ GenerateJava()

◆ GenerateJavaGRPC()

◆ GenerateJsonSchema() [1/2]

◆ GenerateJsonSchema() [2/2]

◆ GenerateKotlin()

◆ GenerateLobster()

◆ GenerateLua()

◆ GeneratePhp()

◆ GeneratePython()

◆ GeneratePythonGRPC()

◆ GenerateRust()

◆ GenerateSwift()

◆ GenerateSwiftGRPC()

◆ GenerateText()

◆ GenerateTextFile()

◆ GenerateTextFromTable()

◆ GenerateTS()

◆ GenerateTSGRPC()

◆ GetAnyFieldAddressOf() [1/2]

◆ GetAnyFieldAddressOf() [2/2]

◆ GetAnyFieldF() [1/2]

◆ GetAnyFieldF() [2/2]

◆ GetAnyFieldI() [1/2]