123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458 |
- #ifndef FLATBUFFERS_REFLECTION_H_
- #define FLATBUFFERS_REFLECTION_H_
- #include "flatbuffers/reflection_generated.h"
- namespace flatbuffers {
- inline size_t GetTypeSize(reflection::BaseType base_type) {
-
- static size_t sizes[] = { 0, 1, 1, 1, 1, 2, 2, 4, 4, 8, 8, 4, 8, 4, 4, 4, 4 };
- return sizes[base_type];
- }
- inline size_t GetTypeSizeInline(reflection::BaseType base_type,
- int type_index,
- const reflection::Schema &schema) {
- if (base_type == reflection::Obj &&
- schema.objects()->Get(type_index)->is_struct()) {
- return schema.objects()->Get(type_index)->bytesize();
- } else {
- return GetTypeSize(base_type);
- }
- }
- inline Table *GetAnyRoot(uint8_t *flatbuf) {
- return GetMutableRoot<Table>(flatbuf);
- }
- inline const Table *GetAnyRoot(const uint8_t *flatbuf) {
- return GetRoot<Table>(flatbuf);
- }
- template<typename T> T GetFieldI(const Table &table,
- const reflection::Field &field) {
- assert(sizeof(T) == GetTypeSize(field.type()->base_type()));
- return table.GetField<T>(field.offset(),
- static_cast<T>(field.default_integer()));
- }
- template<typename T> T GetFieldF(const Table &table,
- const reflection::Field &field) {
- assert(sizeof(T) == GetTypeSize(field.type()->base_type()));
- return table.GetField<T>(field.offset(),
- static_cast<T>(field.default_real()));
- }
- inline const String *GetFieldS(const Table &table,
- const reflection::Field &field) {
- assert(field.type()->base_type() == reflection::String);
- return table.GetPointer<const String *>(field.offset());
- }
- template<typename T> Vector<T> *GetFieldV(const Table &table,
- const reflection::Field &field) {
- assert(field.type()->base_type() == reflection::Vector &&
- sizeof(T) == GetTypeSize(field.type()->element()));
- return table.GetPointer<Vector<T> *>(field.offset());
- }
- inline VectorOfAny *GetFieldAnyV(const Table &table,
- const reflection::Field &field) {
- return table.GetPointer<VectorOfAny *>(field.offset());
- }
- inline Table *GetFieldT(const Table &table,
- const reflection::Field &field) {
- assert(field.type()->base_type() == reflection::Obj ||
- field.type()->base_type() == reflection::Union);
- return table.GetPointer<Table *>(field.offset());
- }
- inline const Struct *GetFieldStruct(const Table &table,
- const reflection::Field &field) {
-
-
- assert(field.type()->base_type() == reflection::Obj);
- return table.GetStruct<const Struct *>(field.offset());
- }
- inline const Struct *GetFieldStruct(const Struct &structure,
- const reflection::Field &field) {
- assert(field.type()->base_type() == reflection::Obj);
- return structure.GetStruct<const Struct *>(field.offset());
- }
- 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);
- inline int64_t GetAnyFieldI(const Table &table,
- const reflection::Field &field) {
- auto field_ptr = table.GetAddressOf(field.offset());
- return field_ptr ? GetAnyValueI(field.type()->base_type(), field_ptr)
- : field.default_integer();
- }
- inline double GetAnyFieldF(const Table &table,
- const reflection::Field &field) {
- auto field_ptr = table.GetAddressOf(field.offset());
- return field_ptr ? GetAnyValueF(field.type()->base_type(), field_ptr)
- : field.default_real();
- }
- inline std::string GetAnyFieldS(const Table &table,
- const reflection::Field &field,
- const reflection::Schema *schema) {
- auto field_ptr = table.GetAddressOf(field.offset());
- return field_ptr ? GetAnyValueS(field.type()->base_type(), field_ptr, schema,
- field.type()->index())
- : "";
- }
- inline int64_t GetAnyFieldI(const Struct &st,
- const reflection::Field &field) {
- return GetAnyValueI(field.type()->base_type(),
- st.GetAddressOf(field.offset()));
- }
- inline double GetAnyFieldF(const Struct &st,
- const reflection::Field &field) {
- return GetAnyValueF(field.type()->base_type(),
- st.GetAddressOf(field.offset()));
- }
- inline std::string GetAnyFieldS(const Struct &st,
- const reflection::Field &field) {
- return GetAnyValueS(field.type()->base_type(),
- st.GetAddressOf(field.offset()), nullptr, -1);
- }
- inline int64_t GetAnyVectorElemI(const VectorOfAny *vec,
- reflection::BaseType elem_type, size_t i) {
- return GetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i);
- }
- inline double GetAnyVectorElemF(const VectorOfAny *vec,
- reflection::BaseType elem_type, size_t i) {
- return GetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i);
- }
- inline std::string GetAnyVectorElemS(const VectorOfAny *vec,
- reflection::BaseType elem_type, size_t i) {
- return GetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i,
- nullptr, -1);
- }
- template<typename T> T *GetAnyVectorElemPointer(const VectorOfAny *vec,
- size_t i) {
- auto elem_ptr = vec->Data() + sizeof(uoffset_t) * i;
- return (T *)(elem_ptr + ReadScalar<uoffset_t>(elem_ptr));
- }
- template<typename T> T *GetAnyVectorElemAddressOf(const VectorOfAny *vec,
- size_t i,
- size_t elem_size) {
-
- return (T *)(vec->Data() + elem_size * i);
- }
- template<typename T> T *GetAnyFieldAddressOf(const Table &table,
- const reflection::Field &field) {
- return (T *)table.GetAddressOf(field.offset());
- }
- template<typename T> T *GetAnyFieldAddressOf(const Struct &st,
- const reflection::Field &field) {
- return (T *)st.GetAddressOf(field.offset());
- }
- template<typename T> bool SetField(Table *table, const reflection::Field &field,
- T val) {
- assert(sizeof(T) == GetTypeSize(field.type()->base_type()));
- return table->SetField(field.offset(), 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);
- inline bool SetAnyFieldI(Table *table, const reflection::Field &field,
- int64_t val) {
- auto field_ptr = table->GetAddressOf(field.offset());
- if (!field_ptr) return false;
- SetAnyValueI(field.type()->base_type(), field_ptr, val);
- return true;
- }
- inline bool SetAnyFieldF(Table *table, const reflection::Field &field,
- double val) {
- auto field_ptr = table->GetAddressOf(field.offset());
- if (!field_ptr) return false;
- SetAnyValueF(field.type()->base_type(), field_ptr, val);
- return true;
- }
- inline bool SetAnyFieldS(Table *table, const reflection::Field &field,
- const char *val) {
- auto field_ptr = table->GetAddressOf(field.offset());
- if (!field_ptr) return false;
- SetAnyValueS(field.type()->base_type(), field_ptr, val);
- return true;
- }
- inline void SetAnyFieldI(Struct *st, const reflection::Field &field,
- int64_t val) {
- SetAnyValueI(field.type()->base_type(), st->GetAddressOf(field.offset()),
- val);
- }
- inline void SetAnyFieldF(Struct *st, const reflection::Field &field,
- double val) {
- SetAnyValueF(field.type()->base_type(), st->GetAddressOf(field.offset()),
- val);
- }
- inline void SetAnyFieldS(Struct *st, const reflection::Field &field,
- const char *val) {
- SetAnyValueS(field.type()->base_type(), st->GetAddressOf(field.offset()),
- val);
- }
- inline void SetAnyVectorElemI(VectorOfAny *vec, reflection::BaseType elem_type,
- size_t i, int64_t val) {
- SetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
- }
- inline void SetAnyVectorElemF(VectorOfAny *vec, reflection::BaseType elem_type,
- size_t i, double val) {
- SetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
- }
- inline void SetAnyVectorElemS(VectorOfAny *vec, reflection::BaseType elem_type,
- size_t i, const char *val) {
- SetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val);
- }
- template<typename T, typename U> class pointer_inside_vector {
- public:
- pointer_inside_vector(T *ptr, std::vector<U> &vec)
- : offset_(reinterpret_cast<uint8_t *>(ptr) -
- reinterpret_cast<uint8_t *>(vec.data())),
- vec_(vec) {}
- T *operator*() const {
- return reinterpret_cast<T *>(
- reinterpret_cast<uint8_t *>(vec_.data()) + offset_);
- }
- T *operator->() const {
- return operator*();
- }
- void operator=(const pointer_inside_vector &piv);
- private:
- size_t offset_;
- std::vector<U> &vec_;
- };
- template<typename T, typename U> pointer_inside_vector<T, U> piv(T *ptr,
- std::vector<U> &vec) {
- return pointer_inside_vector<T, U>(ptr, vec);
- }
- inline const char *UnionTypeFieldSuffix() { return "_type"; }
- inline const reflection::Object &GetUnionType(
- const reflection::Schema &schema, const reflection::Object &parent,
- const reflection::Field &unionfield, const Table &table) {
- auto enumdef = schema.enums()->Get(unionfield.type()->index());
-
- auto type_field = parent.fields()->LookupByKey(
- (unionfield.name()->str() + UnionTypeFieldSuffix()).c_str());
- assert(type_field);
- auto union_type = GetFieldI<uint8_t>(table, *type_field);
- auto enumval = enumdef->values()->LookupByKey(union_type);
- return *enumval->object();
- }
- 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);
- #ifndef FLATBUFFERS_CPP98_STL
- 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) {
- 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);
-
- for (int i = 0; i < delta_elem; i++) {
- auto loc = newelems + i * sizeof(T);
- auto is_scalar = std::is_scalar<T>::value;
- if (is_scalar) {
- WriteScalar(loc, val);
- } else {
- *reinterpret_cast<T *>(loc) = val;
- }
- }
- }
- #endif
- const uint8_t *AddFlatBuffer(std::vector<uint8_t> &flatbuf,
- const uint8_t *newbuf, size_t newlen);
- inline bool SetFieldT(Table *table, const reflection::Field &field,
- const uint8_t *val) {
- assert(sizeof(uoffset_t) == GetTypeSize(field.type()->base_type()));
- return table->SetPointer(field.offset(), 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);
- }
- #endif
|