diff --git a/BUILD.bazel b/BUILD.bazel index de910bc53..0ff3b234e 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -47,6 +47,7 @@ filegroup( "include/flatbuffers/code_generators.h", "include/flatbuffers/default_allocator.h", "include/flatbuffers/detached_buffer.h", + "include/flatbuffers/file_manager.h", "include/flatbuffers/flatbuffer_builder.h", "include/flatbuffers/flatbuffers.h", "include/flatbuffers/flex_flat_util.h", diff --git a/CMakeLists.txt b/CMakeLists.txt index 27d80859f..2b65c20e5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -127,6 +127,7 @@ set(FlatBuffers_Library_SRCS include/flatbuffers/default_allocator.h include/flatbuffers/detached_buffer.h include/flatbuffers/code_generator.h + include/flatbuffers/file_manager.h include/flatbuffers/flatbuffer_builder.h include/flatbuffers/flatbuffers.h include/flatbuffers/flexbuffers.h @@ -171,6 +172,9 @@ set(FlatBuffers_Compiler_SRCS src/idl_gen_grpc.cpp src/idl_gen_json_schema.cpp src/idl_gen_swift.cpp + src/file_name_saving_file_manager.cpp + src/file_binary_writer.cpp + src/file_writer.cpp src/idl_namer.h src/namer.h src/flatc.cpp diff --git a/include/flatbuffers/file_manager.h b/include/flatbuffers/file_manager.h new file mode 100644 index 000000000..069df5b88 --- /dev/null +++ b/include/flatbuffers/file_manager.h @@ -0,0 +1,48 @@ +/* + * Copyright 2023 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_FILE_MANAGER_H_ +#define FLATBUFFERS_FILE_MANAGER_H_ + +#include +#include + +#include "flatbuffers/util.h" + +namespace flatbuffers { + +// A File interface to write data to file by default or +// save only file names +class FileManager { + public: + FileManager() = default; + virtual ~FileManager() = default; + + virtual bool SaveFile(const std::string &absolute_file_name, + const std::string &content) = 0; + + virtual bool LoadFile(const std::string &absolute_file_name, + std::string *buf) = 0; + + private: + // Copying is not supported. + FileManager(const FileManager &) = delete; + FileManager &operator=(const FileManager &) = delete; +}; + +} // namespace flatbuffers + +#endif // FLATBUFFERS_FILE_MANAGER_H_ diff --git a/include/flatbuffers/flatbuffer_builder.h b/include/flatbuffers/flatbuffer_builder.h index a1d3d60a7..b9015d850 100644 --- a/include/flatbuffers/flatbuffer_builder.h +++ b/include/flatbuffers/flatbuffer_builder.h @@ -1184,7 +1184,8 @@ class FlatBufferBuilder { // Allocates space for a vector of structures. // Must be completed with EndVectorOfStructs(). template T *StartVectorOfStructs(size_t vector_size) { - StartVector(vector_size * sizeof(T) / AlignOf(), sizeof(T), AlignOf()); + StartVector(vector_size * sizeof(T) / AlignOf(), sizeof(T), + AlignOf()); return reinterpret_cast(buf_.make_space(vector_size * sizeof(T))); } diff --git a/include/flatbuffers/flatc.h b/include/flatbuffers/flatc.h index e6227d640..e98eb80d7 100644 --- a/include/flatbuffers/flatc.h +++ b/include/flatbuffers/flatc.h @@ -56,6 +56,7 @@ struct FlatCOptions { bool schema_binary = false; bool grpc_enabled = false; bool requires_bfbs = false; + bool file_names_only = false; std::vector> generators; }; diff --git a/include/flatbuffers/flexbuffers.h b/include/flatbuffers/flexbuffers.h index a0ee67003..8e8cac144 100644 --- a/include/flatbuffers/flexbuffers.h +++ b/include/flatbuffers/flexbuffers.h @@ -1424,12 +1424,10 @@ class Builder FLATBUFFERS_FINAL_CLASS { template static Type GetScalarType() { static_assert(flatbuffers::is_scalar::value, "Unrelated types"); - return flatbuffers::is_floating_point::value - ? FBT_FLOAT - : flatbuffers::is_same::value - ? FBT_BOOL - : (flatbuffers::is_unsigned::value ? FBT_UINT - : FBT_INT); + return flatbuffers::is_floating_point::value ? FBT_FLOAT + : flatbuffers::is_same::value + ? FBT_BOOL + : (flatbuffers::is_unsigned::value ? FBT_UINT : FBT_INT); } public: diff --git a/include/flatbuffers/minireflect.h b/include/flatbuffers/minireflect.h index 22f43fbab..1e04bfff0 100644 --- a/include/flatbuffers/minireflect.h +++ b/include/flatbuffers/minireflect.h @@ -408,7 +408,7 @@ inline std::string FlatBufferToString(const uint8_t *buffer, const TypeTable *type_table, bool multi_line = false, bool vector_delimited = true, - const std::string& indent = "") { + const std::string &indent = "") { ToStringVisitor tostring_visitor(multi_line ? "\n" : " ", false, indent, vector_delimited); IterateFlatBuffer(buffer, type_table, &tostring_visitor); diff --git a/include/flatbuffers/util.h b/include/flatbuffers/util.h index 6d0cd2c0c..a6bcf34b6 100644 --- a/include/flatbuffers/util.h +++ b/include/flatbuffers/util.h @@ -722,9 +722,10 @@ enum class Case { kSnake2 = 9, }; -// Convert the `input` string of case `input_case` to the specified `output_case`. +// Convert the `input` string of case `input_case` to the specified +// `output_case`. std::string ConvertCase(const std::string &input, Case output_case, - Case input_case = Case::kSnake); + Case input_case = Case::kSnake); } // namespace flatbuffers diff --git a/src/BUILD.bazel b/src/BUILD.bazel index 66c355d70..28d0868ce 100644 --- a/src/BUILD.bazel +++ b/src/BUILD.bazel @@ -69,6 +69,9 @@ cc_library( "bfbs_gen_nim.cpp", "bfbs_gen_nim.h", "bfbs_namer.h", + "file_binary_writer.cpp", + "file_name_saving_file_manager.cpp", + "file_writer.cpp", "flatc_main.cpp", "idl_gen_binary.cpp", "idl_gen_binary.h", diff --git a/src/file_binary_writer.cpp b/src/file_binary_writer.cpp new file mode 100644 index 000000000..69d83e77c --- /dev/null +++ b/src/file_binary_writer.cpp @@ -0,0 +1,49 @@ +/* + * Copyright 2023 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. + */ + +#include +#include +#include + +#include "flatbuffers/file_manager.h" + +namespace flatbuffers { + +class FileBinaryWriter : public FileManager { + public: + bool SaveFile(const std::string &absolute_file_name, + const std::string &content) override { + std::ofstream ofs(absolute_file_name, std::ofstream::binary); + if (!ofs.is_open()) return false; + ofs.write(content.c_str(), content.size()); + return !ofs.bad(); + } + + bool Loadfile(const std::string &absolute_file_name, std::string *output) { + if (DirExists(absolute_file_name.c_str())) return false; + std::ifstream ifs(absolute_file_name, std::ifstream::binary); + if (!ifs.is_open()) return false; + // The fastest way to read a file into a string. + ifs.seekg(0, std::ios::end); + auto size = ifs.tellg(); + (*output).resize(static_cast(size)); + ifs.seekg(0, std::ios::beg); + ifs.read(&(*output)[0], (*output).size()); + return !ifs.bad(); + } +}; + +} // namespace flatbuffers diff --git a/src/file_name_saving_file_manager.cpp b/src/file_name_saving_file_manager.cpp new file mode 100644 index 000000000..fc4a4aa1e --- /dev/null +++ b/src/file_name_saving_file_manager.cpp @@ -0,0 +1,49 @@ +/* + * Copyright 2023 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. + */ + +#include +#include +#include + +#include "flatbuffers/file_manager.h" + +namespace flatbuffers { + +class FileNameSavingFileManager : public FileManager { + public: + FileNameSavingFileManager(std::set file_names) + : file_names_(file_names) {} + + bool SaveFile(const std::string &absolute_file_name, + const std::string &content) override { + (void)content; + auto pair = file_names_.insert(absolute_file_name); + // pair.second indicates whether the insertion is + // successful or not. + return pair.second; + } + + bool Loadfile(const std::string &absolute_file_name, std::string *content) { + (void) absolute_file_name; + (void) content; + return false; + } + + private: + std::set file_names_; +}; + +} // namespace flatbuffers diff --git a/src/file_writer.cpp b/src/file_writer.cpp new file mode 100644 index 000000000..bd34545b0 --- /dev/null +++ b/src/file_writer.cpp @@ -0,0 +1,47 @@ +/* + * Copyright 2023 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. + */ + +#include +#include +#include + +#include "flatbuffers/file_manager.h" + +namespace flatbuffers { + +class FileWriter : public FileManager { + public: + bool SaveFile(const std::string &absolute_file_name, + const std::string &content) override { + std::ofstream ofs(absolute_file_name, std::ofstream::out); + if (!ofs.is_open()) return false; + ofs.write(content.c_str(), content.size()); + return !ofs.bad(); + } + + bool Loadfile(const std::string &absolute_file_name, std::string *output) { + if (DirExists(absolute_file_name.c_str())) return false; + std::ifstream ifs(absolute_file_name, std::ifstream::in); + if (!ifs.is_open()) return false; + // This is slower, but works correctly on all platforms for text files. + std::ostringstream oss; + oss << ifs.rdbuf(); + *output = oss.str(); + return !ifs.bad(); + } +}; + +} // namespace flatbuffers diff --git a/src/flatc.cpp b/src/flatc.cpp index 1cdfc3c16..a5dd0b1f3 100644 --- a/src/flatc.cpp +++ b/src/flatc.cpp @@ -250,6 +250,8 @@ const static FlatCOption flatc_options[] = { { "", "no-leak-private-annotation", "", "Prevents multiple type of annotations within a Fbs SCHEMA file. " "Currently this is required to generate private types in Rust" }, + { "", "file-names-only", "", + "Print out generated file names without writing to the files"}, }; auto cmp = [](FlatCOption a, FlatCOption b) { return a.long_opt < b.long_opt; }; @@ -653,6 +655,9 @@ FlatCOptions FlatCompiler::ParseFromCommandLineArguments(int argc, } else if (arg == "--annotate") { if (++argi >= argc) Error("missing path following: " + arg, true); options.annotate_schema = flatbuffers::PosixPath(argv[argi]); + } else if(arg == "--file-names-only") { + // TODO (khhn): Provide 2 implementation + options.file_names_only = true; } else { if (arg == "--proto") { opts.proto_mode = true; }