17 #ifndef FLATBUFFERS_H_
18 #define FLATBUFFERS_H_
34 #include <type_traits>
40 #ifdef _STLPORT_VERSION
41 #define FLATBUFFERS_CPP98_STL
43 #ifndef FLATBUFFERS_CPP98_STL
48 #if __cplusplus <= 199711L && \
49 (!defined(_MSC_VER) || _MSC_VER < 1600) && \
50 (!defined(__GNUC__) || \
51 (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40400))
52 #error A C++11 compatible compiler with support for the auto typing is \
53 required for FlatBuffers.
54 #error __cplusplus _MSC_VER __GNUC__ __GNUC_MINOR__ __GNUC_PATCHLEVEL__
57 #if !defined(__clang__) && \
58 defined(__GNUC__) && \
59 (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40600)
64 const class nullptr_t {
66 template<
class T>
inline operator T*()
const {
return 0; }
68 void operator&()
const;
72 #define constexpr const
78 #if defined(__s390x__)
79 #define FLATBUFFERS_LITTLEENDIAN 0
81 #if !defined(FLATBUFFERS_LITTLEENDIAN)
82 #if defined(__GNUC__) || defined(__clang__)
84 #define FLATBUFFERS_LITTLEENDIAN 0
86 #define FLATBUFFERS_LITTLEENDIAN 1
87 #endif // __BIG_ENDIAN__
88 #elif defined(_MSC_VER)
90 #define FLATBUFFERS_LITTLEENDIAN 0
92 #define FLATBUFFERS_LITTLEENDIAN 1
95 #error Unable to determine endianness, define FLATBUFFERS_LITTLEENDIAN.
97 #endif // !defined(FLATBUFFERS_LITTLEENDIAN)
99 #define FLATBUFFERS_VERSION_MAJOR 1
100 #define FLATBUFFERS_VERSION_MINOR 6
101 #define FLATBUFFERS_VERSION_REVISION 0
102 #define FLATBUFFERS_STRING_EXPAND(X) #X
103 #define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
105 #if (!defined(_MSC_VER) || _MSC_VER > 1600) && \
106 (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 407))
107 #define FLATBUFFERS_FINAL_CLASS final
109 #define FLATBUFFERS_FINAL_CLASS
112 #if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \
113 (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 406))
114 #define FLATBUFFERS_CONSTEXPR constexpr
116 #define FLATBUFFERS_CONSTEXPR
119 #if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 || \
120 defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
121 #define FLATBUFFERS_NOEXCEPT noexcept
123 #define FLATBUFFERS_NOEXCEPT
126 #if defined(_MSC_VER)
127 #pragma warning(push)
128 #pragma warning(disable: 4127) // C4127: conditional expression is constant
134 namespace flatbuffers {
140 typedef uint32_t uoffset_t;
143 typedef int32_t soffset_t;
147 typedef uint16_t voffset_t;
149 typedef uintmax_t largest_scalar_t;
152 #define FLATBUFFERS_MAX_BUFFER_SIZE ((1ULL << (sizeof(soffset_t) * 8 - 1)) - 1)
155 #define FLATBUFFERS_MAX_ALIGNMENT 16
157 #ifndef FLATBUFFERS_CPP98_STL
159 typedef std::unique_ptr<uint8_t, std::function<void(uint8_t * )>>
165 template<
typename T>
struct Offset {
168 Offset(uoffset_t _o) : o(_o) {}
169 Offset<void> Union()
const {
return Offset<void>(o); }
170 bool IsNull()
const {
return !o; }
173 inline void EndianCheck() {
176 assert(*reinterpret_cast<char *>(&endiantest) == FLATBUFFERS_LITTLEENDIAN);
180 template<
typename T> T EndianSwap(T t) {
181 #if defined(_MSC_VER)
182 #define FLATBUFFERS_BYTESWAP16 _byteswap_ushort
183 #define FLATBUFFERS_BYTESWAP32 _byteswap_ulong
184 #define FLATBUFFERS_BYTESWAP64 _byteswap_uint64
186 #if defined(__GNUC__) && __GNUC__ * 100 + __GNUC_MINOR__ < 408
188 #define FLATBUFFERS_BYTESWAP16(x) \
189 static_cast<uint16_t>(__builtin_bswap32(static_cast<uint32_t>(x) << 16))
191 #define FLATBUFFERS_BYTESWAP16 __builtin_bswap16
193 #define FLATBUFFERS_BYTESWAP32 __builtin_bswap32
194 #define FLATBUFFERS_BYTESWAP64 __builtin_bswap64
196 if (
sizeof(T) == 1) {
198 }
else if (
sizeof(T) == 2) {
199 auto r = FLATBUFFERS_BYTESWAP16(*reinterpret_cast<uint16_t *>(&t));
200 return *
reinterpret_cast<T *
>(&r);
201 }
else if (
sizeof(T) == 4) {
202 auto r = FLATBUFFERS_BYTESWAP32(*reinterpret_cast<uint32_t *>(&t));
203 return *
reinterpret_cast<T *
>(&r);
204 }
else if (
sizeof(T) == 8) {
205 auto r = FLATBUFFERS_BYTESWAP64(*reinterpret_cast<uint64_t *>(&t));
206 return *
reinterpret_cast<T *
>(&r);
212 template<
typename T> T EndianScalar(T t) {
213 #if FLATBUFFERS_LITTLEENDIAN
216 return EndianSwap(t);
220 template<
typename T> T ReadScalar(
const void *p) {
221 return EndianScalar(*reinterpret_cast<const T *>(p));
224 template<
typename T>
void WriteScalar(
void *p, T t) {
225 *
reinterpret_cast<T *
>(p) = EndianScalar(t);
228 template<
typename T>
size_t AlignOf() {
233 return __alignof__(T);
248 template<
typename T>
struct IndirectHelper {
249 typedef T return_type;
250 typedef T mutable_return_type;
251 static const size_t element_stride =
sizeof(T);
252 static return_type Read(
const uint8_t *p, uoffset_t i) {
253 return EndianScalar((reinterpret_cast<const T *>(p))[i]);
256 template<
typename T>
struct IndirectHelper<Offset<T>> {
257 typedef const T *return_type;
258 typedef T *mutable_return_type;
259 static const size_t element_stride =
sizeof(uoffset_t);
260 static return_type Read(
const uint8_t *p, uoffset_t i) {
261 p += i *
sizeof(uoffset_t);
262 return reinterpret_cast<return_type
>(p + ReadScalar<uoffset_t>(p));
265 template<
typename T>
struct IndirectHelper<const T *> {
266 typedef const T *return_type;
267 typedef T *mutable_return_type;
268 static const size_t element_stride =
sizeof(T);
269 static return_type Read(
const uint8_t *p, uoffset_t i) {
270 return reinterpret_cast<const T *
>(p + i *
sizeof(T));
276 template<
typename T,
typename IT>
277 struct VectorIterator
278 :
public std::iterator<std::random_access_iterator_tag, IT, uoffset_t> {
280 typedef std::iterator<std::random_access_iterator_tag, IT, uoffset_t> super_type;
283 VectorIterator(
const uint8_t *data, uoffset_t i) :
284 data_(data + IndirectHelper<T>::element_stride * i) {}
285 VectorIterator(
const VectorIterator &other) : data_(other.data_) {}
286 #ifndef FLATBUFFERS_CPP98_STL
287 VectorIterator(VectorIterator &&other) : data_(std::move(other.data_)) {}
290 VectorIterator &operator=(
const VectorIterator &other) {
295 VectorIterator &operator=(VectorIterator &&other) {
300 bool operator==(
const VectorIterator &other)
const {
301 return data_ == other.data_;
304 bool operator<(
const VectorIterator &other)
const {
305 return data_ < other.data_;
308 bool operator!=(
const VectorIterator &other)
const {
309 return data_ != other.data_;
312 ptrdiff_t operator-(
const VectorIterator &other)
const {
313 return (data_ - other.data_) / IndirectHelper<T>::element_stride;
316 typename super_type::value_type operator *()
const {
317 return IndirectHelper<T>::Read(data_, 0);
320 typename super_type::value_type operator->()
const {
321 return IndirectHelper<T>::Read(data_, 0);
324 VectorIterator &operator++() {
325 data_ += IndirectHelper<T>::element_stride;
329 VectorIterator operator++(
int) {
330 VectorIterator temp(data_, 0);
331 data_ += IndirectHelper<T>::element_stride;
335 VectorIterator operator+(
const uoffset_t &offset)
const {
336 return VectorIterator(data_ + offset * IndirectHelper<T>::element_stride, 0);
339 VectorIterator& operator+=(
const uoffset_t &offset) {
340 data_ += offset * IndirectHelper<T>::element_stride;
344 VectorIterator &operator--() {
345 data_ -= IndirectHelper<T>::element_stride;
349 VectorIterator operator--(
int) {
350 VectorIterator temp(data_, 0);
351 data_ -= IndirectHelper<T>::element_stride;
355 VectorIterator operator-(
const uoffset_t &offset) {
356 return VectorIterator(data_ - offset * IndirectHelper<T>::element_stride, 0);
359 VectorIterator& operator-=(
const uoffset_t &offset) {
360 data_ -= offset * IndirectHelper<T>::element_stride;
365 const uint8_t *data_;
372 template<
typename T>
class Vector {
374 typedef VectorIterator<T, typename IndirectHelper<T>::mutable_return_type>
376 typedef VectorIterator<T, typename IndirectHelper<T>::return_type>
379 uoffset_t size()
const {
return EndianScalar(length_); }
382 uoffset_t Length()
const {
return size(); }
384 typedef typename IndirectHelper<T>::return_type return_type;
385 typedef typename IndirectHelper<T>::mutable_return_type mutable_return_type;
387 return_type Get(uoffset_t i)
const {
389 return IndirectHelper<T>::Read(Data(), i);
392 return_type operator[](uoffset_t i)
const {
return Get(i); }
397 template<
typename E> E GetEnum(uoffset_t i)
const {
398 return static_cast<E
>(Get(i));
403 template<
typename U>
const U *GetAs(uoffset_t i)
const {
404 return reinterpret_cast<const U *
>(Get(i));
409 const String *GetAsString(uoffset_t i)
const {
410 return reinterpret_cast<const String *
>(Get(i));
413 const void *GetStructFromOffset(
size_t o)
const {
414 return reinterpret_cast<const void *
>(Data() + o);
417 iterator begin() {
return iterator(Data(), 0); }
418 const_iterator begin()
const {
return const_iterator(Data(), 0); }
420 iterator end() {
return iterator(Data(), size()); }
421 const_iterator end()
const {
return const_iterator(Data(), size()); }
425 void Mutate(uoffset_t i,
const T& val) {
427 WriteScalar(data() + i, val);
433 void MutateOffset(uoffset_t i,
const uint8_t *val) {
435 assert(
sizeof(T) ==
sizeof(uoffset_t));
436 WriteScalar(data() + i,
437 static_cast<uoffset_t>(val - (Data() + i *
sizeof(uoffset_t))));
441 mutable_return_type GetMutableObject(uoffset_t i)
const {
443 return const_cast<mutable_return_type
>(IndirectHelper<T>::Read(Data(), i));
447 const uint8_t *Data()
const {
448 return reinterpret_cast<const uint8_t *
>(&length_ + 1);
452 return reinterpret_cast<uint8_t *
>(&length_ + 1);
456 const T *data()
const {
return reinterpret_cast<const T *
>(Data()); }
457 T *data() {
return reinterpret_cast<T *
>(Data()); }
459 template<
typename K> return_type LookupByKey(K key)
const {
460 void *search_result = std::bsearch(&key, Data(), size(),
461 IndirectHelper<T>::element_stride, KeyCompare<K>);
463 if (!search_result) {
467 const uint8_t *element =
reinterpret_cast<const uint8_t *
>(search_result);
469 return IndirectHelper<T>::Read(element, 0);
482 Vector(
const Vector&);
484 template<
typename K>
static int KeyCompare(
const void *ap,
const void *bp) {
485 const K *key =
reinterpret_cast<const K *
>(ap);
486 const uint8_t *data =
reinterpret_cast<const uint8_t *
>(bp);
487 auto table = IndirectHelper<T>::Read(data, 0);
491 return -table->KeyCompareWithValue(*key);
499 uoffset_t size()
const {
return EndianScalar(length_); }
501 const uint8_t *Data()
const {
502 return reinterpret_cast<const uint8_t *
>(&length_ + 1);
505 return reinterpret_cast<uint8_t *
>(&length_ + 1);
513 VectorOfAny(
const VectorOfAny&);
516 #ifndef FLATBUFFERS_CPP98_STL
517 template<
typename T,
typename U>
518 Vector<Offset<T>> *VectorCast(Vector<Offset<U>> *ptr) {
519 static_assert(std::is_base_of<T, U>::value,
"Unrelated types");
520 return reinterpret_cast<Vector<Offset<T>
> *>(ptr);
523 template<
typename T,
typename U>
524 const Vector<Offset<T>> *VectorCast(
const Vector<Offset<U>> *ptr) {
525 static_assert(std::is_base_of<T, U>::value,
"Unrelated types");
526 return reinterpret_cast<const Vector<Offset<T>
> *>(ptr);
532 template<
typename T>
static inline size_t VectorLength(
const Vector<T> *v) {
533 return v ? v->Length() : 0;
536 struct String :
public Vector<char> {
537 const char *c_str()
const {
return reinterpret_cast<const char *
>(Data()); }
538 std::string str()
const {
return std::string(c_str(), Length()); }
540 bool operator <(
const String &o)
const {
541 return strcmp(c_str(), o.c_str()) < 0;
547 class simple_allocator {
549 virtual ~simple_allocator() {}
550 virtual uint8_t *allocate(
size_t size)
const {
return new uint8_t[size]; }
551 virtual void deallocate(uint8_t *p)
const {
delete[] p; }
557 class vector_downward {
559 explicit vector_downward(
size_t initial_size,
560 const simple_allocator &allocator)
561 : reserved_((initial_size + sizeof(largest_scalar_t) - 1) &
562 ~(sizeof(largest_scalar_t) - 1)),
563 buf_(allocator.allocate(reserved_)),
564 cur_(buf_ + reserved_),
565 allocator_(allocator) {}
569 allocator_.deallocate(buf_);
574 buf_ = allocator_.allocate(reserved_);
576 cur_ = buf_ + reserved_;
579 #ifndef FLATBUFFERS_CPP98_STL
581 unique_ptr_t release() {
583 std::function<void(uint8_t *)> deleter(
584 std::bind(&simple_allocator::deallocate, allocator_, buf_));
587 unique_ptr_t retval(data(), deleter);
597 size_t growth_policy(
size_t bytes) {
598 return (bytes / 2) & ~(
sizeof(largest_scalar_t) - 1);
601 uint8_t *make_space(
size_t len) {
602 if (len > static_cast<size_t>(cur_ - buf_)) {
608 assert(size() < FLATBUFFERS_MAX_BUFFER_SIZE);
612 uoffset_t size()
const {
613 assert(cur_ !=
nullptr && buf_ !=
nullptr);
614 return static_cast<uoffset_t
>(reserved_ - (cur_ - buf_));
617 uint8_t *data()
const {
618 assert(cur_ !=
nullptr);
622 uint8_t *data_at(
size_t offset)
const {
return buf_ + reserved_ - offset; }
624 void push(
const uint8_t *bytes,
size_t num) {
625 auto dest = make_space(num);
626 memcpy(dest, bytes, num);
630 template<
typename T>
void push_small(
const T& little_endian_t) {
631 auto dest = make_space(
sizeof(T));
632 *
reinterpret_cast<T *
>(dest) = little_endian_t;
637 void fill(
size_t zero_pad_bytes) {
638 auto dest = make_space(zero_pad_bytes);
639 for (
size_t i = 0; i < zero_pad_bytes; i++) dest[i] = 0;
643 void fill_big(
size_t zero_pad_bytes) {
644 auto dest = make_space(zero_pad_bytes);
645 memset(dest, 0, zero_pad_bytes);
648 void pop(
size_t bytes_to_remove) { cur_ += bytes_to_remove; }
652 vector_downward(
const vector_downward &);
653 vector_downward &operator=(
const vector_downward &);
658 const simple_allocator &allocator_;
660 void reallocate(
size_t len) {
661 auto old_size = size();
662 auto largest_align = AlignOf<largest_scalar_t>();
663 reserved_ += (std::max)(len, growth_policy(reserved_));
665 reserved_ = (reserved_ + (largest_align - 1)) & ~(largest_align - 1);
666 auto new_buf = allocator_.allocate(reserved_);
667 auto new_cur = new_buf + reserved_ - old_size;
668 memcpy(new_cur, cur_, old_size);
670 allocator_.deallocate(buf_);
676 inline voffset_t FieldIndexToOffset(voffset_t field_id) {
678 const int fixed_fields = 2;
679 return static_cast<voffset_t
>((field_id + fixed_fields) *
sizeof(voffset_t));
685 inline size_t PaddingBytes(
size_t buf_size,
size_t scalar_size) {
686 return ((~buf_size) + 1) & (scalar_size - 1);
689 template <
typename T>
const T* data(
const std::vector<T> &v) {
690 return v.empty() ?
nullptr : &v.front();
692 template <
typename T> T* data(std::vector<T> &v) {
693 return v.empty() ?
nullptr : &v.front();
709 FLATBUFFERS_FINAL_CLASS
720 const simple_allocator *allocator =
nullptr)
721 : buf_(initial_size, allocator ? *allocator : default_allocator),
722 nested(false), finished(false), minalign_(1), force_defaults_(false),
723 dedup_vtables_(true), string_pool(nullptr) {
724 offsetbuf_.reserve(16);
725 vtables_.reserve(16);
730 if (string_pool)
delete string_pool;
742 if (string_pool) string_pool->clear();
747 uoffset_t
GetSize()
const {
return buf_.size(); }
761 #ifndef FLATBUFFERS_CPP98_STL
770 return buf_.release();
785 void Finished()
const {
805 void Pad(
size_t num_bytes) { buf_.fill(num_bytes); }
807 void Align(
size_t elem_size) {
808 if (elem_size > minalign_) minalign_ = elem_size;
809 buf_.fill(PaddingBytes(buf_.size(), elem_size));
812 void PushFlatBuffer(
const uint8_t *bytes,
size_t size) {
813 PushBytes(bytes, size);
817 void PushBytes(
const uint8_t *bytes,
size_t size) {
818 buf_.push(bytes, size);
821 void PopBytes(
size_t amount) { buf_.pop(amount); }
823 template<
typename T>
void AssertScalarT() {
824 #ifndef FLATBUFFERS_CPP98_STL
826 static_assert(std::is_scalar<T>::value,
"T must be a scalar type");
831 template<
typename T> uoffset_t PushElement(T element) {
833 T litle_endian_element = EndianScalar(element);
835 buf_.push_small(litle_endian_element);
839 template<
typename T> uoffset_t PushElement(Offset<T> off) {
841 return PushElement(ReferTo(off.o));
846 void TrackField(voffset_t field, uoffset_t off) {
847 FieldLoc fl = { off, field };
848 offsetbuf_.push_back(fl);
852 template<
typename T>
void AddElement(voffset_t field, T e, T def) {
854 if (e == def && !force_defaults_)
return;
855 auto off = PushElement(e);
856 TrackField(field, off);
859 template<
typename T>
void AddOffset(voffset_t field, Offset<T> off) {
860 if (off.IsNull())
return;
861 AddElement(field, ReferTo(off.o), static_cast<uoffset_t>(0));
864 template<
typename T>
void AddStruct(voffset_t field,
const T *structptr) {
865 if (!structptr)
return;
867 buf_.push_small(*structptr);
871 void AddStructOffset(voffset_t field, uoffset_t off) {
872 TrackField(field, off);
878 uoffset_t ReferTo(uoffset_t off) {
880 Align(
sizeof(uoffset_t));
882 assert(off && off <=
GetSize());
883 return GetSize() - off +
static_cast<uoffset_t
>(
sizeof(uoffset_t));
900 uoffset_t StartTable() {
909 uoffset_t EndTable(uoffset_t start, voffset_t numfields) {
914 auto vtableoffsetloc = PushElement<soffset_t>(0);
918 buf_.fill_big(numfields *
sizeof(voffset_t));
919 auto table_object_size = vtableoffsetloc - start;
920 assert(table_object_size < 0x10000);
921 PushElement<voffset_t>(
static_cast<voffset_t
>(table_object_size));
922 PushElement<voffset_t>(FieldIndexToOffset(numfields));
924 for (
auto field_location = offsetbuf_.begin();
925 field_location != offsetbuf_.end();
927 auto pos =
static_cast<voffset_t
>(vtableoffsetloc - field_location->off);
929 assert(!ReadScalar<voffset_t>(buf_.data() + field_location->id));
930 WriteScalar<voffset_t>(buf_.data() + field_location->id, pos);
933 auto vt1 =
reinterpret_cast<voffset_t *
>(buf_.data());
934 auto vt1_size = ReadScalar<voffset_t>(vt1);
938 if (dedup_vtables_) {
939 for (
auto it = vtables_.begin(); it != vtables_.end(); ++it) {
940 auto vt2 =
reinterpret_cast<voffset_t *
>(buf_.data_at(*it));
941 auto vt2_size = *vt2;
942 if (vt1_size != vt2_size || memcmp(vt2, vt1, vt1_size))
continue;
944 buf_.pop(
GetSize() - vtableoffsetloc);
950 vtables_.push_back(vt_use);
957 WriteScalar(buf_.data_at(vtableoffsetloc),
958 static_cast<soffset_t
>(vt_use) -
959 static_cast<soffset_t>(vtableoffsetloc));
962 return vtableoffsetloc;
967 template<
typename T>
void Required(Offset<T> table, voffset_t field) {
968 auto table_ptr = buf_.data_at(table.o);
969 auto vtable_ptr = table_ptr - ReadScalar<soffset_t>(table_ptr);
970 bool ok = ReadScalar<voffset_t>(vtable_ptr + field) != 0;
976 uoffset_t StartStruct(
size_t alignment) {
981 uoffset_t EndStruct() {
return GetSize(); }
983 void ClearOffsets() { offsetbuf_.clear(); }
987 void PreAlign(
size_t len,
size_t alignment) {
988 buf_.fill(PaddingBytes(
GetSize() + len, alignment));
990 template<
typename T>
void PreAlign(
size_t len) {
992 PreAlign(len,
sizeof(T));
1002 PreAlign<uoffset_t>(len + 1);
1004 PushBytes(reinterpret_cast<const uint8_t *>(str), len);
1005 PushElement(static_cast<uoffset_t>(len));
1006 return Offset<String>(
GetSize());
1027 return str ?
CreateString(str->c_str(), str->Length()) : 0;
1034 template<
typename T>
1047 string_pool =
new StringOffsetMap(StringOffsetCompare(buf_));
1048 auto size_before_string = buf_.size();
1052 auto it = string_pool->find(off);
1054 if (it != string_pool->end()) {
1056 buf_.pop(buf_.size() - size_before_string);
1060 string_pool->insert(off);
1092 uoffset_t EndVector(
size_t len) {
1095 return PushElement(static_cast<uoffset_t>(len));
1098 void StartVector(
size_t len,
size_t elemsize) {
1101 PreAlign<uoffset_t>(len * elemsize);
1102 PreAlign(len * elemsize, elemsize);
1110 void ForceVectorAlignment(
size_t len,
size_t elemsize,
size_t alignment) {
1111 PreAlign(len * elemsize, alignment);
1114 uint8_t *ReserveElements(
size_t len,
size_t elemsize) {
1115 return buf_.make_space(len * elemsize);
1126 template<
typename T> Offset<Vector<T>>
CreateVector(
const T *v,
size_t len) {
1127 StartVector(len,
sizeof(T));
1128 if (
sizeof(T) == 1) {
1129 PushBytes(reinterpret_cast<const uint8_t *>(v), len);
1131 for (
auto i = len; i > 0; ) {
1132 PushElement(v[--i]);
1135 return Offset<Vector<T>>(EndVector(len));
1144 template<
typename T> Offset<Vector<T>>
CreateVector(
const std::vector<T> &v) {
1151 Offset<Vector<uint8_t>>
CreateVector(
const std::vector<bool> &v) {
1152 StartVector(v.size(),
sizeof(uint8_t));
1153 for (
auto i = v.size(); i > 0; ) {
1154 PushElement(static_cast<uint8_t>(v[--i]));
1156 return Offset<Vector<uint8_t>>(EndVector(v.size()));
1159 #ifndef FLATBUFFERS_CPP98_STL
1168 const std::function<T (
size_t i)> &f) {
1169 std::vector<T> elems(vector_size);
1170 for (
size_t i = 0; i < vector_size; i++) elems[i] = f(i);
1182 const std::vector<std::string> &v) {
1183 std::vector<Offset<String>> offsets(v.size());
1184 for (
size_t i = 0; i < v.size(); i++) offsets[i] =
CreateString(v[i]);
1196 const T *v,
size_t len) {
1197 StartVector(len *
sizeof(T) / AlignOf<T>(), AlignOf<T>());
1198 PushBytes(reinterpret_cast<const uint8_t *>(v),
sizeof(T) * len);
1199 return Offset<Vector<const T *>>(EndVector(len));
1211 const S *v,
size_t len) {
1212 extern T Pack(
const S&);
1213 typedef T (*Pack_t)(
const S&);
1214 std::vector<T> vv(len);
1215 std::transform(v, v+len, vv.begin(), *(Pack_t)&Pack);
1216 return CreateVectorOfStructs<T>(vv.data(), vv.size());
1220 #ifndef FLATBUFFERS_CPP98_STL
1230 size_t vector_size,
const std::function<
void(
size_t i, T *)> &filler) {
1231 StartVector(vector_size *
sizeof(T) / AlignOf<T>(), AlignOf<T>());
1232 T *structs =
reinterpret_cast<T *
>(buf_.make_space(vector_size *
sizeof(T)));
1233 for (
size_t i = 0; i < vector_size; i++) {
1237 return Offset<Vector<const T *>>(EndVector(vector_size));
1248 const std::vector<T> &v) {
1260 const std::vector<S> &v) {
1261 return CreateVectorOfNativeStructs<T, S>(data(v), v.size());
1266 template<
typename T>
1267 struct StructKeyComparator {
1268 bool operator()(
const T &a,
const T &b)
const {
1269 return a.KeyCompareLessThan(&b);
1273 StructKeyComparator& operator= (
const StructKeyComparator&);
1285 std::vector<T> *v) {
1298 std::vector<S> *v) {
1299 return CreateVectorOfSortedNativeStructs<T, S>(data(*v), v->size());
1312 std::sort(v, v + len, StructKeyComparator<T>());
1327 extern T Pack(
const S&);
1328 typedef T (*Pack_t)(
const S&);
1329 std::vector<T> vv(len);
1330 std::transform(v, v+len, vv.begin(), *(Pack_t)&Pack);
1331 return CreateVectorOfSortedStructs<T>(vv, len);
1335 template<
typename T>
1336 struct TableKeyComparator {
1337 TableKeyComparator(vector_downward& buf) : buf_(buf) {}
1338 bool operator()(
const Offset<T> &a,
const Offset<T> &b)
const {
1339 auto table_a =
reinterpret_cast<T *
>(buf_.data_at(a.o));
1340 auto table_b =
reinterpret_cast<T *
>(buf_.data_at(b.o));
1341 return table_a->KeyCompareLessThan(table_b);
1343 vector_downward& buf_;
1346 TableKeyComparator& operator= (
const TableKeyComparator&);
1359 Offset<T> *v,
size_t len) {
1360 std::sort(v, v + len, TableKeyComparator<T>(buf_));
1372 std::vector<Offset<T>> *v) {
1386 StartVector(len, elemsize);
1387 buf_.make_space(len * elemsize);
1389 auto vec_end = EndVector(len);
1390 *buf = buf_.data_at(vec_start);
1403 size_t len, T **buf) {
1405 reinterpret_cast<uint8_t **>(buf));
1410 Align(AlignOf<T>());
1411 buf_.push_small(structobj);
1412 return Offset<const T *>(
GetSize());
1421 template<
typename T>
void Finish(Offset<T> root,
1422 const char *file_identifier =
nullptr) {
1424 Finish(root.o, file_identifier,
false);
1435 const char *file_identifier =
nullptr) {
1436 Finish(root.o, file_identifier,
true);
1444 void Finish(uoffset_t root,
const char *file_identifier,
bool size_prefix) {
1447 PreAlign((size_prefix ?
sizeof(uoffset_t) : 0) +
1451 if (file_identifier) {
1453 PushBytes(reinterpret_cast<const uint8_t *>(file_identifier),
1456 PushElement(ReferTo(root));
1468 simple_allocator default_allocator;
1470 vector_downward buf_;
1473 std::vector<FieldLoc> offsetbuf_;
1481 std::vector<uoffset_t> vtables_;
1485 bool force_defaults_;
1487 bool dedup_vtables_;
1489 struct StringOffsetCompare {
1490 StringOffsetCompare(
const vector_downward &buf) : buf_(&buf) {}
1491 bool operator() (
const Offset<String> &a,
const Offset<String> &b)
const {
1492 auto stra =
reinterpret_cast<const String *
>(buf_->data_at(a.o));
1493 auto strb =
reinterpret_cast<const String *
>(buf_->data_at(b.o));
1494 return strncmp(stra->c_str(), strb->c_str(),
1495 std::min(stra->size(), strb->size()) + 1) < 0;
1497 const vector_downward *buf_;
1501 typedef std::set<Offset<String>, StringOffsetCompare> StringOffsetMap;
1502 StringOffsetMap *string_pool;
1508 template<
typename T> T *GetMutableRoot(
void *buf) {
1510 return reinterpret_cast<T *
>(
reinterpret_cast<uint8_t *
>(buf) +
1511 EndianScalar(*reinterpret_cast<uoffset_t *>(buf)));
1514 template<
typename T>
const T *GetRoot(
const void *buf) {
1515 return GetMutableRoot<T>(
const_cast<void *
>(buf));
1518 template<
typename T>
const T *GetSizePrefixedRoot(
const void *buf) {
1519 return GetRoot<T>(
reinterpret_cast<const uint8_t *
>(buf) +
sizeof(uoffset_t));
1525 template<
typename T> T *GetMutableTemporaryPointer(FlatBufferBuilder &fbb,
1527 return reinterpret_cast<T *
>(fbb.GetCurrentBufferPointer() +
1528 fbb.GetSize() - offset.o);
1531 template<
typename T>
const T *GetTemporaryPointer(FlatBufferBuilder &fbb,
1533 return GetMutableTemporaryPointer<T>(fbb, offset);
1537 inline bool BufferHasIdentifier(
const void *buf,
const char *identifier) {
1538 return strncmp(reinterpret_cast<const char *>(buf) +
sizeof(uoffset_t),
1543 class Verifier FLATBUFFERS_FINAL_CLASS {
1545 Verifier(
const uint8_t *buf,
size_t buf_len, uoffset_t _max_depth = 64,
1546 uoffset_t _max_tables = 1000000)
1547 : buf_(buf), end_(buf + buf_len), depth_(0), max_depth_(_max_depth),
1548 num_tables_(0), max_tables_(_max_tables)
1549 #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
1555 bool Check(
bool ok)
const {
1556 #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
1559 #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
1561 upper_bound_ = buf_;
1567 bool Verify(
const void *elem,
size_t elem_len)
const {
1568 #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
1569 auto upper_bound =
reinterpret_cast<const uint8_t *
>(elem) + elem_len;
1570 if (upper_bound_ < upper_bound)
1571 upper_bound_ = upper_bound;
1573 return Check(elem_len <= (
size_t) (end_ - buf_) &&
1575 elem <= end_ - elem_len);
1579 template<
typename T>
bool Verify(
const void *elem)
const {
1580 return Verify(elem,
sizeof(T));
1584 template<
typename T>
bool VerifyTable(
const T *table) {
1585 return !table || table->Verify(*
this);
1589 template<
typename T>
bool Verify(
const Vector<T> *vec)
const {
1592 VerifyVector(reinterpret_cast<const uint8_t *>(vec),
sizeof(T),
1597 template<
typename T>
bool Verify(
const Vector<const T *> *vec)
const {
1598 return Verify(
reinterpret_cast<const Vector<T> *
>(vec));
1602 bool Verify(
const String *str)
const {
1605 (VerifyVector(reinterpret_cast<const uint8_t *>(str), 1, &end) &&
1607 Check(*end ==
'\0'));
1611 bool VerifyVector(
const uint8_t *vec,
size_t elem_size,
1612 const uint8_t **end)
const {
1614 if (!Verify<uoffset_t>(vec))
return false;
1617 auto size = ReadScalar<uoffset_t>(vec);
1618 auto max_elems = FLATBUFFERS_MAX_BUFFER_SIZE / elem_size;
1619 if (!Check(size < max_elems))
1621 auto byte_size =
sizeof(size) + elem_size * size;
1622 *end = vec + byte_size;
1623 return Verify(vec, byte_size);
1627 bool VerifyVectorOfStrings(
const Vector<Offset<String>> *vec)
const {
1629 for (uoffset_t i = 0; i < vec->size(); i++) {
1630 if (!Verify(vec->Get(i)))
return false;
1637 template<
typename T>
bool VerifyVectorOfTables(
const Vector<Offset<T>> *vec) {
1639 for (uoffset_t i = 0; i < vec->size(); i++) {
1640 if (!vec->Get(i)->Verify(*
this))
return false;
1646 template<
typename T>
bool VerifyBufferFromStart(
const char *identifier,
1647 const uint8_t *start) {
1649 (
size_t(end_ - start) < 2 *
sizeof(flatbuffers::uoffset_t) ||
1650 !BufferHasIdentifier(start, identifier))) {
1655 auto o = VerifyOffset(start);
1657 reinterpret_cast<const T *
>(start + o)->
1659 #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
1660 && GetComputedSize()
1666 template<
typename T>
bool VerifyBuffer() {
1667 return VerifyBuffer<T>(
nullptr);
1670 template<
typename T>
bool VerifyBuffer(
const char *identifier) {
1671 return VerifyBufferFromStart<T>(identifier, buf_);
1674 template<
typename T>
bool VerifySizePrefixedBuffer(
const char *identifier) {
1675 return Verify<uoffset_t>(buf_) &&
1676 ReadScalar<uoffset_t>(buf_) == end_ - buf_ -
sizeof(uoffset_t) &&
1677 VerifyBufferFromStart<T>(identifier, buf_ +
sizeof(uoffset_t));
1680 uoffset_t VerifyOffset(
const uint8_t *start)
const {
1681 if (!Verify<uoffset_t>(start))
return false;
1682 auto o = ReadScalar<uoffset_t>(start);
1691 bool VerifyComplexity() {
1694 return Check(depth_ <= max_depth_ && num_tables_ <= max_tables_);
1703 #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
1705 size_t GetComputedSize()
const {
1706 uintptr_t size = upper_bound_ - buf_;
1708 size = (size - 1 +
sizeof(uoffset_t)) & ~(
sizeof(uoffset_t) - 1);
1709 return (buf_ + size > end_) ? 0 : size;
1714 const uint8_t *buf_;
1715 const uint8_t *end_;
1717 uoffset_t max_depth_;
1718 uoffset_t num_tables_;
1719 uoffset_t max_tables_;
1720 #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
1721 mutable const uint8_t *upper_bound_;
1728 struct BufferRefBase {};
1729 template<
typename T>
struct BufferRef : BufferRefBase {
1730 BufferRef() : buf(nullptr), len(0), must_free(false) {}
1731 BufferRef(uint8_t *_buf, uoffset_t _len)
1732 : buf(_buf), len(_len), must_free(false) {}
1734 ~BufferRef() {
if (must_free) free(buf); }
1736 const T *GetRoot()
const {
return flatbuffers::GetRoot<T>(buf); }
1739 Verifier verifier(buf, len);
1740 return verifier.VerifyBuffer<T>(
nullptr);
1752 class Struct FLATBUFFERS_FINAL_CLASS {
1754 template<
typename T> T GetField(uoffset_t o)
const {
1755 return ReadScalar<T>(&data_[o]);
1758 template<
typename T> T GetStruct(uoffset_t o)
const {
1759 return reinterpret_cast<T
>(&data_[o]);
1762 const uint8_t *GetAddressOf(uoffset_t o)
const {
return &data_[o]; }
1763 uint8_t *GetAddressOf(uoffset_t o) {
return &data_[o]; }
1773 const uint8_t *GetVTable()
const {
1774 return data_ - ReadScalar<soffset_t>(data_);
1779 voffset_t GetOptionalFieldOffset(voffset_t field)
const {
1781 auto vtable = GetVTable();
1783 auto vtsize = ReadScalar<voffset_t>(vtable);
1786 return field < vtsize ? ReadScalar<voffset_t>(vtable + field) : 0;
1789 template<
typename T> T GetField(voffset_t field, T defaultval)
const {
1790 auto field_offset = GetOptionalFieldOffset(field);
1791 return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
1794 template<
typename P> P GetPointer(voffset_t field) {
1795 auto field_offset = GetOptionalFieldOffset(field);
1796 auto p = data_ + field_offset;
1798 ?
reinterpret_cast<P
>(p + ReadScalar<uoffset_t>(p))
1801 template<
typename P> P GetPointer(voffset_t field)
const {
1802 return const_cast<Table *
>(
this)->GetPointer<P>(field);
1805 template<
typename P> P GetStruct(voffset_t field)
const {
1806 auto field_offset = GetOptionalFieldOffset(field);
1807 auto p =
const_cast<uint8_t *
>(data_ + field_offset);
1808 return field_offset ?
reinterpret_cast<P
>(p) :
nullptr;
1811 template<
typename T>
bool SetField(voffset_t field, T val, T def) {
1812 auto field_offset = GetOptionalFieldOffset(field);
1813 if (!field_offset)
return val == def;
1814 WriteScalar(data_ + field_offset, val);
1818 bool SetPointer(voffset_t field,
const uint8_t *val) {
1819 auto field_offset = GetOptionalFieldOffset(field);
1820 if (!field_offset)
return false;
1821 WriteScalar(data_ + field_offset,
1822 static_cast<uoffset_t>(val - (data_ + field_offset)));
1826 uint8_t *GetAddressOf(voffset_t field) {
1827 auto field_offset = GetOptionalFieldOffset(field);
1828 return field_offset ? data_ + field_offset :
nullptr;
1830 const uint8_t *GetAddressOf(voffset_t field)
const {
1831 return const_cast<Table *
>(
this)->GetAddressOf(field);
1834 bool CheckField(voffset_t field)
const {
1835 return GetOptionalFieldOffset(field) != 0;
1840 bool VerifyTableStart(Verifier &verifier)
const {
1842 if (!verifier.Verify<soffset_t>(data_))
return false;
1843 auto vtable = GetVTable();
1845 return verifier.VerifyComplexity() &&
1846 verifier.Verify<voffset_t>(vtable) &&
1847 (ReadScalar<voffset_t>(vtable) & (
sizeof(voffset_t) - 1)) == 0 &&
1848 verifier.Verify(vtable, ReadScalar<voffset_t>(vtable));
1852 template<
typename T>
bool VerifyField(
const Verifier &verifier,
1853 voffset_t field)
const {
1856 auto field_offset = GetOptionalFieldOffset(field);
1858 return !field_offset || verifier.Verify<T>(data_ + field_offset);
1862 template<
typename T>
bool VerifyFieldRequired(
const Verifier &verifier,
1863 voffset_t field)
const {
1864 auto field_offset = GetOptionalFieldOffset(field);
1865 return verifier.Check(field_offset != 0) &&
1866 verifier.Verify<T>(data_ + field_offset);
1870 bool VerifyOffset(
const Verifier &verifier, voffset_t field)
const {
1871 auto field_offset = GetOptionalFieldOffset(field);
1872 return !field_offset || verifier.VerifyOffset(data_ + field_offset);
1875 bool VerifyOffsetRequired(
const Verifier &verifier, voffset_t field)
const {
1876 auto field_offset = GetOptionalFieldOffset(field);
1877 return verifier.Check(field_offset != 0) &&
1878 verifier.VerifyOffset(data_ + field_offset);
1885 Table(
const Table &other);
1894 inline const uint8_t *GetBufferStartFromRootPointer(
const void *root) {
1895 auto table =
reinterpret_cast<const Table *
>(root);
1896 auto vtable = table->GetVTable();
1898 auto start = std::min(vtable, reinterpret_cast<const uint8_t *>(root));
1900 start =
reinterpret_cast<const uint8_t *
>(
1901 reinterpret_cast<uintptr_t
>(start) & ~(
sizeof(uoffset_t) - 1));
1912 "file_identifier is assumed to be the same size as uoffset_t");
1913 for (
auto possible_roots = FLATBUFFERS_MAX_ALIGNMENT /
sizeof(uoffset_t) + 1;
1916 start -=
sizeof(uoffset_t);
1917 if (ReadScalar<uoffset_t>(start) + start ==
1918 reinterpret_cast<const uint8_t *
>(root))
return start;
1931 struct NativeTable {
1942 typedef uint64_t hash_value_t;
1943 #ifdef FLATBUFFERS_CPP98_STL
1944 typedef void (*resolver_function_t)(
void **pointer_adr, hash_value_t hash);
1945 typedef hash_value_t (*rehasher_function_t)(
void *pointer);
1947 typedef std::function<void (void **pointer_adr, hash_value_t hash)>
1948 resolver_function_t;
1949 typedef std::function<hash_value_t (void *pointer)> rehasher_function_t;
1959 template<
typename T>
bool IsFieldPresent(
const T *table, voffset_t field) {
1961 return reinterpret_cast<const Table *
>(table)->CheckField(field);
1967 inline int LookupEnum(
const char **names,
const char *name) {
1968 for (
const char **p = names; *p; p++)
1969 if (!strcmp(*p, name))
1970 return static_cast<int>(p - names);
1984 #if defined(_MSC_VER)
1985 #define MANUALLY_ALIGNED_STRUCT(alignment) \
1986 __pragma(pack(1)); \
1987 struct __declspec(align(alignment))
1988 #define STRUCT_END(name, size) \
1990 static_assert(sizeof(name) == size, "compiler breaks packing rules")
1991 #elif defined(__GNUC__) || defined(__clang__)
1992 #define MANUALLY_ALIGNED_STRUCT(alignment) \
1993 _Pragma("pack(1)") \
1994 struct __attribute__((aligned(alignment)))
1995 #define STRUCT_END(name, size) \
1997 static_assert(sizeof(name) == size, "compiler breaks packing rules")
1999 #error Unknown compiler, please define structure alignment macros
2012 #if !defined(_WIN32) && !defined(__CYGWIN__)
2014 extern volatile __attribute__((weak)) const
char *flatbuffer_version_string;
2015 volatile __attribute__((weak)) const
char *flatbuffer_version_string =
2017 FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MAJOR) "."
2018 FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MINOR) "."
2019 FLATBUFFERS_STRING(FLATBUFFERS_VERSION_REVISION);
2021 #endif // !defined(_WIN32) && !defined(__CYGWIN__)
2023 #define DEFINE_BITMASK_OPERATORS(E, T)\
2024 inline E operator | (E lhs, E rhs){\
2025 return E(T(lhs) | T(rhs));\
2027 inline E operator & (E lhs, E rhs){\
2028 return E(T(lhs) & T(rhs));\
2030 inline E operator ^ (E lhs, E rhs){\
2031 return E(T(lhs) ^ T(rhs));\
2033 inline E operator ~ (E lhs){\
2036 inline E operator |= (E &lhs, E rhs){\
2040 inline E operator &= (E &lhs, E rhs){\
2044 inline E operator ^= (E &lhs, E rhs){\
2048 inline bool operator !(E rhs) \
2050 return !bool(T(rhs)); \
2055 #if defined(_MSC_VER)
2056 #pragma warning(pop)
2059 #endif // FLATBUFFERS_H_
Offset< Vector< T > > CreateVector(size_t vector_size, const std::function< T(size_t i)> &f)
Serialize values returned by a function into a FlatBuffer vector.
Definition: flatbuffers.h:1167
uoffset_t CreateUninitializedVector(size_t len, size_t elemsize, uint8_t **buf)
Specialized version of CreateVector for non-copying use cases.
Definition: flatbuffers.h:1383
Offset< Vector< const T * > > CreateVectorOfStructs(size_t vector_size, const std::function< void(size_t i, T *)> &filler)
Serialize an array of structs into a FlatBuffer vector.
Definition: flatbuffers.h:1229
Offset< Vector< const T * > > CreateVectorOfSortedStructs(T *v, size_t len)
Serialize an array of structs into a FlatBuffer vector in sorted order.
Definition: flatbuffers.h:1310
Offset< Vector< const T * > > CreateVectorOfSortedNativeStructs(std::vector< S > *v)
Serialize a std::vector of native structs into a FlatBuffer vector in sorted order.
Definition: flatbuffers.h:1297
Offset< Vector< Offset< T > > > CreateVectorOfSortedTables(std::vector< Offset< T >> *v)
Serialize an array of table offsets as a vector in the buffer in sorted order.
Definition: flatbuffers.h:1371
Helper class to hold data needed in creation of a FlatBuffer.
Definition: flatbuffers.h:707
uoffset_t GetSize() const
The current size of the serialized buffer, counting from the end.
Definition: flatbuffers.h:747
FlatBufferBuilder(uoffset_t initial_size=1024, const simple_allocator *allocator=nullptr)
Default constructor for FlatBufferBuilder.
Definition: flatbuffers.h:719
void Clear()
Reset all the state in this FlatBufferBuilder so it can be reused to construct another buffer...
Definition: flatbuffers.h:735
Offset< Vector< const T * > > CreateVectorOfNativeStructs(const S *v, size_t len)
Serialize an array of native structs into a FlatBuffer vector.
Definition: flatbuffers.h:1210
Offset< const T * > CreateStruct(const T &structobj)
Write a struct by itself, typically to be part of a union.
Definition: flatbuffers.h:1409
unique_ptr_t ReleaseBufferPointer()
Get the released pointer to the serialized buffer.
Definition: flatbuffers.h:768
void FinishSizePrefixed(Offset< T > root, const char *file_identifier=nullptr)
Finish a buffer with a 32 bit size field pre-fixed (size of the buffer following the size field)...
Definition: flatbuffers.h:1434
Offset< String > CreateSharedString(const char *str)
Store a string in the buffer, which null-terminated.
Definition: flatbuffers.h:1069
Offset< String > CreateString(const char *str, size_t len)
Store a string in the buffer, which can contain any binary data.
Definition: flatbuffers.h:1000
void ForceDefaults(bool fd)
In order to save space, fields that are set to their default value don't get serialized into the buff...
Definition: flatbuffers.h:798
void DedupVtables(bool dedup)
By default vtables are deduped in order to save space.
Definition: flatbuffers.h:802
static const size_t kFileIdentifierLength
The length of a FlatBuffer file header.
Definition: flatbuffers.h:1416
Offset< String > CreateString(const String *str)
Store a string in the buffer, which can contain any binary data.
Definition: flatbuffers.h:1026
Offset< Vector< const T * > > CreateVectorOfSortedNativeStructs(S *v, size_t len)
Serialize an array of native structs into a FlatBuffer vector in sorted order.
Definition: flatbuffers.h:1325
Offset< String > CreateSharedString(const String *str)
Store a string in the buffer, which can contain any binary data.
Definition: flatbuffers.h:1087
Offset< String > CreateString(const T &str)
Store a string in the buffer, which can contain any binary data.
Definition: flatbuffers.h:1035
Offset< Vector< const T * > > CreateVectorOfSortedStructs(std::vector< T > *v)
Serialize a std::vector of structs into a FlatBuffer vector in sorted order.
Definition: flatbuffers.h:1284
Offset< Vector< Offset< String > > > CreateVectorOfStrings(const std::vector< std::string > &v)
Serialize a std::vector into a FlatBuffer vector.
Definition: flatbuffers.h:1181
size_t GetBufferMinAlignment()
get the minimum alignment this buffer needs to be accessed properly.
Definition: flatbuffers.h:779
Offset< Vector< const T * > > CreateVectorOfStructs(const T *v, size_t len)
Serialize an array of structs into a FlatBuffer vector.
Definition: flatbuffers.h:1195
Offset< Vector< const T * > > CreateVectorOfNativeStructs(const std::vector< S > &v)
Serialize a std::vector of native structs into a FlatBuffer vector.
Definition: flatbuffers.h:1259
Offset< String > CreateString(const char *str)
Store a string in the buffer, which is null-terminated.
Definition: flatbuffers.h:1012
Offset< String > CreateString(const std::string &str)
Store a string in the buffer, which can contain any binary data.
Definition: flatbuffers.h:1019
Offset< Vector< T > > CreateVector(const std::vector< T > &v)
Serialize a std::vector into a FlatBuffer vector.
Definition: flatbuffers.h:1144
Offset< Vector< T > > CreateUninitializedVector(size_t len, T **buf)
Specialized version of CreateVector for non-copying use cases.
Definition: flatbuffers.h:1402
uint8_t * GetCurrentBufferPointer() const
Get a pointer to an unfinished buffer.
Definition: flatbuffers.h:759
Offset< Vector< T > > CreateVector(const T *v, size_t len)
Serialize an array into a FlatBuffer vector.
Definition: flatbuffers.h:1126
Offset< String > CreateSharedString(const std::string &str)
Store a string in the buffer, which can contain any binary data.
Definition: flatbuffers.h:1078
Offset< Vector< Offset< T > > > CreateVectorOfSortedTables(Offset< T > *v, size_t len)
Serialize an array of table offsets as a vector in the buffer in sorted order.
Definition: flatbuffers.h:1358
Offset< String > CreateSharedString(const char *str, size_t len)
Store a string in the buffer, which can contain any binary data.
Definition: flatbuffers.h:1045
Offset< Vector< const T * > > CreateVectorOfStructs(const std::vector< T > &v)
Serialize a std::vector of structs into a FlatBuffer vector.
Definition: flatbuffers.h:1247
void Finish(Offset< T > root, const char *file_identifier=nullptr)
Finish serializing a buffer by writing the root offset.
Definition: flatbuffers.h:1421
uint8_t * GetBufferPointer() const
Get the serialized buffer (after you call Finish()).
Definition: flatbuffers.h:752