| # Copyright 2015 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. | |
| # General function to create FlatBuffer build rules for the given list of | |
| # schemas. | |
| # | |
| # flatbuffers_schemas: A list of flatbuffer schema files to process. | |
| # | |
| # schema_include_dirs: A list of schema file include directories, which will be | |
| # passed to flatc via the -I parameter. | |
| # | |
| # custom_target_name: The generated files will be added as dependencies for a | |
| # new custom target with this name. You should add that target as a dependency | |
| # for your main target to ensure these files are built. You can also retrieve | |
| # various properties from this target, such as GENERATED_INCLUDES_DIR, | |
| # BINARY_SCHEMAS_DIR, and COPY_TEXT_SCHEMAS_DIR. | |
| # | |
| # additional_dependencies: A list of additional dependencies that you'd like | |
| # all generated files to depend on. Pass in a blank string if you have none. | |
| # | |
| # generated_includes_dir: Where to generate the C++ header files for these | |
| # schemas. The generated includes directory will automatically be added to | |
| # CMake's include directories, and will be where generated header files are | |
| # placed. This parameter is optional; pass in empty string if you don't want to | |
| # generate include files for these schemas. | |
| # | |
| # binary_schemas_dir: If you specify an optional binary schema directory, binary | |
| # schemas will be generated for these schemas as well, and placed into the given | |
| # directory. | |
| # | |
| # copy_text_schemas_dir: If you want all text schemas (including schemas from | |
| # all schema include directories) copied into a directory (for example, if you | |
| # need them within your project to build JSON files), you can specify that | |
| # folder here. All text schemas will be copied to that folder. | |
| # | |
| # IMPORTANT: Make sure you quote all list arguments you pass to this function! | |
| # Otherwise CMake will only pass in the first element. | |
| # Example: build_flatbuffers("${fb_files}" "${include_dirs}" target_name ...) | |
| function(build_flatbuffers flatbuffers_schemas | |
| schema_include_dirs | |
| custom_target_name | |
| additional_dependencies | |
| generated_includes_dir | |
| binary_schemas_dir | |
| copy_text_schemas_dir) | |
| # Test if including from FindFlatBuffers | |
| if(FLATBUFFERS_FLATC_EXECUTABLE) | |
| set(FLATC_TARGET "") | |
| set(FLATC ${FLATBUFFERS_FLATC_EXECUTABLE}) | |
| elseif(TARGET flatbuffers::flatc) | |
| set(FLATC_TARGET flatbuffers::flatc) | |
| set(FLATC flatbuffers::flatc) | |
| else() | |
| set(FLATC_TARGET flatc) | |
| set(FLATC flatc) | |
| endif() | |
| set(FLATC_SCHEMA_ARGS --gen-mutable) | |
| if(FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS) | |
| set(FLATC_SCHEMA_ARGS | |
| ${FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS} | |
| ${FLATC_SCHEMA_ARGS} | |
| ) | |
| endif() | |
| set(working_dir "${CMAKE_CURRENT_SOURCE_DIR}") | |
| set(schema_glob "*.fbs") | |
| # Generate the include files parameters. | |
| set(include_params "") | |
| set(all_generated_files "") | |
| foreach (include_dir ${schema_include_dirs}) | |
| set(include_params -I ${include_dir} ${include_params}) | |
| if (NOT ${copy_text_schemas_dir} STREQUAL "") | |
| # Copy text schemas from dependent folders. | |
| file(GLOB_RECURSE dependent_schemas ${include_dir}/${schema_glob}) | |
| foreach (dependent_schema ${dependent_schemas}) | |
| file(COPY ${dependent_schema} DESTINATION ${copy_text_schemas_dir}) | |
| endforeach() | |
| endif() | |
| endforeach() | |
| foreach(schema ${flatbuffers_schemas}) | |
| get_filename_component(filename ${schema} NAME_WE) | |
| # For each schema, do the things we requested. | |
| if (NOT ${generated_includes_dir} STREQUAL "") | |
| set(generated_include ${generated_includes_dir}/${filename}_generated.h) | |
| add_custom_command( | |
| OUTPUT ${generated_include} | |
| COMMAND ${FLATC} ${FLATC_SCHEMA_ARGS} | |
| -o ${generated_includes_dir} | |
| ${include_params} | |
| -c ${schema} | |
| DEPENDS ${FLATC_TARGET} ${schema} ${additional_dependencies} | |
| WORKING_DIRECTORY "${working_dir}") | |
| list(APPEND all_generated_files ${generated_include}) | |
| endif() | |
| if (NOT ${binary_schemas_dir} STREQUAL "") | |
| set(binary_schema ${binary_schemas_dir}/${filename}.bfbs) | |
| add_custom_command( | |
| OUTPUT ${binary_schema} | |
| COMMAND ${FLATC} -b --schema | |
| -o ${binary_schemas_dir} | |
| ${include_params} | |
| ${schema} | |
| DEPENDS ${FLATC_TARGET} ${schema} ${additional_dependencies} | |
| WORKING_DIRECTORY "${working_dir}") | |
| list(APPEND all_generated_files ${binary_schema}) | |
| endif() | |
| if (NOT ${copy_text_schemas_dir} STREQUAL "") | |
| file(COPY ${schema} DESTINATION ${copy_text_schemas_dir}) | |
| endif() | |
| endforeach() | |
| # Create a custom target that depends on all the generated files. | |
| # This is the target that you can depend on to trigger all these | |
| # to be built. | |
| add_custom_target(${custom_target_name} | |
| DEPENDS ${all_generated_files} ${additional_dependencies}) | |
| # Register the include directory we are using. | |
| if (NOT ${generated_includes_dir} STREQUAL "") | |
| include_directories(${generated_includes_dir}) | |
| set_property(TARGET ${custom_target_name} | |
| PROPERTY GENERATED_INCLUDES_DIR | |
| ${generated_includes_dir}) | |
| endif() | |
| # Register the binary schemas dir we are using. | |
| if (NOT ${binary_schemas_dir} STREQUAL "") | |
| set_property(TARGET ${custom_target_name} | |
| PROPERTY BINARY_SCHEMAS_DIR | |
| ${binary_schemas_dir}) | |
| endif() | |
| # Register the text schema copy dir we are using. | |
| if (NOT ${copy_text_schemas_dir} STREQUAL "") | |
| set_property(TARGET ${custom_target_name} | |
| PROPERTY COPY_TEXT_SCHEMAS_DIR | |
| ${copy_text_schemas_dir}) | |
| endif() | |
| endfunction() | |
| # Creates a target that can be linked against that generates flatbuffer headers. | |
| # | |
| # This function takes a target name and a list of schemas. You can also specify | |
| # other flagc flags using the FLAGS option to change the behavior of the flatc | |
| # tool. | |
| # | |
| # When the target_link_libraries is done within a different directory than | |
| # flatbuffers_generate_headers is called, then the target should also be dependent | |
| # the custom generation target called GENERATE_<TARGET>. | |
| # | |
| # Arguments: | |
| # TARGET: The name of the target to generate. | |
| # SCHEMAS: The list of schema files to generate code for. | |
| # BINARY_SCHEMAS_DIR: Optional. The directory in which to generate binary | |
| # schemas. Binary schemas will only be generated if a path is provided. | |
| # INCLUDE: Optional. Search for includes in the specified paths. (Use this | |
| # instead of "-I <path>" and the FLAGS option so that CMake is aware of | |
| # the directories that need to be searched). | |
| # INCLUDE_PREFIX: Optional. The directory in which to place the generated | |
| # files. Use this instead of the --include-prefix option. | |
| # FLAGS: Optional. A list of any additional flags that you would like to pass | |
| # to flatc. | |
| # | |
| # Example: | |
| # | |
| # flatbuffers_generate_headers( | |
| # TARGET my_generated_headers_target | |
| # INCLUDE_PREFIX ${MY_INCLUDE_PREFIX}" | |
| # SCHEMAS ${MY_SCHEMA_FILES} | |
| # BINARY_SCHEMAS_DIR "${MY_BINARY_SCHEMA_DIRECTORY}" | |
| # FLAGS --gen-object-api) | |
| # | |
| # target_link_libraries(MyExecutableTarget | |
| # PRIVATE my_generated_headers_target | |
| # ) | |
| # | |
| # Optional (only needed within different directory): | |
| # add_dependencies(app GENERATE_my_generated_headers_target) | |
| function(flatbuffers_generate_headers) | |
| # Parse function arguments. | |
| set(options) | |
| set(one_value_args | |
| "TARGET" | |
| "INCLUDE_PREFIX" | |
| "BINARY_SCHEMAS_DIR") | |
| set(multi_value_args | |
| "SCHEMAS" | |
| "INCLUDE" | |
| "FLAGS") | |
| cmake_parse_arguments( | |
| PARSE_ARGV 0 | |
| FLATBUFFERS_GENERATE_HEADERS | |
| "${options}" | |
| "${one_value_args}" | |
| "${multi_value_args}") | |
| # Test if including from FindFlatBuffers | |
| if(FLATBUFFERS_FLATC_EXECUTABLE) | |
| set(FLATC_TARGET "") | |
| set(FLATC ${FLATBUFFERS_FLATC_EXECUTABLE}) | |
| elseif(TARGET flatbuffers::flatc) | |
| set(FLATC_TARGET flatbuffers::flatc) | |
| set(FLATC flatbuffers::flatc) | |
| else() | |
| set(FLATC_TARGET flatc) | |
| set(FLATC flatc) | |
| endif() | |
| set(working_dir "${CMAKE_CURRENT_SOURCE_DIR}") | |
| # Generate the include files parameters. | |
| set(include_params "") | |
| foreach (include_dir ${FLATBUFFERS_GENERATE_HEADERS_INCLUDE}) | |
| set(include_params -I ${include_dir} ${include_params}) | |
| endforeach() | |
| # Create a directory to place the generated code. | |
| set(generated_target_dir "${CMAKE_CURRENT_BINARY_DIR}/${FLATBUFFERS_GENERATE_HEADERS_TARGET}") | |
| set(generated_include_dir "${generated_target_dir}") | |
| if (NOT ${FLATBUFFERS_GENERATE_HEADERS_INCLUDE_PREFIX} STREQUAL "") | |
| set(generated_include_dir "${generated_include_dir}/${FLATBUFFERS_GENERATE_HEADERS_INCLUDE_PREFIX}") | |
| list(APPEND FLATBUFFERS_GENERATE_HEADERS_FLAGS | |
| "--include-prefix" ${FLATBUFFERS_GENERATE_HEADERS_INCLUDE_PREFIX}) | |
| endif() | |
| set(generated_custom_commands) | |
| # Create rules to generate the code for each schema. | |
| foreach(schema ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS}) | |
| get_filename_component(filename ${schema} NAME_WE) | |
| set(generated_include "${generated_include_dir}/${filename}_generated.h") | |
| # Generate files for grpc if needed | |
| set(generated_source_file) | |
| if("${FLATBUFFERS_GENERATE_HEADERS_FLAGS}" MATCHES "--grpc") | |
| # Check if schema file contain a rpc_service definition | |
| file(STRINGS ${schema} has_grpc REGEX "rpc_service") | |
| if(has_grpc) | |
| list(APPEND generated_include "${generated_include_dir}/${filename}.grpc.fb.h") | |
| set(generated_source_file "${generated_include_dir}/${filename}.grpc.fb.cc") | |
| endif() | |
| endif() | |
| add_custom_command( | |
| OUTPUT ${generated_include} ${generated_source_file} | |
| COMMAND ${FLATC} ${FLATC_ARGS} | |
| -o ${generated_include_dir} | |
| ${include_params} | |
| -c ${schema} | |
| ${FLATBUFFERS_GENERATE_HEADERS_FLAGS} | |
| DEPENDS ${FLATC_TARGET} ${schema} | |
| WORKING_DIRECTORY "${working_dir}" | |
| COMMENT "Building ${schema} flatbuffers...") | |
| list(APPEND all_generated_header_files ${generated_include}) | |
| list(APPEND all_generated_source_files ${generated_source_file}) | |
| list(APPEND generated_custom_commands "${generated_include}" "${generated_source_file}") | |
| # Geneate the binary flatbuffers schemas if instructed to. | |
| if (NOT ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR} STREQUAL "") | |
| set(binary_schema | |
| "${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR}/${filename}.bfbs") | |
| add_custom_command( | |
| OUTPUT ${binary_schema} | |
| COMMAND ${FLATC} -b --schema | |
| -o ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR} | |
| ${include_params} | |
| ${schema} | |
| DEPENDS ${FLATC_TARGET} ${schema} | |
| WORKING_DIRECTORY "${working_dir}") | |
| list(APPEND generated_custom_commands "${binary_schema}") | |
| list(APPEND all_generated_binary_files ${binary_schema}) | |
| endif() | |
| endforeach() | |
| # Create an additional target as add_custom_command scope is only within same directory (CMakeFile.txt) | |
| set(generate_target GENERATE_${FLATBUFFERS_GENERATE_HEADERS_TARGET}) | |
| add_custom_target(${generate_target} ALL | |
| DEPENDS ${generated_custom_commands} | |
| COMMENT "Generating flatbuffer target ${FLATBUFFERS_GENERATE_HEADERS_TARGET}") | |
| # Set up interface library | |
| add_library(${FLATBUFFERS_GENERATE_HEADERS_TARGET} INTERFACE) | |
| target_sources( | |
| ${FLATBUFFERS_GENERATE_HEADERS_TARGET} | |
| INTERFACE | |
| ${all_generated_header_files} | |
| ${all_generated_binary_files} | |
| ${all_generated_source_files} | |
| ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS}) | |
| add_dependencies( | |
| ${FLATBUFFERS_GENERATE_HEADERS_TARGET} | |
| ${FLATC_TARGET}) | |
| target_include_directories( | |
| ${FLATBUFFERS_GENERATE_HEADERS_TARGET} | |
| INTERFACE ${generated_target_dir}) | |
| # Organize file layout for IDEs. | |
| source_group( | |
| TREE "${generated_target_dir}" | |
| PREFIX "Flatbuffers/Generated/Headers Files" | |
| FILES ${all_generated_header_files}) | |
| source_group( | |
| TREE "${generated_target_dir}" | |
| PREFIX "Flatbuffers/Generated/Source Files" | |
| FILES ${all_generated_source_files}) | |
| source_group( | |
| TREE ${working_dir} | |
| PREFIX "Flatbuffers/Schemas" | |
| FILES ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS}) | |
| if (NOT ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR} STREQUAL "") | |
| source_group( | |
| TREE "${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR}" | |
| PREFIX "Flatbuffers/Generated/Binary Schemas" | |
| FILES ${all_generated_binary_files}) | |
| endif() | |
| endfunction() | |
| # Creates a target that can be linked against that generates flatbuffer binaries | |
| # from json files. | |
| # | |
| # This function takes a target name and a list of schemas and Json files. You | |
| # can also specify other flagc flags and options to change the behavior of the | |
| # flatc compiler. | |
| # | |
| # Adding this target to your executable ensurses that the flatbuffer binaries | |
| # are compiled before your executable is run. | |
| # | |
| # Arguments: | |
| # TARGET: The name of the target to generate. | |
| # JSON_FILES: The list of json files to compile to flatbuffers binaries. | |
| # SCHEMA: The flatbuffers schema of the Json files to be compiled. | |
| # INCLUDE: Optional. Search for includes in the specified paths. (Use this | |
| # instead of "-I <path>" and the FLAGS option so that CMake is aware of | |
| # the directories that need to be searched). | |
| # OUTPUT_DIR: The directly where the generated flatbuffers binaries should be | |
| # placed. | |
| # FLAGS: Optional. A list of any additional flags that you would like to pass | |
| # to flatc. | |
| # | |
| # Example: | |
| # | |
| # flatbuffers_generate_binary_files( | |
| # TARGET my_binary_data | |
| # SCHEMA "${MY_SCHEMA_DIR}/my_example_schema.fbs" | |
| # JSON_FILES ${MY_JSON_FILES} | |
| # OUTPUT_DIR "${MY_BINARY_DATA_DIRECTORY}" | |
| # FLAGS --strict-json) | |
| # | |
| # target_link_libraries(MyExecutableTarget | |
| # PRIVATE my_binary_data | |
| # ) | |
| function(flatbuffers_generate_binary_files) | |
| # Parse function arguments. | |
| set(options) | |
| set(one_value_args | |
| "TARGET" | |
| "SCHEMA" | |
| "OUTPUT_DIR") | |
| set(multi_value_args | |
| "JSON_FILES" | |
| "INCLUDE" | |
| "FLAGS") | |
| cmake_parse_arguments( | |
| PARSE_ARGV 0 | |
| FLATBUFFERS_GENERATE_BINARY_FILES | |
| "${options}" | |
| "${one_value_args}" | |
| "${multi_value_args}") | |
| # Test if including from FindFlatBuffers | |
| if(FLATBUFFERS_FLATC_EXECUTABLE) | |
| set(FLATC_TARGET "") | |
| set(FLATC ${FLATBUFFERS_FLATC_EXECUTABLE}) | |
| elseif(TARGET flatbuffers::flatc) | |
| set(FLATC_TARGET flatbuffers::flatc) | |
| set(FLATC flatbuffers::flatc) | |
| else() | |
| set(FLATC_TARGET flatc) | |
| set(FLATC flatc) | |
| endif() | |
| set(working_dir "${CMAKE_CURRENT_SOURCE_DIR}") | |
| # Generate the include files parameters. | |
| set(include_params "") | |
| foreach (include_dir ${FLATBUFFERS_GENERATE_BINARY_FILES_INCLUDE}) | |
| set(include_params -I ${include_dir} ${include_params}) | |
| endforeach() | |
| # Create rules to generate the flatbuffers binary for each json file. | |
| foreach(json_file ${FLATBUFFERS_GENERATE_BINARY_FILES_JSON_FILES}) | |
| get_filename_component(filename ${json_file} NAME_WE) | |
| set(generated_binary_file "${FLATBUFFERS_GENERATE_BINARY_FILES_OUTPUT_DIR}/${filename}.bin") | |
| add_custom_command( | |
| OUTPUT ${generated_binary_file} | |
| COMMAND ${FLATC} ${FLATC_ARGS} | |
| -o ${FLATBUFFERS_GENERATE_BINARY_FILES_OUTPUT_DIR} | |
| ${include_params} | |
| -b ${FLATBUFFERS_GENERATE_BINARY_FILES_SCHEMA} ${json_file} | |
| ${FLATBUFFERS_GENERATE_BINARY_FILES_FLAGS} | |
| DEPENDS ${FLATC_TARGET} ${json_file} | |
| WORKING_DIRECTORY "${working_dir}" | |
| COMMENT "Building ${json_file} binary flatbuffers...") | |
| list(APPEND all_generated_binary_files ${generated_binary_file}) | |
| endforeach() | |
| # Set up interface library | |
| add_library(${FLATBUFFERS_GENERATE_BINARY_FILES_TARGET} INTERFACE) | |
| target_sources( | |
| ${FLATBUFFERS_GENERATE_BINARY_FILES_TARGET} | |
| INTERFACE | |
| ${all_generated_binary_files} | |
| ${FLATBUFFERS_GENERATE_BINARY_FILES_JSON_FILES} | |
| ${FLATBUFFERS_GENERATE_BINARY_FILES_SCHEMA}) | |
| add_dependencies( | |
| ${FLATBUFFERS_GENERATE_BINARY_FILES_TARGET} | |
| ${FLATC}) | |
| # Organize file layout for IDEs. | |
| source_group( | |
| TREE ${working_dir} | |
| PREFIX "Flatbuffers/JSON Files" | |
| FILES ${FLATBUFFERS_GENERATE_BINARY_FILES_JSON_FILES}) | |
| source_group( | |
| TREE ${working_dir} | |
| PREFIX "Flatbuffers/Schemas" | |
| FILES ${FLATBUFFERS_GENERATE_BINARY_FILES_SCHEMA}) | |
| source_group( | |
| TREE ${FLATBUFFERS_GENERATE_BINARY_FILES_OUTPUT_DIR} | |
| PREFIX "Flatbuffers/Generated/Binary Files" | |
| FILES ${all_generated_binary_files}) | |
| endfunction() |