diff --git a/CMakeLists.txt b/CMakeLists.txt
index d74123adea19b4557d3eba1639fc2ecd35594e17..d3c6a7afba6ffb197b73e71895e8905f57982114 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,6 +24,7 @@ endif()
set(FlatBuffers_Library_SRCS
include/flatbuffers/code_generators.h
+ include/flatbuffers/base.h
include/flatbuffers/flatbuffers.h
include/flatbuffers/hash.h
include/flatbuffers/idl.h
@@ -31,6 +32,7 @@ set(FlatBuffers_Library_SRCS
include/flatbuffers/reflection.h
include/flatbuffers/reflection_generated.h
include/flatbuffers/flexbuffers.h
+ include/flatbuffers/registry.h
src/code_generators.cpp
src/idl_parser.cpp
src/idl_gen_text.cpp
diff --git a/include/flatbuffers/flatbuffers.h b/include/flatbuffers/flatbuffers.h
index 2f4e3cf15d79a9b7af305fb7bb5142b947f0bbf6..4ca829547257cd1654f6f025df6c9f0dc25d774e 100644
--- a/include/flatbuffers/flatbuffers.h
+++ b/include/flatbuffers/flatbuffers.h
@@ -431,6 +431,9 @@ class DefaultAllocator : public Allocator {
// the DetachedBuffer can manage the memory lifetime.
class DetachedBuffer {
public:
+ DetachedBuffer() : allocator_(nullptr), own_allocator_(false), buf_(nullptr),
+ reserved_(0), cur_(nullptr), size_(0) {}
+
DetachedBuffer(Allocator *allocator, bool own_allocator, uint8_t *buf,
size_t reserved, uint8_t *cur, size_t sz)
: allocator_(allocator), own_allocator_(own_allocator), buf_(buf),
@@ -442,7 +445,6 @@ class DetachedBuffer {
: allocator_(other.allocator_), own_allocator_(other.own_allocator_),
buf_(other.buf_), reserved_(other.reserved_), cur_(other.cur_),
size_(other.size_) {
- assert(allocator_);
other.allocator_ = nullptr;
other.own_allocator_ = false;
other.buf_ = nullptr;
@@ -462,17 +464,14 @@ class DetachedBuffer {
}
const uint8_t *data() const {
- assert(cur_);
return cur_;
}
uint8_t *data() {
- assert(cur_);
return cur_;
}
size_t size() const {
- assert(cur_);
return size_;
}
diff --git a/include/flatbuffers/registry.h b/include/flatbuffers/registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a227682da50603c1cd38636d7346f7f85bdd476
--- /dev/null
+++ b/include/flatbuffers/registry.h
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLATBUFFERS_REGISTRY_H_
+#define FLATBUFFERS_REGISTRY_H_
+
+#include "flatbuffers/idl.h"
+
+namespace flatbuffers {
+
+// Convenience class to easily parse or generate text for arbitrary FlatBuffers.
+// Simply pre-populate it with all schema filenames that may be in use, and
+// This class will look them up using the file_identifier declared in the
+// schema.
+class Registry {
+ public:
+ // Call this for all schemas that may be in use. The identifier has
+ // a function in the generated code, e.g. MonsterIdentifier().
+ void Register(const char *file_identifier, const char *schema_path) {
+ Schema schema;
+ schema.path_ = schema_path;
+ schemas_[file_identifier] = schema;
+ }
+
+ // Generate text from an arbitrary FlatBuffer by looking up its
+ // file_identifier in the registry.
+ bool FlatBufferToText(const uint8_t *flatbuf, size_t len,
+ std::string *dest) {
+ // Get the identifier out of the buffer.
+ // If the buffer is truncated, exit.
+ if (len < sizeof(uoffset_t) +
+ FlatBufferBuilder::kFileIdentifierLength) {
+ lasterror_ = "buffer truncated";
+ return false;
+ }
+ std::string ident(reinterpret_cast<const char *>(flatbuf) +
+ sizeof(uoffset_t),
+ FlatBufferBuilder::kFileIdentifierLength);
+ // Load and parse the schema.
+ Parser parser;
+ if (!LoadSchema(ident, &parser)) return false;
+ // Now we're ready to generate text.
+ if (!GenerateText(parser, flatbuf, dest)) {
+ lasterror_ = "unable to generate text for FlatBuffer binary";
+ return false;
+ }
+ return true;
+ }
+
+ // Converts a binary buffer to text using one of the schemas in the registry,
+ // use the file_identifier to indicate which.
+ // If DetachedBuffer::data() is null then parsing failed.
+ DetachedBuffer TextToFlatBuffer(const char *text,
+ const char *file_identifier) {
+ // Load and parse the schema.
+ Parser parser;
+ if (!LoadSchema(file_identifier, &parser)) return DetachedBuffer();
+ // Parse the text.
+ if (!parser.Parse(text)) {
+ lasterror_ = parser.error_;
+ return DetachedBuffer();
+ }
+ // We have a valid FlatBuffer. Detach it from the builder and return.
+ return parser.builder_.ReleaseBufferPointer();
+ }
+
+ // Modify any parsing / output options used by the other functions.
+ void SetOptions(const IDLOptions &opts) { opts_ = opts; }
+
+ // If schemas used contain include statements, call this function for every
+ // directory the parser should search them for.
+ void AddIncludeDirectory(const char *path) {
+ include_paths_.push_back(path);
+ }
+
+ // Returns a human readable error if any of the above functions fail.
+ const std::string &GetLastError() { return lasterror_; }
+
+ private:
+ bool LoadSchema(const std::string &ident, Parser *parser) {
+ // Find the schema, if not, exit.
+ auto it = schemas_.find(ident);
+ if (it == schemas_.end()) {
+ // Don't attach the identifier, since it may not be human readable.
+ lasterror_ = "identifier for this buffer not in the registry";
+ return false;
+ }
+ auto &schema = it->second;
+ // Load the schema from disk. If not, exit.
+ std::string schematext;
+ if (!LoadFile(schema.path_.c_str(), false, &schematext)) {
+ lasterror_ = "could not load schema: " + schema.path_;
+ return false;
+ }
+ // Parse schema.
+ parser->opts = opts_;
+ if (!parser->Parse(schematext.c_str(), include_paths_.data(),
+ schema.path_.c_str())) {
+ lasterror_ = parser->error_;
+ return false;
+ }
+ return true;
+ }
+
+ struct Schema {
+ std::string path_;
+ // TODO(wvo) optionally cache schema file or parsed schema here.
+ };
+
+ std::string lasterror_;
+ IDLOptions opts_;
+ std::vector<const char *> include_paths_;
+ std::map<std::string, Schema> schemas_;
+};
+
+} // namespace flatbuffers
+
+#endif // FLATBUFFERS_REGISTRY_H_
diff --git a/tests/test.cpp b/tests/test.cpp
index f8f905de5db10a529f6a7243faa28b15dc97c4d0..2754d8a72d997e189589852a5f12ce6f1ef3a3b1 100644
--- a/tests/test.cpp
+++ b/tests/test.cpp
@@ -17,6 +17,7 @@
#include "flatbuffers/flatbuffers.h"
#include "flatbuffers/idl.h"
#include "flatbuffers/util.h"
+#include "flatbuffers/registry.h"
#include "monster_test_generated.h"
#include "namespace_test/namespace_test1_generated.h"
@@ -543,6 +544,31 @@ void ParseAndGenerateTextTest() {
printf("%s----------------\n%s", jsongen.c_str(), jsonfile.c_str());
TEST_NOTNULL(NULL);
}
+
+ // We can also do the above using the convenient Registry that knows about
+ // a set of file_identifiers mapped to schemas.
+ flatbuffers::Registry registry;
+ // Make sure schemas can find their includes.
+ registry.AddIncludeDirectory(test_data_path.c_str());
+ registry.AddIncludeDirectory(include_test_path.c_str());
+ // Call this with many schemas if possible.
+ registry.Register(MonsterIdentifier(),
+ (test_data_path + "monster_test.fbs").c_str());
+ // Now we got this set up, we can parse by just specifying the identifier,
+ // the correct schema will be loaded on the fly:
+ auto buf = registry.TextToFlatBuffer(jsonfile.c_str(),
+ MonsterIdentifier());
+ // If this fails, check registry.lasterror_.
+ TEST_NOTNULL(buf.data());
+ // Test the buffer, to be sure:
+ AccessFlatBufferTest(buf.data(), buf.size(), false);
+ // We can use the registry to turn this back into text, in this case it
+ // will get the file_identifier from the binary:
+ std::string text;
+ auto ok = registry.FlatBufferToText(buf.data(), buf.size(), &text);
+ // If this fails, check registry.lasterror_.
+ TEST_EQ(ok, true);
+ TEST_EQ_STR(text.c_str(), jsonfile.c_str());
}
void ReflectionTest(uint8_t *flatbuf, size_t length) {